thinkpool-pair 0.7.183 → 0.7.184

package/bridge.mjs

@@ -2282,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).
@@ -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/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.183",
+  "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.