thinkpool-pair 0.7.182 → 0.7.184

package/bridge.mjs

@@ -1900,9 +1900,10 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // This opens a brand-new structured session server-side (the same path the
       // web's "+ New terminal" and the restore loop use), so announce() surfaces
       // its tab in the open web UI live. Auto-allowed by the PreToolUse gate but
-      // bounded by spawnDecision (hop-0-only, per-turn cap, the live terminal cap,
-      // TP_SPAWN_OFF kill-switch). A spawned lane runs one hop deep, so it cannot
-      // recursively spawn/post onward — the fork-bomb breaker (mirrors Tier C).
+      // bounded by spawnDecision (depth-2 hop bound, burst window, the live terminal
+      // cap, TP_SPAWN_OFF kill-switch). A person's lane (hop 0) may spawn conductors
+      // (hop 1) which may spawn workers (hop 2); hop 2 can never spawn onward — the
+      // fork-bomb breaker, now one level deeper (2026-07-10 cascade-spawn-depth spec).
       tool(
         'spawn_terminal',
         'Open a NEW agent terminal (a fresh Claude lane) in this ThinkPool Code room — YOUR lane to use, not a sibling that is already working. Use it to fan work out: give it an initial `task` and it runs in parallel in its own lane; collect its result later with read_terminal, and close it with close_terminal when done. By default the new lane INHERITS your current permission mode — so if you are in bypass, it runs autonomously with no per-action clicking; pass `mode` to override. ALWAYS prefer spawning a fresh lane over post_to_terminal into one that is already busy. Tier guidance: default worker lanes to opus; use sonnet for mechanical work (renames, boilerplate, doc sweeps); reserve your own model for planning/review. Bounded by the room terminal cap and a per-turn limit.',
@@ -1947,9 +1948,11 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
           ne.spawnedBy = id   // ownership: only the spawner may close_terminal it
           announce()          // (defensive) ensure the web renders the new tab live
           if (args?.task) {
-            // One hop deep: the spawned lane cannot spawn/post onward until a person
-            // speaks to it (code-turn resets hop to 0). Mirrors the Tier C injection.
-            ne.hop = 1; ne.peekCount = 0; ne.postCount = 0; ne.spawnTimes = []
+            // One level deeper than the spawner: hop = parent.hop + 1, so the depth-2
+            // bound in spawnDecision binds at every level (hop-0 person's lane → hop-1
+            // conductor → hop-2 worker, which can never spawn onward). A person speaking
+            // to any lane still resets it to hop 0 (code-turn). Mirrors Tier C injection.
+            ne.hop = (entry.hop || 0) + 1; ne.peekCount = 0; ne.postCount = 0; ne.spawnTimes = []
             const msg = `[Task from terminal ${fromRef}'s agent — relayed via ThinkPool cross-terminal; you are a fresh lane it opened for you]\n${args.task}`
             const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true }
             stampEvent(evt); pushLog(ne, evt); bcast('code-event', { term: newId, evt })
@@ -2279,18 +2282,32 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // 'suggestion' is Claude Code's predicted-next-prompt ghost text — ephemeral
       // composer UI, broadcast to both clients but never logged/persisted/replayed.
       const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear' || evt.kind === 'compact' || evt.kind === 'stalled' || evt.kind === 'suggestion'
-      // compact turn finished (or errored) → clear the pulsing indicator AND resolve the
-      // "◈ compacting context…" line so it doesn't sit there forever looking stuck (Max asked
-      // "is it compacted?" — 2026-07-02). On success post an explicit "◈ context compacted"
-      // control line, paired with the start line; on error the SDK's AbortError/too-small
-      // text is the signal, so no line. Same control-event shape as ctlLine (kind:'control').
+      // The compact turn settled with `entry.compacting` STILL TRUE — which, because the
+      // `compaction` branch above clears the flag the moment the milestone lands, means
+      // exactly one thing: NO compaction happened. Three ways to get here, all of which
+      // used to end in silence (the indicator blinked out and the context was unchanged,
+      // so "did that work?" was unanswerable — Max, 2026-07-10):
+      //   • aborted   — Stop, a model switch, or (until turn-stall.mjs) the stall watchdog
+      //                 killing the long silent compaction call outright.
+      //   • no-op     — the SDK declines: "Not enough messages to compact."
+      //   • error     — the compaction call itself failed.
+      // `/compact` writes no `you` line (the code-turn handler returns before echoYou), so
+      // without this the room has no record the command was ever run. Say what happened,
+      // once, durably — same control-event shape as ctlLine.
       if ((evt.kind === 'result' || evt.kind === 'error') && entry.compacting) {
+        const by = entry.compactBy || null
         entry.compacting = false
-        // Clear the ephemeral "Compacting…" indicator. The persistent record is the
-        // CompactionCard (kind:'compaction', now attributed) — no redundant control line
-        // that lingers in scrollback reading as "compacted recently" (Max, 2026-07-02).
-        bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
         entry.compactBy = null
+        // Clear the ephemeral "Compacting…" indicator. On the SUCCESS path the persistent
+        // record is the CompactionCard (kind:'compaction', attributed) — no redundant control
+        // line that reads as "compacted recently" in scrollback (Max, 2026-07-02).
+        bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+        const why = evt.kind === 'error' ? 'compaction failed'
+          : evt.subtype === 'aborted' ? 'compaction canceled'
+          : 'nothing to compact'
+        const ce = { kind: 'control', text: `${why} — context unchanged`, by }
+        pushLog(entry, ce)
+        bcast('code-event', { term: id, evt: ce })
       }
       // ── Slice 3: the turn settled. Two things happen, in this order.
       //   1. Every outstanding permission card on this lane is now dead (the SDK

package/claude-session.mjs

@@ -21,7 +21,7 @@ import { sanitizeSession } from './transcript-sanitize.mjs'
 import { reviewGatePreToolDecision } from './flow-review-gate.mjs'
 import { crossPostNeedsCard } from './cross-terminal.mjs'
 import { correctContext } from './context-windows.mjs'
-import { stallDecision, stallEvent } from './turn-stall.mjs'
+import { stallDecision, stallEvent, isCompactTurn } from './turn-stall.mjs'
 
 // The caret-pulled SDK's real version (^0.3.x auto-upgrades on restart). Resolved
 // once at import by walking up from the package entry to its own package.json.
@@ -312,6 +312,13 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   const FORCE_STOP_MS = Math.max(STALL_MS * 3, parseInt(process.env.TP_FORCE_STOP_MS, 10) || 300000)
   let forceStopped = false
   let stallRetried = false        // one auto-retry per turn (the abort+re-run path below)
+  // A manual /compact is one long, LEGITIMATELY silent model call — not a wedge. The
+  // watchdog stands down for its whole duration (stallDecision's `compacting` branch);
+  // only a compaction quiet for COMPACT_FORCE_STOP_MS (20 min default) is force-stopped,
+  // and never by aborting the query. Set in sendTurn, cleared on compact_boundary (the
+  // compaction landed) and on any result/error (the turn settled, incl. a no-op compact).
+  const COMPACT_FORCE_STOP_MS = Math.max(FORCE_STOP_MS, parseInt(process.env.TP_COMPACT_FORCE_STOP_MS, 10) || 1200000)
+  let compacting = false
   // Waiting on a HUMAN decision (permission card / plan gate / AskUserQuestion)
   // is NOT a wedge — the turn is correctly idle until the person answers. Every
   // interactive gate goes through requestPermission, so wrap it once to bump a
@@ -360,10 +367,13 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // the last real SDK event). emit() is the normal path: it stamps liveness + clears the
   // one-shot stall flag on any real event other than a `stalled` re-emit.
   const emitRaw = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
-  const emit = (evt) => { lastEvtTs = Date.now(); if (evt && evt.kind !== 'stalled') stalledSent = false; emitRaw(evt) }
+  // The compaction window closes on its milestone (`compaction`) or on the turn settling
+  // (`result`/`error` — covers a no-op "Not enough messages to compact" and a Stop). After
+  // that the normal wedge timeline applies again.
+  const emit = (evt) => { lastEvtTs = Date.now(); if (evt && evt.kind !== 'stalled') stalledSent = false; if (evt && (evt.kind === 'compaction' || evt.kind === 'result' || evt.kind === 'error')) compacting = false; emitRaw(evt) }
   const stallTimer = setInterval(() => {
     const quiet = Date.now() - lastEvtTs
-    const action = stallDecision({ turnActive, awaitingUser, quietMs: quiet, stallMs: STALL_MS, forceStopMs: FORCE_STOP_MS, stalledSent, stallRetried })
+    const action = stallDecision({ turnActive, awaitingUser, quietMs: quiet, stallMs: STALL_MS, forceStopMs: FORCE_STOP_MS, stalledSent, stallRetried, compacting, compactForceStopMs: COMPACT_FORCE_STOP_MS })
     if (action === 'none') return
     // ALWAYS surface — a stall is never swallowed. emitRaw so this synthetic event
     // doesn't reset the silence clock (see emitRaw above).
@@ -503,7 +513,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // hasn't already opted into). If the spawner is already in bypass, children inherit
     // bypass with NO prompt (you opted in once); a non-bypass child gates itself per
     // action anyway, so no spawn prompt there either. Bridge-side spawnDecision still
-    // enforces hop-0-only / per-turn cap / 8-terminal cap / TP_SPAWN_OFF regardless.
+    // enforces the depth-2 hop bound / burst window / machineMax / TP_SPAWN_OFF regardless.
     if (toolName === 'mcp__thinkpool__spawn_terminal') {
       const childMode = toolInput?.mode || mode   // inherit this lane's mode by default
       const escalating = childMode === 'bypassPermissions' && mode !== 'bypassPermissions'
@@ -690,7 +700,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       'RUN IT, DO NOT ASK: verify your own work before calling it done. Actually run or serve what you changed, observe that it behaves correctly, and show the evidence in the room — a screenshot of the running result, the passing test output, or the real response — rather than telling the user "this should work, go test it." If you could not verify something, say exactly what is unverified. This room follows verify-before-claiming: runtime evidence you produced, not assertion.',
       'CROSS-TERMINAL AWARENESS: this room may have other terminals open alongside yours — other agents working, or shells the people are driving. You have a READ-ONLY tool, read_terminal: call it with no arguments to list the other open terminals, or with a terminal ref/id/command to read that terminal\'s recent activity. Reach for it when your work depends on what another terminal is doing (e.g. someone says "see what the other terminal hit", or you need to coordinate with a sibling agent before acting). It only ever reads — it never changes another terminal. Identify a terminal by its NAME or its ref/id from the roster, never by an on-screen number like "Terminal 2" — those positional labels renumber when a terminal is closed, so they do not reliably point at a lane.',
       'CROSS-TERMINAL HAND-OFF: you also have post_to_terminal(terminal, text) to send a message or task to ANOTHER AGENT terminal in this room (not a plain shell). Use it sparingly and only when the people clearly want the lanes to coordinate — e.g. "tell the backend terminal the API is ready", or to hand a sibling agent a concrete task. Every post requires a person in the room to approve a card before it is delivered, and an agent that was itself reached via a cross-post cannot post onward — so do not rely on it for chit-chat or loops. Prefer read_terminal to understand a sibling before you ever post to it.',
-      'CROSS-TERMINAL SPAWN: when a person asks you to fan work out across multiple agents — research lanes, parallel sub-tasks, a swarm — open YOUR OWN fresh lanes with spawn_terminal(name?, task?, model?); do NOT dump the work into siblings that are already busy (a sibling is mid-task unless read_terminal shows it idle, and hijacking it derails their work). spawn_terminal opens a brand-new Claude lane and, if you pass `task`, hands it that task immediately; it appears as a new terminal in the room. A spawned lane INHERITS your current permission mode by default — so if you are in bypass, your lanes run autonomously with no per-action clicking; pass `mode` only to override. Raising a lane to bypass from a non-bypass lane asks the room to confirm once (everything else spawns without a prompt). Collect each lane\'s result later with read_terminal (a spawned lane cannot post back to you), and tidy up with close_terminal once you have what you need — you may only close lanes you spawned yourself. You are bounded: a few new lanes per turn, a per-plan dispatch ceiling on concurrent spawned lanes (Free 3 / Plus 6) that is separate from the human terminals so it never blocks them, an overall room machine cap, and a lane you were spawned/cross-posted into cannot itself spawn (so no runaway). This is how you "open the terminals yourself" instead of asking a person to.',
+      'CROSS-TERMINAL SPAWN: when a person asks you to fan work out across multiple agents — research lanes, parallel sub-tasks, a swarm — open YOUR OWN fresh lanes with spawn_terminal(name?, task?, model?); do NOT dump the work into siblings that are already busy (a sibling is mid-task unless read_terminal shows it idle, and hijacking it derails their work). spawn_terminal opens a brand-new Claude lane and, if you pass `task`, hands it that task immediately; it appears as a new terminal in the room. A spawned lane INHERITS your current permission mode by default — so if you are in bypass, your lanes run autonomously with no per-action clicking; pass `mode` only to override. Raising a lane to bypass from a non-bypass lane asks the room to confirm once (everything else spawns without a prompt). Collect each lane\'s result later with read_terminal (a spawned lane cannot post back to you), and tidy up with close_terminal once you have what you need — you may only close lanes you spawned yourself. You are bounded: a sliding spawn-burst window, a per-plan dispatch ceiling on concurrent spawned lanes (Free 3 / Plus 6) that is separate from the human terminals so it never blocks them, an overall machine cap on live lanes, and a DEPTH bound — a lane opened by a person may spawn workers, and those workers may spawn one further level (a conductor dispatching its crew), but that second level can never spawn onward (so no runaway). This is how you "open the terminals yourself" instead of asking a person to.',
       'CROSS-SESSION AWARENESS: the Ensemble reaches across your SESSIONS, not just the terminals in this room. list_sessions() lists your OTHER ThinkPool Code rooms — both your own rooms running on this machine AND your partner\'s rooms in the same pair, reachable over the per-pair bus (a room on the partner\'s machine shows its host). read_session(session, terminal?) reads recent activity inside one (omit `terminal` to list that room\'s terminals, or pass a ref/name to read that lane). Both are READ-ONLY — they never change another session, and they reach ONLY your own rooms and rooms you share with your partner, never a stranger\'s. Reach for them when work spans rooms — "what\'s the other project up to", "pick up where the other session left off", or to check a long-running task elsewhere before you act here.',
       'CROSS-SESSION HAND-OFF: post_to_session(session, text, terminal?) sends a task or message to an agent in ANOTHER of your rooms — your own, or your partner\'s over the pair bus. Use it sparingly and only when the people clearly want the rooms to coordinate — e.g. hand the API room\'s agent a concrete follow-up once the frontend is ready. It is dual-consent: a person in YOUR room approves sending, and a person in the TARGET room approves receiving, before anything is delivered — so never rely on it for chit-chat or loops, and an agent that was itself reached via a cross-room post cannot post onward to a third room. It spends real model tokens in the other room (maybe on the other person\'s machine), so prefer read_session to understand a room before you ever post into it, and only post one concrete hand-off at a time. All of this works only under the ThinkPool account bridge; a standalone room sees just its own terminals.',
       'SUBAGENT POLICY: in this room, delegated work goes through the Ensemble. When you fan out research, parallel sub-tasks, reviews, or any substantive multi-step delegated work, open spawn_terminal lanes — they are visible in the room, the people can watch and steer them, and every other lane can peer at their work. Do NOT reach for the built-in Task/Agent subagents for that work: an in-process subagent is invisible to the room, cannot be peered at or steered, and its work is lost to the Ensemble. The only exception is a trivial, seconds-scale read-only lookup where a room lane would be pure overhead.',
@@ -1110,7 +1120,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     if (closed) return
     stallRetried = true
     const wasActive = turnActive
-    const replay = wasActive ? lastTurnText : null
+    // NEVER replay a `/compact`. The abort below is what cancels an in-flight compaction, and
+    // re-pushing the command just feeds the next abort. stallDecision already stands down while
+    // `compacting` is armed, so this is the belt for the window where the flag was cleared by a
+    // mid-compaction error but lastTurnText is still the command.
+    const replay = wasActive && !isCompactTurn(lastTurnText) ? lastTurnText : null
     turnActive = false                                     // unblock between-turns updates while we tear down
     const dying = qDone
     const oldInput = input
@@ -1136,6 +1150,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // is queue-backed, so the pushed turn buffers and runs once the query is ready.
     sendTurn(text) { if (!closed) { if (!started) runQuery(); turnActive = true; sawSuggestion = false; lastTurnText = String(text); if (sugTimer) { clearTimeout(sugTimer); sugTimer = null } lastEvtTs = Date.now(); stalledSent = false; stallRetried = false; forceStopped = false;
       const t = String(text)
+      // Arm the compaction window BEFORE the push: from here until the `compaction` milestone
+      // (or the turn's result) the SDK is allowed to be silent for minutes without the stall
+      // watchdog aborting it. See turn-stall.mjs — aborting a compaction is what produced
+      // `AbortError: Compaction canceled.` in the room.
+      compacting = isCompactTurn(t)
       // SDK 0.3.198 only recognizes a slash command (/compact, /clear, custom /cmds) when the
       // user message is a SINGLE text block. Appending the per-turn ROOM NOW <system-reminder>
       // as a 2nd block made 0.3.198 treat /compact as a plain turn → compaction silently

package/cross-terminal.mjs

@@ -240,12 +240,21 @@ export const crossPostNeedsCard = ({ mode = 'default', spawnedByMe = false } = {
 // this stays a PURE function (no Date.now inside; the clock is injected, like
 // spawnCount was before).
 export const SPAWN = {
-  maxHop: 1,               // human turn = hop 0; a spawned/injected lane = hop ≥ 1, CANNOT spawn onward
-  perWindowCap: 4,         // spawn_terminal calls allowed per rolling window (burst breaker)
+  maxHop: 2,               // human turn = hop 0; its spawned lane (hop 1, a "conductor") MAY spawn
+                           // workers (hop 2); hop ≥ 2 can never spawn onward. Depth-2 cascades,
+                           // fork-bomb still impossible by construction — every level also passes
+                           // machineMax + the plan ceiling + the burst window + the kill-switch.
+                           // Was 1 until 2026-07-10 (docs/specs/2026-07-10-cascade-spawn-depth.md):
+                           // conductors dispatched by a person's lane could not dispatch at all.
+  perWindowCap: 6,         // spawn_terminal calls allowed per rolling window (burst breaker);
+                           // 6 matches plusMaxSpawned so one wave can open a full crew (was 4)
   windowMs: 10 * 60 * 1000, // sliding window over which perWindowCap applies (10 min)
   freeMaxSpawned: 3,       // Free plan dispatch ceiling (concurrent spawned lanes)
   plusMaxSpawned: 6,       // Plus plan dispatch ceiling
-  machineMax: 10,          // hard cap on TOTAL live lanes (the laptop/runaway backstop)
+  machineMax: 12,          // hard cap on TOTAL live lanes (the laptop/runaway backstop). 10 → 12
+                           // 2026-07-10: finished-but-open lanes were starving slots. NOT higher:
+                           // at ~10 live lanes CPU contention corrupted Lighthouse runs that day —
+                           // this cap protects the host and measurement quality, not just runaway.
 }
 
 // Plan → dispatch ceiling. Anything not 'plus' is treated as Free (the safe default).

package/event-id.mjs

@@ -225,10 +225,16 @@ export const claudeish = (m) => /claude|anthropic|opus|sonnet|haiku|fable/i.test
 
 // model id → friendly label for the /usage report: claude-opus-4-8 → "Opus 4.8".
 // Bridge-local twin of the web's prettyModel (structured.jsx); falls back to the raw id.
+// The `[1m]` long-context suffix is PRESERVED. `claude-opus-4-8` and `claude-opus-4-8[1m]`
+// are different models on different rates and summarizeUsage keys them apart — collapsing
+// both to "Opus 4.8" printed two identical, unattributable rows in one report (real log,
+// room 1TV7B59A: `Opus 4.8: 51.8M in … · Opus 4.8: 46.0M in …`). 2026-07-10.
 export function prettyModelId (m) {
   if (!m) return 'unknown'
-  const mm = String(m).match(/(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/i)
-  return mm ? `${mm[1][0].toUpperCase()}${mm[1].slice(1)} ${mm[2]}${mm[3] ? '.' + mm[3] : ''}` : String(m)
+  const raw = String(m)
+  const long = /\[1m\]/i.test(raw) ? ' [1m]' : ''
+  const mm = raw.match(/(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/i)
+  return mm ? `${mm[1][0].toUpperCase()}${mm[1].slice(1)} ${mm[2]}${mm[3] ? '.' + mm[3] : ''}${long}` : raw
 }
 
 // Build the ONE ◆ control line the /usage command emits, from the session's model +
@@ -246,11 +252,16 @@ export function usageReportLine (sessionModel, logEvents) {
   if (!anyClaude && (sessionModel || sum.turns)) return 'usage reporting is available on Claude models only'
   if (!sum.turns) return 'usage · no completed turns yet this session'
   const fmtTok = (n) => n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'k' : String(n)
-  const perStr = sum.per.map((r) => {
+  // Drop models that burned nothing. The SDK stamps a `result` with the resolved id even for
+  // turns that spent no tokens (an interrupt, a no-op /compact), so a real report carried dead
+  // rows like `opus[1m]: 0 in / 0 out` (room 1TV7B59A). If EVERY row is empty, print them all
+  // rather than an eerie modelless line. `total` keys off the printed rows, not the raw set.
+  const rows = sum.per.filter((r) => r.in || r.out).length ? sum.per.filter((r) => r.in || r.out) : sum.per
+  const perStr = rows.map((r) => {
     const cch = r.cached ? ` (${fmtTok(r.cached)} cached)` : ''
     return `${prettyModelId(r.model)}: ${fmtTok(r.in)} in${cch} / ${fmtTok(r.out)} out`
   }).join(' · ')
-  const total = sum.per.length > 1 ? ` · total ${fmtTok(sum.totalIn)} in / ${fmtTok(sum.totalOut)} out` : ''
+  const total = rows.length > 1 ? ` · total ${fmtTok(sum.totalIn)} in / ${fmtTok(sum.totalOut)} out` : ''
   const cost = sum.haveCost ? ` · ~$${sum.totalCost.toFixed(2)} est` : ''
   const turns = `${sum.turns} turn${sum.turns === 1 ? '' : 's'}`
   return `usage · ${turns} · ${perStr}${total}${cost} · tokens + cost only (no plan/rate-limit meters)`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.182",
+  "version": "0.7.184",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {

package/turn-stall.mjs

@@ -22,13 +22,31 @@
 //   quietMs > stallMs (90s)      → 'status'  — surface a "still retrying (Ns)" banner, ONCE
 //   quietMs > forceStopMs (5min) → 'retry'   — abort the hung call, re-run the turn ONCE
 //   quietMs > forceStopMs again  → 'giveup'  — the one retry also stalled: force-stop, resend
-export function stallDecision({ turnActive, awaitingUser, quietMs, stallMs, forceStopMs, stalledSent, stallRetried }) {
+//
+// COMPACTION is the third "silence is not a wedge" case, alongside idle + awaitingUser.
+// A `/compact` is ONE model call that summarises the whole transcript and emits NOTHING until
+// it lands: measured at 28.5s of dead air on a 54k-token context (bridge/probe-compact.mjs),
+// and Max's real compactions carried 397k–618k pre-tokens — minutes of silence. The watchdog
+// read that as a wedge, fired 'retry' at 300s, and retryStalledTurn's qAc.abort() KILLED the
+// compaction: `AbortError: Compaction canceled.` landed in the shared transcript, the context
+// was unchanged, and the retry re-pushed `/compact` to be aborted again. (Room 1TV7B59A, lane
+// 9ad2e6bf, seq 1210-1215 on 2026-07-09 20:00 — and the same shape again at seq 2239-2241.)
+// So while compacting: never 'status' (the "still retrying" copy is a lie, and the compact
+// indicator already owns that UI) and never 'retry' (the abort IS the bug). A genuinely hung
+// compaction still recovers at a much longer ceiling — 'giveup' force-stops without aborting.
+export function stallDecision({ turnActive, awaitingUser, quietMs, stallMs, forceStopMs, stalledSent, stallRetried, compacting = false, compactForceStopMs = Infinity }) {
   if (!turnActive || awaitingUser > 0) return 'none'
+  if (compacting) return quietMs > compactForceStopMs ? 'giveup' : 'none'
   if (quietMs > forceStopMs) return stallRetried ? 'giveup' : 'retry'
   if (!stalledSent && quietMs > stallMs) return 'status'
   return 'none'
 }
 
+// Is this turn text a manual compaction request? The SDK recognises `/compact` (optionally
+// with focus instructions) as a slash command when the user message is a single text block —
+// see claude-session's sendTurn. Exported so the watchdog and the re-push guard agree.
+export const isCompactTurn = (text) => /^\s*\/compact\b/.test(String(text || ''))
+
 // The room-facing event for a watchdog action (pure → the exact wording is unit-tested).
 // 'status' rides the transient `stalled` chrome event (broadcast, never persisted); 'retry'
 // and 'giveup' ride `error` (recoverable) so the stall is ALWAYS surfaced, never swallowed.