thinkpool-pair 0.7.183 → 0.7.185

package/bridge.mjs

@@ -96,6 +96,7 @@ import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSP
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine, buildRecapFromLog, RECAP_CAP } from './event-id.mjs'
+import { planMeterLine } from './plan-meters.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
@@ -2282,18 +2283,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
@@ -2834,9 +2849,16 @@ channel
     // Computed by REPLAYING the session's own retained result events (each completed turn
     // persists kind:'result' with usage + costUsd + model — see onEvent). No new accumulator
     // state: the log is durable, so this survives a bridge restart for free. Reported as ◆
-    // control lines (like /model) so both members AND late-joiners see it. Scope is honest —
-    // the Agent SDK exposes tokens + cost, not plan/rate-limit meters, and the card says so.
-    if (/^\/usage\s*$/.test(text)) { ctlLine(usageReportLine(s.model, s.log)); return }
+    // control lines (like /model) so both members AND late-joiners see it. Two lines: the
+    // token/cost report (instant, from the retained log), then the plan meters (5h + weekly
+    // utilization + server-authoritative resets) once the OAuth usage endpoint answers. The
+    // meter line is fired-and-forgotten so a slow/unreachable endpoint never stalls /usage;
+    // it degrades to "plan meters unavailable" rather than printing an inferred reset.
+    if (/^\/usage\s*$/.test(text)) {
+      ctlLine(usageReportLine(s.model, s.log))
+      planMeterLine().then((l) => { if (l) ctlLine(l) }).catch(() => { /* meters are never load-bearing */ })
+      return
+    }
     // Context-carry (2026-07-08) point 4: a real human turn arrived BEFORE the post-switch/
     // restore recap fired on init-`system`. Prepend the recap to THIS turn (one turn, not two
     // — a separate recap turn would race + double-fire) and clear the flag so the init handler

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,14 +252,22 @@ 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)`
+  // No "(no plan/rate-limit meters)" tail any more — the handler appends a second control
+  // line from bridge/plan-meters.mjs carrying the real 5h/weekly utilization + resets, or
+  // an explicit "plan meters unavailable". Neither claim belongs on this token/cost line.
+  return `usage · ${turns} · ${perStr}${total}${cost}`
 }
 
 /* The context-carry recap moved to ./recap.mjs (ADR-0010 / S4, 2026-07-09).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.183",
+  "version": "0.7.185",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "update-gate.mjs",
     "agent-notify.mjs",
     "event-id.mjs",
+    "plan-meters.mjs",
     "recap.mjs",
     "transcript-sanitize.mjs",
     "session-store.mjs",

package/plan-meters.mjs

@@ -0,0 +1,144 @@
+/* Plan / rate-limit meters for the /usage report.
+ *
+ * WHERE THE NUMBERS COME FROM. `GET https://api.anthropic.com/api/oauth/usage`
+ * with the Claude Code OAuth access token — the SAME endpoint the CLI's own /usage
+ * screen reads. So the percentages and, critically, the RESET TIMES are the
+ * server's, not ours. We never infer a 5-hour block boundary from transcript
+ * timestamps (the ccusage approach): an inferred reset is a number that looks
+ * authoritative and is wrong, which is exactly the bug this module exists to avoid.
+ *
+ * READ-ONLY, AND DELIBERATELY SO. We read the access token and we never refresh it.
+ * Refreshing rotates the refresh token; two processes rotating against one credential
+ * store is how the bridge's login died before (memory: thinkpool_bridge_login_headless_recovery).
+ * An expired token therefore degrades to "plan meters unavailable" rather than
+ * quietly re-authenticating behind the user's back.
+ *
+ * DEGRADE HONESTLY. Every failure — no token, non-Claude provider, network error,
+ * 401, shape change, a reset timestamp in the past — returns null, and the caller
+ * prints "plan meters unavailable". A stale or invented meter is worse than no meter.
+ */
+
+import { execFileSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
+const CACHE_MS = 45_000
+const FETCH_TIMEOUT_MS = 4_000
+
+// ── token ────────────────────────────────────────────────────────────────────
+// macOS keeps Claude Code's credentials in the login keychain; Linux writes
+// ~/.claude/.credentials.json. Same JSON shape either way: { claudeAiOauth: { accessToken } }.
+// Any failure here is a normal, expected state (BYOK lane, API-key auth, logged out).
+export function readOAuthToken (deps = {}) {
+  const {
+    platform = process.platform,
+    env = process.env,
+    exec = execFileSync,
+    read = readFileSync,
+    home = homedir()
+  } = deps
+  if (env.THINKPOOL_OAUTH_TOKEN) return env.THINKPOOL_OAUTH_TOKEN // test/override seam
+  let raw = null
+  try {
+    if (platform === 'darwin') {
+      raw = exec('security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'],
+        { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] })
+    } else {
+      raw = read(join(home, '.claude', '.credentials.json'), 'utf8')
+    }
+    const tok = JSON.parse(raw)?.claudeAiOauth?.accessToken
+    return (typeof tok === 'string' && tok.startsWith('sk-ant-oat')) ? tok : null
+  } catch { return null }
+}
+
+// ── fetch ────────────────────────────────────────────────────────────────────
+export async function fetchPlanUsage (token, fetchImpl = globalThis.fetch) {
+  if (!token) return null
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS)
+  try {
+    const res = await fetchImpl(USAGE_URL, {
+      method: 'GET',
+      headers: { authorization: `Bearer ${token}`, 'anthropic-beta': 'oauth-2025-04-20' },
+      signal: ac.signal
+    })
+    if (!res.ok) return null // 401 (expired) / 403 / 5xx → unavailable, never a guess
+    return await res.json()
+  } catch { return null } finally { clearTimeout(timer) }
+}
+
+// ── format (pure) ────────────────────────────────────────────────────────────
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
+// A reset renders in LOCAL time. Beyond ~20h out (the weekly meter) a bare HH:MM is
+// ambiguous, so it carries a weekday. Returns null for an unparseable timestamp OR one
+// already in the past — a past reset means the payload is stale, and printing "resets
+// 10:10" when 10:10 has been and gone is precisely the lie we refuse to tell.
+export function fmtReset (iso, now) {
+  const t = new Date(iso).getTime()
+  if (!Number.isFinite(t) || t <= now.getTime()) return null
+  // ROUND to the nearest minute, don't floor. The endpoint stamps `resets_at` with
+  // sub-second jitter around the true boundary — two calls seconds apart returned
+  // 10:10:00.355Z and 10:09:59.873Z for the same reset. Flooring renders those as
+  // 12:10 and 12:09, so the meter visibly flickers a minute back and forth on a
+  // surface whose whole job is to be the trustworthy number. Observed 2026-07-10.
+  const d = new Date(Math.round(t / 60000) * 60000)
+  const hhmm = `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
+  return (t - now.getTime()) > 20 * 3600 * 1000 ? `${DAYS[d.getDay()]} ${hhmm}` : hhmm
+}
+
+const fmtIn = (ms) => {
+  const m = Math.max(0, Math.round(ms / 60000))
+  return m >= 60 ? `${Math.floor(m / 60)}h${String(m % 60).padStart(2, '0')}m` : `${m}m`
+}
+
+// Render one block ("5h" / "week") or null if it can't be stated truthfully.
+function block (label, node, now, withRelative) {
+  const pct = node && typeof node.utilization === 'number' ? Math.round(node.utilization) : null
+  if (pct == null) return null
+  const at = fmtReset(node.resets_at, now)
+  if (!at) return `${label}: ${pct}%` // percent is still true even if the reset isn't usable
+  const rel = withRelative ? ` (${fmtIn(new Date(node.resets_at).getTime() - now.getTime())})` : ''
+  return `${label}: ${pct}% · resets ${at}${rel}`
+}
+
+// json → "plan · 5h: 10% · resets 12:10 (1h04m) · week: 26% · resets Tue 11:00"
+// Returns null when nothing truthful can be said, so the caller prints the honest
+// "plan meters unavailable" instead of a half-line.
+export function formatPlanMeters (json, now = new Date()) {
+  if (!json || typeof json !== 'object') return null
+  const parts = [block('5h', json.five_hour, now, true), block('week', json.seven_day, now, false)]
+  // A scoped weekly cap (e.g. a per-model ceiling) only matters while it's the binding
+  // one — surface it, named, so a lane that's about to hit a model-specific wall sees it.
+  const scoped = Array.isArray(json.limits)
+    ? json.limits.find((l) => l && l.is_active && l.kind === 'weekly_scoped' && typeof l.percent === 'number')
+    : null
+  if (scoped) {
+    const name = scoped.scope?.model?.display_name
+    parts.push(`${name ? `week ${name}` : 'week scoped'}: ${Math.round(scoped.percent)}%`)
+  }
+  const live = parts.filter(Boolean)
+  return live.length ? `plan · ${live.join(' · ')}` : null
+}
+
+// ── cached entry point ───────────────────────────────────────────────────────
+let cache = { at: 0, line: null }
+
+// The ONE line bridge.mjs appends under the token/cost line. Cached ~45s so a user
+// spamming /usage doesn't hammer the endpoint. Never throws.
+export async function planMeterLine (deps = {}) {
+  const { now = () => Date.now(), clock = () => new Date(), token = readOAuthToken, fetchUsage = fetchPlanUsage } = deps
+  const t = now()
+  if (cache.line !== null && (t - cache.at) < CACHE_MS) return cache.line
+  let line = 'plan meters unavailable'
+  try {
+    const json = await fetchUsage(token())
+    line = formatPlanMeters(json, clock()) || 'plan meters unavailable'
+  } catch { /* stays unavailable */ }
+  cache = { at: t, line }
+  return line
+}
+
+export function _resetCache () { cache = { at: 0, line: null } } // test seam

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.