tokenmaxxing 1.3.0 → 1.5.0

package/src/lib/install.ts

@@ -406,8 +406,9 @@ export function findClaudeShadowers(rcText: string): ShellShadower[] {
 /** Remove ONLY the marker-tagged PATH line this tool added; a hand-added
  *  PATH entry without the marker is the user's own. A stale `# tokenmaxxing
  *  PATH` line pointing at an emptied binDir is exactly how the supervisor
- *  recursion incident started (see AGENTS.md), so uninstall must not leave
- *  one behind (closing-review catch). Returns true when a line was removed. */
+ *  recursion incident started (.memory/supervisor-recursion-guards.md), so
+ *  uninstall must not leave one behind (closing-review catch).
+ *  Returns true when a line was removed. */
 export function removePathFromRc(rc: string): boolean {
   if (!existsSync(rc)) return false;
   // same symlink + mode treatment as ensurePathInRc: write through a

package/src/lib/slackbridge.ts

@@ -9,7 +9,7 @@ import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { z } from "zod";
 import { delay } from "es-toolkit";
-import { createSdkMcpServer, query, tool, type SpawnOptions } from "@anthropic-ai/claude-agent-sdk";
+import { createSdkMcpServer, query, tool, type SDKUserMessage, type SpawnOptions } from "@anthropic-ai/claude-agent-sdk";
 import { StreamingMarkdownRenderer, type StreamChunk } from "chat";
 import { ensureBestAccount, pooledOptions, stopHookCheck, type SwapDecision } from "../sdk.ts";
 import { POST_SWAP_COOLDOWN_MS } from "./decide.ts";
@@ -56,6 +56,14 @@ export const TurnOutcomeSchema = z.object({
    *  thread's activeTurn marker with resumeAt and the daemon resumes the turn
    *  itself, instead of the old "re-send it once the pool recovers" drop. */
   deferUntil: z.number().nullable(),
+  /** a steered follow-up's own drained turn FAILED after the primary turn
+   *  already succeeded (success stays sticky, the loss is announced
+   *  in-thread): the caller settles the steered messages' reactions as
+   *  failed, never as done - a lost instruction must not read green.
+   *  Attribution is per-turn, not per-message (steer() carries text only),
+   *  so when several messages were steered a successfully folded one can
+   *  read failed too - accepted: a false re-send ask beats a false green. */
+  steerLost: z.boolean(),
 });
 export type TurnOutcome = z.infer<typeof TurnOutcomeSchema>;
 
@@ -75,6 +83,24 @@ const RETRY_DELAY_MS = 10_000;
 /** parks + retries per Slack message; keeps a stale usage cache from looping
  *  a thread forever. */
 export const MAX_RECOVERIES = 3;
+/** extra spawns for a NON-limit failure whose child never completed (crash,
+ *  API blip, errored result): each resumes the same session, so a retry
+ *  continues the turn instead of re-running it. Separate from MAX_RECOVERIES
+ *  on purpose - that budget bounds limit-driven parking, this one bounds
+ *  quota spent chasing a possibly-permanent error. */
+export const MAX_TRANSIENT_RETRIES = 2;
+/** Slack expires a native stream SERVER-SIDE on undocumented timers
+ *  (Slack-maintainer-confirmed in slackapi/python-slack-sdk#1859: idle
+ *  around 30s, total lifetime around 300s measured), and an expired stream
+ *  freezes in the Slack client as a grey "Something went wrong" pill - the
+ *  exact 2026-07-27 report. The salvage path recovers the CONTENT but
+ *  cannot un-freeze the pill, so the fix is to never let Slack expire a
+ *  stream we own: rotate the open segment - a clean end() that the adapter
+ *  finishes with a proper stream stop - before either timer can fire, and
+ *  let the next chunk open a fresh message, the same flow pushText's size
+ *  splits already use. Thresholds sit well inside Slack's observed margins;
+ *  read at every arm (a mutable object, the file's test seam pattern). */
+export const SEGMENT_ROTATION = { idleMs: 20_000, maxAgeMs: 240_000 };
 
 const ParkPlanSchema = z.union([
   z.object({ kind: z.literal("proceed") }),
@@ -216,6 +242,60 @@ export function serveTurnContext(input: { requesterIds: string[] }): string {
 const SegmentChunkSchema = z.union([z.string(), z.custom<StreamChunk>()]);
 type SegmentChunk = z.infer<typeof SegmentChunkSchema>;
 
+/** The exact user-message shape the SDK's own string-prompt path writes to the
+ *  child's stdin (verified in @anthropic-ai/claude-agent-sdk 0.3.214: the SDK
+ *  serializes yielded messages verbatim, adding nothing). No uuid on purpose:
+ *  the CLI dedupes stream-json user messages by uuid and silently swallows a
+ *  reused one, so a uuid derived from a Slack message ts would eat retries.
+ *  No priority either: the default "next" folds the message into the running
+ *  turn at the next tool boundary, while "now" is an undocumented hard
+ *  interrupt that would abort the turn mid-tool (both verified in the claude
+ *  2.1.220 binary). */
+function steerUserMessage(text: string): SDKUserMessage {
+  return { type: "user", session_id: "", message: { role: "user", content: [{ type: "text", text }] }, parent_tool_use_id: null };
+}
+
+/** A hand-pushed async iterable of SDK user messages: the streaming-input
+ *  prompt for one query attempt. The initial prompt is pushed before query()
+ *  and steered messages join mid-turn; end() closes the child's stdin (the
+ *  SDK ends the stream when the iterable finishes). */
+function pushableMessages(): {
+  iterable: AsyncIterable<SDKUserMessage>;
+  push: (m: SDKUserMessage) => void;
+  end: () => void;
+} {
+  const queued: SDKUserMessage[] = [];
+  let cursor = 0;
+  let done = false;
+  let notify: (() => void) | null = null;
+  return {
+    push(m) {
+      queued.push(m);
+      notify?.();
+    },
+    end() {
+      done = true;
+      notify?.();
+    },
+    iterable: {
+      async *[Symbol.asyncIterator]() {
+        while (true) {
+          while (cursor < queued.length) {
+            const next = queued[cursor]!;
+            cursor += 1;
+            yield next;
+          }
+          if (done) return;
+          await new Promise<void>((resolve) => {
+            notify = resolve;
+          });
+          notify = null;
+        }
+      },
+    },
+  };
+}
+
 /** A hand-pushed async iterable: relayThread feeds one of these per Slack
  *  message segment while thread.post concurrently drains it. */
 function pushableStream(): {
@@ -460,8 +540,22 @@ export async function relayThread(input: {
   /** daemon shutdown signal: aborts park/retry sleeps so a drain never sits
    *  out a depleted-pool countdown. */
   drainSignal?: AbortSignal;
+  /** Steering seam. Called with a steer function while a query attempt is
+   *  live and with null when it ends; steer(text) returns true when the text
+   *  was written into the RUNNING attempt's stdin (the CLI folds it into the
+   *  turn at the next tool boundary, or runs it as its own turn in the same
+   *  child when the fold window is gone - either way it reaches the session,
+   *  verified against claude 2.1.220), false once the attempt's result
+   *  arrived or the attempt died - the caller then queues the message as a
+   *  normal next turn instead. Accepted texts also fold into any RETRY
+   *  attempt's prompt, mirroring the existing resend-the-full-prompt retry
+   *  tradeoff (duplication in the resumed transcript beats loss).
+   *  input.requesterIds is shared by reference on purpose: the caller may
+   *  push a steer author's id so a retry attempt's UserPromptSubmit context
+   *  names them (the hook does not fire for folded mid-turn messages). */
+  onSteer?: (steer: ((text: string, onAccept?: () => void) => boolean) | null) => void;
 }): Promise<TurnOutcome> {
-  const outcome: TurnOutcome = { sessionId: input.sessionId, failed: false, rateLimited: false, finish: false, attention: false, announcedDrop: false, resultReceived: false, deferUntil: null };
+  const outcome: TurnOutcome = { sessionId: input.sessionId, failed: false, rateLimited: false, finish: false, attention: false, announcedDrop: false, resultReceived: false, deferUntil: null, steerLost: false };
   let segment: ReturnType<typeof pushableStream> | null = null;
   // acc mirrors the segment's pushed text (bounded by SEGMENT_TEXT_MAX plus a
   // small overshoot): fence parity must be computed over the ACCUMULATED text,
@@ -469,6 +563,14 @@ export async function relayThread(input: {
   // a ``` split across two deltas would be invisible to per-chunk counting
   // (pullfrog review catch, PR #42).
   let segmentMeta: { text: boolean; acc: string; reopenFence: boolean } | null = null;
+  // the open segment's rotation clock (see armSegmentTimer).
+  let segmentTimer: ReturnType<typeof setTimeout> | null = null;
+  let segmentOpenedAt = 0;
+  // a timer rotation closed the segment inside a code fence: the next
+  // segment must reopen it, exactly like pushText's size splits do (codex
+  // review catch). Consumed by openSegment; the salvage handler's own
+  // delivered-prefix recomputation overrides it there.
+  let pendingReopenFence = false;
   let lastPost: Promise<unknown> = Promise.resolve();
   // Reply TEXT that died with a rejected segment and was neither salvaged into
   // a follow-on message nor re-delivered by a later text-bearing segment: the
@@ -496,6 +598,8 @@ export async function relayThread(input: {
   const openSegment = () => {
     const seg = pushableStream();
     segment = seg;
+    segmentOpenedAt = Date.now();
+    armSegmentTimer();
     // reopenFence: the delivered prefix of a REJECTED predecessor left a code
     // fence open, so the first TEXT entering this salvage segment must be
     // preceded by a reopen or it renders outside the code block. Pending
@@ -503,7 +607,8 @@ export async function relayThread(input: {
     // salvage would otherwise either skip the reopen (later text joining the
     // segment renders unfenced) or dangle an empty open fence at message end
     // when no text ever follows. Materialized by BOTH text entry points.
-    const meta = { text: false, acc: "", reopenFence: false };
+    const meta = { text: false, acc: "", reopenFence: pendingReopenFence };
+    pendingReopenFence = false;
     segmentMeta = meta;
     lastPost = input.post(seg.iterable).then(
       () => {
@@ -608,9 +713,19 @@ export async function relayThread(input: {
           // the salvage segment here keeps the salvaged content ordered ahead
           // of any push still awaiting lastPost; the salvage segment's own
           // settle then decides whether its text counts as delivered.
+          // A salvage always recomputes its fence state from the delivered
+          // prefix (the override below), so it must never CONSUME a pending
+          // rotation reopen that belongs to a different segment's
+          // continuation - a rejected notice settling after notify()
+          // restored the flag would otherwise eat it (cubic review catch,
+          // round 4). Held across the lost-chunk re-push too: the salvaged
+          // text is the dying segment's, not the continuation's.
+          const heldReopen = pendingReopenFence;
+          pendingReopenFence = false;
           const next = openSegment();
           next.meta.reopenFence = deliveredFenceOpen;
           for (const c of lost) next.pushInto(c);
+          pendingReopenFence = heldReopen;
         } else if (textRemainder !== "") {
           textLost = true;
           textLostDetail = detail;
@@ -637,6 +752,7 @@ export async function relayThread(input: {
         meta.acc += chunk;
       }
       seg.push(chunk);
+      if (segment === seg) armSegmentTimer();
     };
     return { seg, meta, pushInto };
   };
@@ -649,6 +765,17 @@ export async function relayThread(input: {
     }
     const target = segment ?? openSegment().seg;
     if (!(chunk instanceof Object)) {
+      // a pending rotation reopen can outlive its openSegment hand-off when
+      // text JOINS a segment a rejection handler opened during the wait
+      // (the salvage recomputes its own fence state without consuming the
+      // flag): adopt it here so the continuation still reopens its fence,
+      // UNLESS the joined segment already sits inside an open fence - then
+      // the state is satisfied and a second marker would close it (cubic
+      // review catch, round 4).
+      if (pendingReopenFence) {
+        pendingReopenFence = false;
+        if (!fenceOpen()) segmentMeta!.reopenFence = true;
+      }
       // materialize a salvage segment's pending fence reopen (see
       // openSegment) before the first text from this entry point too.
       if (segmentMeta!.reopenFence) {
@@ -661,14 +788,42 @@ export async function relayThread(input: {
       segmentMeta!.acc += chunk;
     }
     target.push(chunk);
+    if (segment === target) armSegmentTimer();
   };
   // parity by occurrence count over the segment's accumulated text: an odd
   // number of ``` markers means the segment currently sits inside a fence.
   const fenceOpen = () => segmentMeta !== null && (segmentMeta.acc.split("```").length - 1) % 2 === 1;
   const breakSegment = () => {
+    if (segmentTimer !== null) {
+      clearTimeout(segmentTimer);
+      segmentTimer = null;
+    }
+    // a segment dying with an armed-but-unmaterialized reopen (no text ever
+    // arrived - a card-only segment that consumed the flag at open) folds it
+    // back: the reply still logically sits inside an open fence, and the
+    // next text-bearing segment must reopen it (cubic review catch, round
+    // 4: the errored result's closing card ate the rotation's reopen).
+    if (segmentMeta?.reopenFence) pendingReopenFence = true;
     segment?.end();
     segment = null;
   };
+  const armSegmentTimer = () => {
+    if (segmentTimer !== null) clearTimeout(segmentTimer);
+    const ageLeft = segmentOpenedAt + SEGMENT_ROTATION.maxAgeMs - Date.now();
+    segmentTimer = setTimeout(() => {
+      segmentTimer = null;
+      // a rotation mid-fence closes the fence and arms the reopen, so both
+      // message halves render as code - pushText's split contract. An
+      // armed-but-unmaterialized reopen needs no close marker; breakSegment
+      // folds it forward.
+      if (segment !== null && fenceOpen()) {
+        segmentMeta!.acc += "\n```";
+        segment.push("\n```");
+        pendingReopenFence = true;
+      }
+      breakSegment();
+    }, Math.max(0, Math.min(SEGMENT_ROTATION.idleMs, ageLeft)));
+  };
   /** Reply text routed through here splits across Slack messages before the
    *  msg_too_long cap (see SEGMENT_TEXT_MAX): a break prefers the last newline
    *  inside the remaining room, and a break forced inside a code fence closes
@@ -723,8 +878,16 @@ export async function relayThread(input: {
   // streamed segment.
   const notify = async (text: string) => {
     breakSegment();
+    // a notice must never inherit a rotation's pending fence reopen: the
+    // reopen belongs to the interrupted reply's continuation, not to the
+    // status line - consuming it here would render the notice as a code
+    // block AND strand the continuation unfenced (cubic review catch,
+    // round 3). Held aside and restored for the real continuation.
+    const heldReopen = pendingReopenFence;
+    pendingReopenFence = false;
     await push(text);
     breakSegment();
+    pendingReopenFence = heldReopen;
   };
   /** notify + confirm the post actually landed in Slack. A drop notice that
    *  never reached the user must NOT count as announced. DURING A DRAIN an
@@ -759,6 +922,16 @@ export async function relayThread(input: {
   // deferral notice explains the pause; the raw line would invite a manual
   // re-send of work the daemon resumes itself - cubic catch, PR #44).
   let pendingFailureLine: string | null = null;
+  // texts steered into this message's turn, kept across retries: a retry
+  // resumes the session and re-sends the attempt prompt (the established
+  // duplication-beats-loss tradeoff), so steered text folds into every
+  // retry attempt's first message too - a steer written just before a
+  // mid-turn limit killed the child must not vanish from the turn it joined.
+  const steeredTexts: string[] = [];
+  // what the next spawn submits ahead of the steered texts: the original
+  // message, until a transient retry swaps in the continuation wrapper (see
+  // the retry branch).
+  let prompt = input.prompt;
   const runQueryOnce = async () => {
     postedText = false;
     pendingFailureLine = null;
@@ -773,11 +946,47 @@ export async function relayThread(input: {
     // inside the try: a malformed claude.json must fail the TURN, not the
     // relay's never-throws contract.
     let spawnOrg: string | null = null;
+    // Streaming input: the prompt rides an open stdin stream instead of a
+    // one-shot string, which is what lets a mid-turn Slack reply steer the
+    // running turn (the CLI folds a queued stream-json user message into the
+    // current turn at the next tool boundary; one that misses the last fold
+    // window runs as its own turn in the same child before exit, so nothing
+    // is ever dropped - both verified against claude 2.1.220 + SDK 0.3.214).
+    // steer() refuses the moment the attempt's result arrives: stdin ends
+    // then, and the SDK silently drops writes to an ended stdin.
+    const stream = pushableMessages();
+    let steerable = true;
+    const steer = (text: string, onAccept?: () => void): boolean => {
+      if (!steerable) return false;
+      // the caller's SYNCHRONOUS durable commit runs inside the acceptance,
+      // in the same JS tick as the liveness check and BEFORE the child sees
+      // the text (adversarial-review catch, round 3): steerable=true here
+      // proves the turn has not ended, so the commit's view of the turn
+      // state cannot be stale, a crash between commit and push replays a
+      // steer the child never saw (duplication over loss), and a refusal
+      // commits NOTHING - a stale acceptor invocation racing the turn's end
+      // can no longer resurrect a finished turn's marker or clobber
+      // post-turn state. A THROWING commit escapes to the caller before
+      // anything is pushed or recorded here: the stream, steeredTexts, and
+      // the sticky flags are untouched, so the caller can treat the throw
+      // as a refusal and a later steer still works.
+      onAccept?.();
+      steeredTexts.push(text);
+      stream.push(steerUserMessage(text));
+      // a steer answers a LIVE ask too (codex review catch on PR #50): when
+      // need_attention already fired in this attempt, the ask exists only as
+      // this sticky flag until settleTurn persists it - left set, the
+      // answered ask would still get a question mark and a nudge. A later
+      // need_attention call re-arms it for a genuinely new ask.
+      outcome.attention = false;
+      return true;
+    };
     try {
       spawnOrg = readOAuthAccount()?.organizationUuid ?? null;
       const pooled = pooledOptions();
+      stream.push(steerUserMessage([prompt, ...steeredTexts].join("\n\n")));
       const q = query({
-        prompt: input.prompt,
+        prompt: stream.iterable,
         options: {
           ...pooled,
           // claude >= 2.1.142 emits the structured Task tools by default and
@@ -844,8 +1053,18 @@ export async function relayThread(input: {
           ...(outcome.sessionId ? { resume: outcome.sessionId } : {}),
         },
       });
+      // registered only while this attempt is live (cleared in the finally):
+      // the caller's fallback for a refused steer is the normal queued turn.
+      input.onSteer?.(steer);
       const mapState = newStreamMapState();
       let result: string | null = null;
+      // reply text streamed since the last result boundary: each turn in the
+      // child (the primary one, plus any post-fold-window steer drained as
+      // its own turn) delivers its answer independently - a tool-only turn's
+      // answer lives ONLY in its result message, and flushing it at that
+      // result is what keeps a trailing turn's notice or result from
+      // suppressing or clobbering it (adversarial-review catch, round 2).
+      let streamedSinceResult = false;
       for await (const message of q) {
         if (message.type === "system" && message.subtype === "init") {
           // persist BEFORE the turn ends so a first-turn kill stays
@@ -856,36 +1075,82 @@ export async function relayThread(input: {
         }
         if (message.type === "result") {
           outcome.sessionId = message.session_id;
+          // any result ends steerability and closes the child's stdin: a
+          // steer arriving now queues as its own next turn instead. A steer
+          // accepted BEFORE this that missed its fold window still runs -
+          // the CLI drains queued commands as their own turns in this same
+          // child before exiting, emitting a further result each time, so
+          // this loop just keeps consuming until the child exits (end() is
+          // idempotent).
+          steerable = false;
+          stream.end();
           // is_error can ride a "success" subtype (a mid-turn usage limit
           // arrives exactly that way: result "Claude AI usage limit
           // reached|<epoch>"), so errored is a field check, not a subtype
           // check - and only an errored result is ever limit-classified.
           if (message.is_error || message.subtype !== "success") {
             const text = erroredResultText(message);
-            outcome.failed = true;
-            outcome.rateLimited = isRateLimitText({ text });
-            // persist the observation: the retry's decision otherwise re-reads
-            // the stale pre-limit snapshot (poll TTL) and respawns the same
-            // depleted account - a serve process has no statusLine tee.
-            if (outcome.rateLimited) await recordObservedLimit({ text, now: Date.now(), org: spawnOrg });
+            const limited = isRateLimitText({ text });
+            // persist the observation either way: the next spawn decision
+            // must see the limit even when this turn does not retry.
+            if (limited) await recordObservedLimit({ text, now: Date.now(), org: spawnOrg });
+            if (outcome.resultReceived) {
+              // SUCCESS IS STICKY within an attempt (adversarial-review
+              // catch): this errored result belongs to a post-fold-window
+              // steer's own drained turn, arriving AFTER the primary turn
+              // already succeeded and delivered its answer. Marking the turn
+              // failed here would send the whole prompt back through the
+              // retry/defer machinery and re-run completed work - the exact
+              // duplicate-execution the outcome contract forbids. The steer
+              // is announced lost instead (drop-beats-false-promise), and
+              // steerLost settles the steered messages' reactions as failed.
+              outcome.steerLost = true;
+              log("serve.steered_turn_failed", { limited });
+              await notify(
+                limited
+                  ? "a steered follow-up message hit a usage limit before it could run - please re-send it."
+                  : "a steered follow-up message failed - please re-send it.",
+              );
+            } else {
+              outcome.failed = true;
+              // a limit classification is sticky across a child's errored
+              // results (adversarial-review catch, round 2): the drained
+              // steer turn's generic death must not declassify the primary
+              // turn's recoverable limit back to a plain failure.
+              outcome.rateLimited = outcome.rateLimited || limited;
+              // hold the REAL errored text for the terminal diagnostic (codex
+              // review catches: a streamed-then-errored turn used to end with
+              // a truncated answer and only the x reaction, and a no-text
+              // errored turn used to discard the reason for a generic line).
+              // The depleted-pool probe still outranks the line.
+              if (!limited) {
+                const reason = text.slice(0, 200) || "no error detail";
+                pendingFailureLine = postedText
+                  ? `tokenmaxxing: the turn errored before finishing (${reason}) - the reply above may be incomplete.`
+                  : `tokenmaxxing: the turn errored without a result (${reason}) - trying again may help.`;
+              }
+            }
           } else {
             result = message.result;
             outcome.resultReceived = true;
+            // a turn that streamed no reply text (tool-only turns) still
+            // reports: its answer is flushed HERE, per result, not after the
+            // loop - a later turn in the same child must not suppress it. A
+            // paragraph break ahead of it when text already posted, or two
+            // result-only answers would concatenate mid-line (codex review
+            // catch on PR #50).
+            if (!streamedSinceResult && result) await pushText(`${postedText ? "\n\n" : ""}${result}`);
           }
+          streamedSinceResult = false;
         }
         for (const part of agentEventChunks({ state: mapState, message })) {
           if (part instanceof Object) await push(part);
-          else await pushText(part);
+          else {
+            if (part.trim() !== "") streamedSinceResult = true;
+            await pushText(part);
+          }
         }
       }
-      // a turn that produced no streamed text (tool-only turns) still reports.
-      if (!postedText && result) await pushText(result);
-      if (!postedText && !result && outcome.failed && !outcome.rateLimited) {
-        // held back until the depleted-pool probe rules: a "trying again may
-        // help" line right before a deferral notice invites a manual re-send
-        // of work the daemon is about to resume itself (cubic catch, PR #44).
-        pendingFailureLine = "the turn ended without a result - trying again may help";
-      }
     } catch (e) {
       outcome.failed = true;
       const detail = (e instanceof Error ? e.message : String(e)).slice(0, 300);
@@ -896,10 +1161,18 @@ export async function relayThread(input: {
       // deferral's own notice explains the pause better than a raw child
       // error that reads as "please re-send".
       if (!outcome.rateLimited) pendingFailureLine = `tokenmaxxing: turn failed: ${detail}`;
+    } finally {
+      // a died attempt must stop accepting steers (they would be silent
+      // drops on an ended stdin) and must release the caller's steer hook
+      // before the retry loop decides anything.
+      steerable = false;
+      stream.end();
+      input.onSteer?.(null);
     }
   };
 
   let recoveries = 0;
+  let transientRetries = 0;
   const parkDeadline = Date.now() + PARK_MAX_MS;
   while (true) {
     // the switch decision runs at the spawn boundary, same as the CLI hooks.
@@ -956,10 +1229,14 @@ export async function relayThread(input: {
       // the evidence the error text did not carry. A completed result stays
       // terminal, and a usable pool keeps the plain failure.
       if (!outcome.resultReceived) {
+        // outranks the transient retry below even when the recovery time is
+        // unknown (cubic review catch): a depleted pool explains the failure,
+        // and respawning against it would just burn doomed attempts.
+        let probeDepleted = false;
         try {
           const verdict = await ensureBestAccount();
-          const depleted = verdict.reason === "all-depleted" || verdict.reason === "depleted-wait";
-          const wake = depleted ? verdict.waitUntil ?? null : null;
+          probeDepleted = verdict.reason === "all-depleted" || verdict.reason === "depleted-wait";
+          const wake = probeDepleted ? verdict.waitUntil ?? null : null;
           if (wake != null) {
             outcome.rateLimited = true;
             outcome.deferUntil = wake + PARK_GRACE_MS;
@@ -971,8 +1248,43 @@ export async function relayThread(input: {
           // keep the original failure; the probe must never mask it.
           log("serve.defer_probe_error", { err: (e instanceof Error ? e.message : String(e)).slice(0, 300) });
         }
+        // a transient non-limit failure (child crash, API blip, errored
+        // result) against a usable pool retries silently into the same
+        // session, mirroring the rate-limit path's invisible short retry
+        // (2026-07-27 report: these turns died terminally, telling the user
+        // "trying again may help" instead of trying again). resultReceived
+        // stays terminal above - a completed answer must never re-run - and
+        // the probe's deferral outranks a retry: an exhausted pool explains
+        // the failure better than "transient".
+        if (!probeDepleted && outcome.deferUntil === null && transientRetries < MAX_TRANSIENT_RETRIES) {
+          transientRetries += 1;
+          breakSegment();
+          log("serve.transient_retry", { attempt: transientRetries });
+          // once a session exists, the failed attempt may have executed
+          // side-effectful tools before dying, so the retry must CONTINUE,
+          // never re-instruct: replaying the original prompt verbatim into
+          // the resumed session reads as "do it again" (codex review catch).
+          // The wrapper mirrors resumeDecision's deferral resume. A pre-init
+          // death ran nothing, so the original replays verbatim there.
+          if (outcome.sessionId !== null) {
+            prompt = `Your previous turn was interrupted by an error mid-run; this session's transcript already holds any work it completed, including tool calls whose side effects already happened. Pick up exactly where you left off and finish the task without re-running completed side-effectful steps. If the work was already complete, just summarize the final state. The original request was:\n\n${input.prompt}`;
+          }
+          if (!(await sleep(RETRY_DELAY_MS))) {
+            // a drain aborted the retry sleep: same as a killed child, the
+            // marker survives (presumedKilled) and the next daemon start
+            // resumes the session where it stopped.
+            await notify("tokenmaxxing is restarting - this turn resumes after the restart.");
+            break;
+          }
+          continue;
+        }
+      }
+      if (pendingFailureLine !== null) {
+        // same fence-reopen bypass as notify: a diagnostic line opening a
+        // fresh segment must not render inside a reopened code fence.
+        pendingReopenFence = false;
+        await push(transientRetries > 0 ? `${pendingFailureLine} (after ${transientRetries + 1} attempts)` : pendingFailureLine);
       }
-      if (pendingFailureLine !== null) await push(pendingFailureLine);
       break;
     }
     if (recoveries >= MAX_RECOVERIES) {

package/src/lib/slackstate.ts

@@ -133,6 +133,15 @@ const ActiveTurnSchema = z.object({
    *  Absent on older records: recovery falls back to the streamable
    *  handle's newest-author derivation. */
   requesterIds: z.array(z.string()).optional(),
+  /** Slack ids of messages STEERED into this turn mid-run: they carry the
+   *  same hourglass-to-terminal reaction lifecycle as the triggering
+   *  message, so a killed or deferred turn's recovery must settle them too.
+   *  Their text is already folded into `prompt` at steer time, which is what
+   *  makes replays and retries include what the user steered in. An inbound
+   *  takeover of a DEFERRED turn also adopts the held turn's unsettled ids
+   *  here: the takeover serves their held prompt, and without the adoption
+   *  the old trigger's hourglass would read "processing" forever. */
+  steeredMessageIds: z.array(z.string()).optional(),
 });
 export type ActiveTurn = z.infer<typeof ActiveTurnSchema>;