jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

40 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `a6caa2f99786`

tarball

atagen <boss@atagen.co>2026-10-12 10:43 UTC

14 files changed+239-135

game: make every action pay for itself in its own currency

The wall-clock refractory period never bit, since any later request
lifted it and the bots ran it at zero, so exhaustion is now cleared by the
next HOLD at the cost of a turn and the warmth. Re-reading the thread no
longer ticks the floor clock, which made it the cheapest way off any
floor, and is capped at two live rolls per floor before the cached copy.
The towel warms once per cold spell unless the kettle has boiled, edging
chafes like a dry stroke and loops on the third edge of a floor, and
friction now climbs with intensity so the slicker lubes earn their price.

Caged rummaging costs the turn instead, so a caged floor cannot stall,
and the hotel and bathroom drawers give the lotion a home.

Modified file: src/config.rs−5 deletions@@ -5,7 +5,6 @@ use crate::secret::Secret;
 
 pub struct Config {
     pub addr: String,
-    pub refractory: Duration,
     pub secret: Secret,
     pub max_runs: usize,
     pub idle_ttl: Duration,
@@ -16,7 +15,6 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             addr: "127.0.0.1:6969".into(),
-            refractory: Duration::from_secs(30),
             secret: Secret::random(),
             max_runs: 10_000,
             idle_ttl: Duration::from_secs(6 * 60 * 60),
@@ -31,9 +29,6 @@ impl Config {
         let defaults = Self::default();
         Self {
             addr: var("JELQD_ADDR").unwrap_or(defaults.addr),
-            refractory: var("JELQD_REFRACTORY_SECS")
-                .and_then(|s| s.parse().ok())
-                .map_or(defaults.refractory, Duration::from_secs),
             secret: var("JELQD_SECRET").map_or(defaults.secret, |s| Secret::new(s.into_bytes())),
             oracle: match var("JELQD_ORACLE").as_deref() {
                 Some("clm") => OracleTemplate::Clm {

Modified file: src/game/balance.rs+3 additions@@ -70,6 +70,9 @@ pub const GREED_HOT: f64 = 2.0;
 pub const COCONUT_ODDS: u32 = 3;
 pub const ENERGY_ODDS: u32 = 5;
 pub const KITCHEN_ICE_ODDS: u32 = 8;
+pub const KETTLE_ODDS: u32 = 6;
+pub const ULI_READS: u8 = 2;
+pub const DRAWER_JAMS: u32 = 4;
 pub const KITCHEN_TOLD: u32 = 4;
 pub const KITCHEN_TELLINGS: u8 = 2;
 pub const WATERMELON: (u32, u32) = (2, 5);

Modified file: src/game/floors.rs+39 additions−9 deletions@@ -4,8 +4,8 @@ use serde_json::{Value, json};
 use super::{
     Cause, Elder, Floor, FloorState, Item, Outcome, Run,
     balance::{
-        EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, GREGS_LOCKER, KEY_IN_DRAWER,
-        RULER_IN_DRAWER, STARTING_EQ, SUSPICION_LIMIT, ZIP,
+        DRAWER_JAMS, EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, GREGS_LOCKER,
+        KEY_IN_DRAWER, RULER_IN_DRAWER, STARTING_EQ, SUSPICION_LIMIT, ZIP,
     },
     round2,
 };
@@ -142,6 +142,15 @@ impl Run {
                 self.decision("ruler", "Is there a ruler hiding in the drawer?"),
                 RULER_IN_DRAWER,
             );
+        let vaseline_here = self.floor == Floor::Bathroom
+            && first
+            && self.chance(
+                self.decision(
+                    "bathroom-vaseline",
+                    "Is it the vaseline behind the door lock, rather than the lotion?",
+                ),
+                2,
+            );
         let locker_open = self.floor == Floor::ChangingRoom
             && first
             && self.chance(
@@ -159,11 +168,14 @@ impl Run {
             }
             Floor::Bathroom if first => {
                 self.items.grant(Item::DoorLock);
-                self.items.grant(Item::Vaseline);
-                Ok(self.found(
-                    Item::DoorLock,
-                    "A door lock, which works once, and a tub of vaseline behind it.",
-                ))
+                let detail = if vaseline_here {
+                    self.items.grant(Item::Vaseline);
+                    "A door lock, which works once, and a tub of vaseline behind it."
+                } else {
+                    self.items.grant(Item::Lotion);
+                    "A door lock, which works once, and a bottle of lotion behind it."
+                };
+                Ok(self.found(Item::DoorLock, detail))
             }
             Floor::ChangingRoom if locker_open => {
                 self.items.grant(Item::BabyOil);
@@ -192,9 +204,10 @@ impl Run {
                 self.items.grant(Item::DndSign);
                 self.items.grant(Item::IcePack);
                 self.items.grant(Item::IcePack);
+                self.items.grant(Item::Lotion);
                 Ok(self.found(
                     Item::DndSign,
-                    "A Do Not Disturb sign, and two ice packs from the machine down the hall.",
+                    "A Do Not Disturb sign, two ice packs from the machine down the hall, and a complimentary lotion.",
                 ))
             }
             Floor::Forum if first => {
@@ -230,15 +243,32 @@ impl Run {
         .header(header::LOCATION, self.path("")))
     }
 
-    /// Searching while caged is noisy, and the key only turns up some of the time.
+    /// Searching while caged is noisy, costs the floor turn, and the key only turns up some of
+    /// the time. A jammed drawer takes a whole turn to work loose.
     fn rummage_for_key(&mut self) -> Outcome {
+        self.turn += 1;
+        self.here.turns += 1;
+        self.realise();
         let was_below = self.suspicion < SUSPICION_LIMIT;
         self.suspicion = (self.suspicion + 1).min(SUSPICION_LIMIT);
         self.maybe_summon_mum(was_below);
+        if self.here.drawer_jammed {
+            self.here.drawer_jammed = false;
+            self.notices
+                .push("The drawer comes loose. That took a while.");
+            return Outcome::empty(StatusCode::NO_CONTENT);
+        }
         if !self.chance(
             self.decision("key", "Does the drawer finally give up the cage key?"),
             KEY_IN_DRAWER,
         ) {
+            if self.chance(
+                self.decision("drawer-jams", "Has the drawer jammed on its runners?"),
+                DRAWER_JAMS,
+            ) {
+                self.here.drawer_jammed = true;
+                self.notices.push("The drawer has jammed.");
+            }
             return Outcome::empty(StatusCode::NO_CONTENT);
         }
         self.items.grant(Item::CageKey);

Modified file: src/game/forum.rs+26 additions−20 deletions@@ -1,9 +1,11 @@
+use std::time::SystemTime;
+
 use axum::http::{StatusCode, header};
 use serde_json::{Value, json};
 
 use super::{
     Cause, Elder, Floor, Outcome, Run, Story,
-    balance::{EXAGGERATION, PATIENCE, SUSPICION_LIMIT, ULI_ODDS},
+    balance::{EXAGGERATION, PATIENCE, ULI_ODDS, ULI_READS},
     body::exaggeration,
     honest, parse_credentials,
 };
@@ -21,6 +23,13 @@ date,length,girth,technique,notes,honest?
 2009-06-14,7.50,5.50,wet,progress is slow but real,no
 ";
 
+fn nothing_new() -> Outcome {
+    Outcome::empty(StatusCode::NOT_MODIFIED).header(
+        header::WARNING,
+        r#"199 - "Nothing new has been posted since 2009.""#,
+    )
+}
+
 pub fn forum_thread() -> Value {
     json!({
         "title": "The definitive jelqing FAQ (updated 2009)",
@@ -109,7 +118,8 @@ impl Run {
         )
     }
 
-    /// Opening the thread again costs the turn, and each read may finally surface the reply.
+    /// Re-reading is free. Each floor gets a couple of live reads that may surface the reply,
+    /// after which the forum is down and the browser serves what it kept.
     pub fn read_thread(&mut self) -> Result<Outcome, Problem> {
         if self.story == Story::Pending {
             return Ok(self.branch_offer());
@@ -121,20 +131,21 @@ impl Run {
                 "There is no thread to re-read. Nobody has mentioned a forum yet.",
             ));
         }
-        self.touch();
-        self.turn += 1;
-        self.here.turns += 1;
         self.end_kitchen_visit();
-        self.realise();
-        if self.chance(
-            self.decision(
-                "rupture",
-                "Does the third read of the same thread rupture something?",
-            ),
-            self.rupture_odds(),
-        ) {
-            return Err(self.rupture());
+        if self.uli_taught {
+            return Ok(Outcome::json(StatusCode::OK, forum_thread()));
         }
+        if self.here.thread_rolls >= ULI_READS {
+            let age = httpdate::parse_http_date(ELDER_LAST_MODIFIED)
+                .ok()
+                .and_then(|posted| SystemTime::now().duration_since(posted).ok())
+                .map_or(0, |age| age.as_secs());
+            return Ok(Outcome::json(StatusCode::OK, forum_thread())
+                .header(header::AGE, age.to_string())
+                .header(header::WARNING, r#"112 - "Disconnected operation""#));
+        }
+        self.here.thread_rolls += 1;
+        self.touch();
         if self.chance(
             self.decision(
                 "teach-uli",
@@ -149,12 +160,7 @@ impl Run {
             )
             .header(header::LOCATION, self.path("/techniques")));
         }
-        let was_below = self.suspicion < SUSPICION_LIMIT;
-        self.settle(was_below);
-        Ok(Outcome::empty(StatusCode::NOT_MODIFIED).header(
-            header::WARNING,
-            r#"199 - "Nothing new has been posted since 2009.""#,
-        ))
+        Ok(nothing_new())
     }
 
     fn elder_strike(&mut self, problem: Problem) -> Problem {

Modified file: src/game/kitchen.rs+14 additions−3 deletions@@ -4,7 +4,7 @@ use serde_json::json;
 use super::{
     Cause, Floor, Item, Outcome, Run, Story,
     balance::{
-        CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TELLINGS,
+        CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KETTLE_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TELLINGS,
         KITCHEN_TOLD, MELON_SHAME, RUPTURE_LINE, SUSPICION_LIMIT, WATERMELON,
     },
 };
@@ -41,19 +41,24 @@ impl Run {
             return Err(self.rupture());
         }
         let was_below = self.suspicion < SUSPICION_LIMIT;
-        // One draw of 120 keeps the marginals at the documented 1 in 3, 1 in 5 and 1 in 8.
+        // One draw of 120 keeps the marginals at the documented 1 in 3, 1 in 5, 1 in 8 and 1 in 6.
         let loot = self.oracle.pick(
             self.decision("loot", "What does the fridge give up on this raid?"),
             &[
                 120 / COCONUT_ODDS,
                 120 / ENERGY_ODDS,
                 120 / KITCHEN_ICE_ODDS,
-                120 - (120 / COCONUT_ODDS + 120 / ENERGY_ODDS + 120 / KITCHEN_ICE_ODDS),
+                120 / KETTLE_ODDS,
+                120 - (120 / COCONUT_ODDS
+                    + 120 / ENERGY_ODDS
+                    + 120 / KITCHEN_ICE_ODDS
+                    + 120 / KETTLE_ODDS),
             ],
             &[
                 "A jar of coconut oil, half of it already gone.",
                 "An energy drink, cold and faintly alarming.",
                 "An ice pack, buried under the peas.",
+                "The kettle has just boiled.",
                 "Nothing. The fridge is ordinary.",
             ],
         );
@@ -86,6 +91,12 @@ impl Run {
                 StatusCode::OK,
                 json!({ "detail": "An ice pack, buried under the peas." }),
             ))
+        } else if loot == 3 {
+            self.here.kettle_boiled = true;
+            Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "The kettle has just boiled. The towel can be warmed once more." }),
+            ))
         } else {
             Ok(Outcome::empty(StatusCode::NO_CONTENT))
         };

Modified file: src/game/mod.rs+17 additions−25 deletions@@ -26,10 +26,10 @@ pub use techniques::{LUBRICANTS, Lube, Technique};
 
 use std::{
     hash::{DefaultHasher, Hash, Hasher},
-    time::{Duration, Instant, SystemTime},
+    time::{Instant, SystemTime},
 };
 
-use axum::http::{StatusCode, header};
+use axum::http::StatusCode;
 use serde_json::{Value, json};
 
 use crate::problem::Problem;
@@ -76,8 +76,7 @@ pub struct Run {
     pub seeded: bool,
     pub filmed_at: Option<SystemTime>,
     pub observed: Option<Observer>,
-    pub refractory: Duration,
-    pub refractory_until: Option<Instant>,
+    pub exhausted: bool,
     pub pending: Vec<Pending>,
     pub notices: Vec<&'static str>,
     pub ended: Option<Ending>,
@@ -188,8 +187,7 @@ impl Run {
             seeded: false,
             filmed_at: None,
             observed: None,
-            refractory: Duration::from_secs(30),
-            refractory_until: None,
+            exhausted: false,
             pending: Vec::new(),
             ended: None,
             last_seen: Instant::now(),
@@ -394,34 +392,28 @@ impl Run {
         cause.problem().with("turn", self.turn)
     }
 
-    /// Ends the refractory period once it has run out, whatever the request.
-    pub fn recover(&mut self, now: Instant) {
-        if self.refractory_until.is_some_and(|until| now >= until) {
-            self.refractory_until = None;
-            self.stamina = self.max_stamina();
-            self.reset_eq(STARTING_EQ);
-            self.warmed_up = false;
-            self.touch();
-        }
+    /// The refractory period is the next HOLD. It comes back with full stamina and nothing else.
+    fn recover(&mut self) {
+        self.exhausted = false;
+        self.stamina = self.max_stamina();
+        self.reset_eq(STARTING_EQ);
+        self.warmed_up = false;
     }
 
-    fn check_refractory(&mut self, now: Instant) -> Result<(), Problem> {
-        self.recover(now);
-        let Some(until) = self.refractory_until else {
+    fn check_exhausted(&self) -> Result<(), Problem> {
+        if !self.exhausted {
             return Ok(());
-        };
-        let seconds = until.saturating_duration_since(now).as_secs() + 1;
+        }
         Err(Problem::new(
             StatusCode::TOO_MANY_REQUESTS,
             "overtrained",
-            "Stamina is exhausted. The refractory period is in effect.",
-        )
-        .header(header::RETRY_AFTER, seconds.to_string()))
+            "Stamina is exhausted. HOLD for the refractory period.",
+        ))
     }
 
-    fn exhaust(&mut self, now: Instant) {
+    fn exhaust(&mut self) {
         self.stamina = 0;
-        self.refractory_until = Some(now + self.refractory);
+        self.exhausted = true;
     }
 
     fn realise(&mut self) {

Modified file: src/game/state.rs+3 additions@@ -136,6 +136,9 @@ impl Grip {
 pub struct FloorState {
     pub turns: u32,
     pub drawer_searched: bool,
+    pub drawer_jammed: bool,
+    pub kettle_boiled: bool,
+    pub thread_rolls: u8,
     pub edges: u8,
     pub temp_length: f64,
     pub teapot: bool,

Modified file: src/game/turn.rs+39 additions−40 deletions@@ -1,4 +1,4 @@
-use std::{fmt::Write as _, ops::ControlFlow, time::Instant};
+use std::{fmt::Write as _, ops::ControlFlow};
 
 use axum::http::{StatusCode, header};
 use serde_json::json;
@@ -25,9 +25,8 @@ impl Run {
         techniques: &[Technique],
         intensity: i32,
         lube: Option<Lube>,
-        now: Instant,
     ) -> Result<Outcome, Problem> {
-        self.check_refractory(now)?;
+        self.check_exhausted()?;
         if self.story == Story::Pending {
             return Ok(self.branch_offer());
         }
@@ -46,11 +45,9 @@ impl Run {
             ));
         }
         match *techniques {
-            [Technique::Utility(utility)] => self.utility(utility, lube, now),
-            [Technique::Training(training)] => self.single(training, intensity, lube, now),
-            [Technique::Training(a), Technique::Training(b)] => {
-                self.combo(a, b, intensity, lube, now)
-            }
+            [Technique::Utility(utility)] => self.utility(utility, lube),
+            [Technique::Training(training)] => self.single(training, intensity, lube),
+            [Technique::Training(a), Technique::Training(b)] => self.combo(a, b, intensity, lube),
             [_, _] => Err(Problem::new(
                 StatusCode::BAD_REQUEST,
                 "combo-invalid",
@@ -64,12 +61,7 @@ impl Run {
         }
     }
 
-    fn utility(
-        &mut self,
-        utility: Utility,
-        lube: Option<Lube>,
-        now: Instant,
-    ) -> Result<Outcome, Problem> {
+    fn utility(&mut self, utility: Utility, lube: Option<Lube>) -> Result<Outcome, Problem> {
         match utility {
             Utility::Warmup => return self.warm_up(),
             Utility::Ice => return self.ice(),
@@ -81,12 +73,9 @@ impl Run {
         self.ready(Technique::Utility(utility), lube)?;
         self.check_storage()?;
         self.floor_enemy()?;
-        if utility == Utility::Pump {
-            self.here.edges = 0;
-        }
         match utility {
-            Utility::Edge => self.edge(now),
-            _ => self.pump(now),
+            Utility::Edge => self.edge(),
+            _ => self.pump(),
         }
     }
 
@@ -95,16 +84,14 @@ impl Run {
         training: Training,
         intensity: i32,
         lube: Option<Lube>,
-        now: Instant,
     ) -> Result<Outcome, Problem> {
         self.ready(Technique::Training(training), lube)?;
         self.check_storage()?;
         self.lube_available(lube)?;
         self.floor_enemy()?;
-        self.here.edges = 0;
         self.take_lube(lube)?;
-        self.chafe(lube);
-        self.commit(intensity, lube, now, 1);
+        self.chafe(lube, intensity);
+        self.commit(intensity, lube, 1);
         if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
             return Ok(interrupted);
         }
@@ -121,7 +108,6 @@ impl Run {
         b: Training,
         intensity: i32,
         lube: Option<Lube>,
-        now: Instant,
     ) -> Result<Outcome, Problem> {
         if a == b {
             return Err(Problem::new(
@@ -135,10 +121,9 @@ impl Run {
         self.check_storage()?;
         self.lube_available(lube)?;
         self.floor_enemy()?;
-        self.here.edges = 0;
         self.take_lube(lube)?;
-        self.chafe(lube);
-        self.commit(intensity, lube, now, 2);
+        self.chafe(lube, intensity);
+        self.commit(intensity, lube, 2);
         for training in [a, b] {
             if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
                 return Ok(interrupted);
@@ -279,10 +264,8 @@ impl Run {
     }
 
     /// The techniques a JELQ could use right now without being refused before the roll.
-    pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {
-        let blocked = !self.floor.timed()
-            || self.items.cage
-            || self.refractory_until.is_some_and(|until| now < until);
+    pub fn techniques_now(&self) -> Vec<Technique> {
+        let blocked = !self.floor.timed() || self.items.cage || self.exhausted;
         if blocked {
             return Vec::new();
         }
@@ -346,12 +329,20 @@ impl Run {
         Ok(())
     }
 
-    fn chafe(&mut self, lube: Option<Lube>) {
-        let mut friction = match lube {
-            None => FRICTION_DRY,
-            Some(Lube::Spit) => FRICTION_SPIT,
-            Some(_) => 0,
+    pub(super) fn chafe(&mut self, lube: Option<Lube>, intensity: i32) {
+        let (base, slip) = match lube {
+            None => (FRICTION_DRY, 0),
+            Some(Lube::Spit) => (FRICTION_SPIT, 0),
+            Some(Lube::Lotion) => (0, 0),
+            Some(Lube::BabyOil | Lube::CoconutOil) => (0, 1),
+            Some(Lube::Vaseline) => (0, 2),
         };
+        let vigour = match intensity {
+            ..=5 => 0,
+            6..=8 => 1,
+            _ => 2,
+        };
+        let mut friction = (base + vigour - slip).max(0);
         if friction > 0 && self.jelq_grip.is_some_and(|grip| grip != self.grip) {
             friction -= FRICTION_GRIP;
         }
@@ -371,7 +362,7 @@ impl Run {
         }
     }
 
-    pub(super) fn commit(&mut self, intensity: i32, lube: Option<Lube>, now: Instant, cost: i32) {
+    pub(super) fn commit(&mut self, intensity: i32, lube: Option<Lube>, cost: i32) {
         self.touch();
         self.turn += 1;
         self.here.turns += 1;
@@ -382,7 +373,7 @@ impl Run {
         }
         self.stamina -= cost + i32::from(lube == Some(Lube::Lotion));
         if self.stamina <= 0 {
-            self.exhaust(now);
+            self.exhaust();
         }
         let chill = if self.floor == Floor::ChangingRoom {
             CHANGING_ROOM_CHILL
@@ -472,8 +463,7 @@ impl Run {
         self.eq > DANGER_EQ || self.stamina <= 2
     }
 
-    pub fn hold(&mut self, now: Instant) -> Result<Outcome, Problem> {
-        self.check_refractory(now)?;
+    pub fn hold(&mut self) -> Result<Outcome, Problem> {
         if self.story == Story::Pending {
             return Ok(self.branch_offer());
         }
@@ -496,6 +486,15 @@ impl Run {
             return Err(self.rupture());
         }
         let was_below = self.suspicion < SUSPICION_LIMIT;
+        if self.exhausted {
+            self.recover();
+            self.shed(FRICTION_HOLD);
+            self.settle(was_below);
+            return Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "The count went well past ten. Stamina is back. Everything else has gone quiet, and you are cold again." }),
+            ));
+        }
         if self.chance(
             self.decision(
                 "reflection",

Modified file: src/game/utility.rs+17 additions−6 deletions@@ -1,6 +1,6 @@
 use std::{
     ops::ControlFlow,
-    time::{Duration, Instant, SystemTime},
+    time::{Duration, SystemTime},
 };
 
 use axum::http::{StatusCode, header};
@@ -19,6 +19,13 @@ const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);
 
 impl Run {
     pub(super) fn warm_up(&mut self) -> Result<Outcome, Problem> {
+        if self.warmed_up && !self.here.kettle_boiled {
+            return Err(Problem::new(
+                StatusCode::CONFLICT,
+                "towel-cold",
+                "The towel has gone cold. It warms once per floor, or once after the refractory period, unless someone boils the kettle.",
+            ));
+        }
         if self.floor == Floor::Hotel
             && self.chance(
                 self.decision(
@@ -50,6 +57,9 @@ impl Run {
         };
         self.touch();
         self.step_away();
+        if self.warmed_up {
+            self.here.kettle_boiled = false;
+        }
         self.warmed_up = true;
         self.eq = (self.eq + boost).min(100);
         Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })))
@@ -134,8 +144,9 @@ impl Run {
         .with("upstream", "Pump-Bro"))
     }
 
-    pub(super) fn edge(&mut self, now: Instant) -> Result<Outcome, Problem> {
-        self.commit(5, None, now, 1);
+    pub(super) fn edge(&mut self) -> Result<Outcome, Problem> {
+        self.chafe(None, 5);
+        self.commit(5, None, 1);
         if let ControlFlow::Break(interrupted) = self.hazards(5)? {
             return Ok(interrupted);
         }
@@ -144,7 +155,7 @@ impl Run {
         self.girth += EDGE_GIRTH;
         if self.here.edges >= EDGE_LOOP {
             self.here.edges = 0;
-            self.exhaust(now);
+            self.exhaust();
             return Err(Problem::new(
                 StatusCode::LOOP_DETECTED,
                 "edging-loop",
@@ -157,8 +168,8 @@ impl Run {
         ))
     }
 
-    pub(super) fn pump(&mut self, now: Instant) -> Result<Outcome, Problem> {
-        self.commit(4, None, now, 1);
+    pub(super) fn pump(&mut self) -> Result<Outcome, Problem> {
+        self.commit(4, None, 1);
         if let ControlFlow::Break(interrupted) = self.hazards(4)? {
             return Ok(interrupted);
         }

Modified file: src/http/meta.rs−1

@@ -105,7 +105,6 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {

105105 &config.oracle,

106106 );

107107 run.seeded = seeded;

108- run.refractory = config.refractory;

109108 run.last_seen = ctx.now;

110109 let response = (

111110 StatusCode::CREATED,

Modified file: src/http/run.rs+3 additions−6 deletions@@ -1,7 +1,5 @@
 //! Plumbing shared by every resource under `/runs/{id}`.
 
-use std::time::Instant;
-
 use axum::{
     http::{HeaderName, HeaderValue, StatusCode, header},
     response::{IntoResponse, Response},
@@ -60,7 +58,6 @@ pub fn serve(state: &AppState, mut ctx: Ctx, target: &RunResource) -> Response {
             .into_response();
     }
     run.last_seen = ctx.now;
-    run.recover(ctx.now);
     run.observed = None;
     let response =
         gate(run, &ctx, target.scope).unwrap_or_else(|| target.resource.dispatch(run, &ctx));
@@ -96,7 +93,7 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
 
 /// Every resource the run can reach right now, then every technique a JELQ could use. The `allow`
 /// and `lubricant` extension attributes (RFC 8288 §3) say what each accepts, so a client never guesses.
-fn links(run: &Run, now: Instant) -> String {
+fn links(run: &Run) -> String {
     let thread_reachable = run.thread_reachable();
     let linked: [(&str, &RunResource, bool); 15] = [
         ("", &runs::RUN, true),
@@ -152,7 +149,7 @@ fn links(run: &Run, now: Instant) -> String {
             };
             [choice("forum", "Read the forum"), choice("close-tab", "Close the tab")].join(", ")
         }))
-        .chain(run.techniques_now(now).into_iter().map(|technique| {
+        .chain(run.techniques_now().into_iter().map(|technique| {
             let name = technique.name();
             let lubricant = technique
                 .lubricant()
@@ -219,7 +216,7 @@ pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response)
         (X_SHAME, shame.to_string()),
         (X_CASH, run.cash.to_string()),
         (X_FLOOR, run.floor.number().to_string()),
-        (header::LINK, links(run, ctx.now)),
+        (header::LINK, links(run)),
     ];
     if let Some(observer) = run.observed {
         stats.push((X_OBSERVED_BY, observer.name().into()));

Modified file: src/http/runs.rs+3 additions−5 deletions@@ -173,9 +173,7 @@ fn jelq(run: &mut Run, ctx: &Ctx) -> Response {
         Ok((techniques, intensity, lube))
     });
     match parsed {
-        Ok((techniques, intensity, lube)) => {
-            respond(run.jelq(&techniques, intensity, lube, ctx.now))
-        }
+        Ok((techniques, intensity, lube)) => respond(run.jelq(&techniques, intensity, lube)),
         Err(problem) => problem.into_response(),
     }
 }
@@ -184,8 +182,8 @@ fn put_run(run: &mut Run, _: &Ctx) -> Response {
     run.put().into_response()
 }
 
-fn hold_run(run: &mut Run, ctx: &Ctx) -> Response {
-    respond(run.hold(ctx.now))
+fn hold_run(run: &mut Run, _: &Ctx) -> Response {
+    respond(run.hold())
 }
 
 fn patch_run(run: &mut Run, ctx: &Ctx) -> Response {

Modified file: src/tests.rs+74 additions−14 deletions@@ -1,7 +1,4 @@
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
+use std::{sync::Arc, time::Duration};
 
 use axum::{
     Router,
@@ -994,7 +991,6 @@ async fn the_thread_announces_itself_at_the_branch() {
 #[tokio::test]
 async fn rereading_the_thread_teaches_uli() {
     let mut taught_runs = 0;
-    let mut ruptured = 0;
     for seed in 0..100u64 {
         let app = app_with(Floor::Bedroom, seed, |run| {
             run.turn = BRANCH_TURN;
@@ -1002,34 +998,36 @@ async fn rereading_the_thread_teaches_uli() {
             run.story = Story::ClosedTab;
         });
         let mut taught = false;
-        for _ in 0..40 {
+        for _ in 0..2 {
             let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
             match read.status() {
                 StatusCode::NOT_MODIFIED => {
                     assert!(header(&read, "warning").contains("2009"));
                 }
-                StatusCode::MULTIPLE_CHOICES => {
-                    send(&app, "POST", "/runs/cafebabe/branches/close-tab", &[], "").await;
-                }
                 StatusCode::OK => {
                     assert!(header(&read, "location").contains("/techniques"));
                     taught = true;
                     break;
                 }
-                StatusCode::INTERNAL_SERVER_ERROR => break,
                 other => panic!("seed {seed} read the thread into {other}"),
             }
         }
+        let state = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+        assert_eq!(header(&state, "x-stamina"), "10/10", "reading is free");
         if taught {
             taught_runs += 1;
             let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
             assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
+        } else {
+            let cached = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            assert_eq!(cached.status(), StatusCode::OK);
+            assert!(header(&cached, "warning").starts_with("112"));
+            assert!(header(&cached, "age").parse::<u64>().unwrap() > 0);
         }
-        ruptured += u32::from(!taught);
     }
     assert!(
-        taught_runs >= 85,
-        "{taught_runs}/100 learned uli, {ruptured} ruptured first"
+        (30..=58).contains(&taught_runs),
+        "{taught_runs}/100 learned uli in two reads"
     );
 }
 
@@ -1096,7 +1094,7 @@ async fn holding_calms_and_sometimes_reflects() {
     for seed in 0..120u64 {
         let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
         run.eq = 75;
-        match run.hold(Instant::now()) {
+        match run.hold() {
             Ok(_) if run.eq == 0 => reflected += 1,
             Ok(_) => calmed += 1,
             Err(_) => ruptured += 1,
@@ -1893,3 +1891,65 @@ async fn a_full_server_buries_the_dead_to_make_room() {
     let second = send(&app, "POST", "/runs", &[], "").await;
     assert_eq!(second.status(), StatusCode::CREATED);
 }
+
+#[tokio::test]
+async fn the_towel_warms_once_until_the_kettle_boils() {
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(warm.status(), StatusCode::OK);
+    let again = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(again.status(), StatusCode::CONFLICT);
+
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.warmed_up = true;
+        run.here.kettle_boiled = true;
+    });
+    let reheated = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(reheated.status(), StatusCode::OK);
+    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(cold.status(), StatusCode::CONFLICT);
+}
+
+#[tokio::test]
+async fn the_refractory_period_is_the_next_hold() {
+    let app = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.warmed_up = true;
+        run.eq = 60;
+        run.stamina = 0;
+        run.exhausted = true;
+    });
+    let tired = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(tired.status(), StatusCode::TOO_MANY_REQUESTS);
+    let hold = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert_eq!(hold.status(), StatusCode::OK);
+    assert_eq!(header(&hold, "x-stamina"), "10/10");
+    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(cold.status(), StatusCode::PRECONDITION_FAILED);
+}
+
+#[tokio::test]
+async fn friction_rises_with_vigour_and_edging_chafes() {
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for (intensity, friction) in [(5, "1/10"), (7, "2/10"), (10, "3/10")] {
+        let app = seeded_with(Floor::Hotel, |run| {
+            run.here.wifi_accepted = true;
+            run.warmed_up = true;
+            run.eq = 55;
+        });
+        let uri = format!("/runs/cafebabe?technique=wet&intensity={intensity}");
+        let jelq = send(&app, "JELQ", &uri, &spit, "").await;
+        assert_eq!(
+            header(&jelq, "x-friction"),
+            friction,
+            "intensity {intensity}"
+        );
+    }
+    let app = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.warmed_up = true;
+        run.eq = 55;
+    });
+    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(header(&edge, "x-friction"), "2/10");
+}

Modified file: src/ui.html+1−1

@@ -238,7 +238,7 @@ function renderAlerts(list) {

238238 }

239239 }

240240 const stamina = (list || []).find(([name]) => name === "x-stamina");

241

-  if (stamina && stamina[1].startsWith("0/")) alerts.push("Exhausted. Wait out the refractory period, then GET the run.");

241+ if (stamina && stamina[1].startsWith("0/")) alerts.push("Exhausted. HOLD for the refractory period.");

242242 for (const alert of alerts) box.append(el("h2", { textContent: alert }));

243243 }

jelq

Commit a6caa2f99786

Commit `a6caa2f99786`