thinkpool-pair 0.7.207 → 0.7.209

package/bridge.mjs

@@ -50,7 +50,7 @@ import { validateProviderSwitch, providerSwitchPlan, BUILTIN_PROVIDER } from './
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
 import { startClaudeSession } from './claude-session.mjs'
-import { startCodexSession, readCodexDefaultModel, readCodexModels, codexConfigForMode } from './codex-session.mjs'
+import { startCodexSession, readCodexDefaultModel, readCodexModels, codexConfigForMode, defaultModeForRuntime } from './codex-session.mjs'
 import { createManagedLaneWorktree, removeManagedLaneWorktree } from './lane-worktree.mjs'
 import { commandOnPath } from './agent-detect.mjs'
 
@@ -98,7 +98,7 @@ const flowRedispatch = new Map()
 // wave BEFORE overrun. Lives bridge-side because waves dispatch across separate
 // broadcasts; without persistent state the cap can never bite.
 const flowBudgets = new Map()
-import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint } from './cross-terminal.mjs'
+import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint, laneStatusOf } from './cross-terminal.mjs'
 import { armInterruptedResume, sendInterruptedContinue, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage } from './session-store.mjs'
@@ -1034,18 +1034,17 @@ const announce = () => {
     // cols/rows: the PTY's one true size — web viewers render this grid and
     // scale it to their own page instead of voting to reflow it.
     terms: [
-      ...[...terms.entries()].map(([id, t]) => ({ id, cmd: t.cmd, alive: true, cols: t.term.cols, rows: t.term.rows, name: termNames[id] || undefined })),
+      ...[...terms.entries()].map(([id, t]) => ({ id, cmd: t.cmd, alive: true, cols: t.term.cols, rows: t.term.rows, name: termNames[id] || undefined, ...laneStatusOf(t) })),
       // Structured sessions advertise kind:'structured' so the web renders the
       // reader (not xterm) and drives them with code-turn / code-perm. `mode` +
       // `name` ride along so a second device shows the live permission mode and
       // the chosen label instead of defaulting to Normal / unnamed. `spawned` (set
       // when an agent Dispatched this lane via spawn_terminal) lets the client keep
       // it OUT of the top tab strip and show it only in the Ensemble menu.
-      // busy: this structured session is mid-turn right now (the SDK's
-      // turnActive). Authoritative — the bridge owns the turn — so the /code
-      // dashboard reads "N agents working" off the roster instead of sniffing
-      // the live code-event stream (which a passive dashboard channel misses).
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
+      // laneStatusOf: authoritative busy/idle + last-action timestamp/age +
+      // STUCK/BLOCKED alert. The bridge owns the turn and permission state, so
+      // every roster consumer reads one status instead of reconstructing it.
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, ...laneStatusOf(s), hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
         // provider: the registered LLM-provider this lane runs on, NAME-ONLY {id,name}
         // (NEVER the key or baseUrl). Additive; older clients ignore it. Omitted for the
         // built-in/default Claude path (no badge). Makes the lane's provider badge +
@@ -1096,6 +1095,7 @@ function raiseCard(entry, req) {
     if (!entry?.pending) return resolve('deny')
     const payload = { term: entry.id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk }
     entry.pending.set(req.id, { resolve, payload })
+    announce()
     bcast('code-perm-req', payload)
     process.stderr.write(`\n  ● incoming cross-room task for ${String(entry.id).slice(0, 8)} — approve in the room.\n`)
   })
@@ -1404,12 +1404,13 @@ function openTerm({ id, cmd, args = [], attached = false, cols, rows }) {
     rows: rows || (attached ? ad.rows : (PIN_ROWS || 32)),
     cwd: process.cwd(), env: { ...process.env, TP_MOCKUP_OUTBOX: mockupOutbox },
   })
-  const entry = { term, cmd, attached, scrollback: '', buf: '', mockupWatcher: watchOutbox(mockupOutbox, () => id) }
+  const entry = { term, cmd, attached, scrollback: '', buf: '', lastActionAt: null, mockupWatcher: watchOutbox(mockupOutbox, () => id) }
   terms.set(id, entry)
   if (attached) attachedId = id
   term.onData(d => {
     if (attached) process.stdout.write(d)
     entry.buf += d
+    entry.lastActionAt = Date.now()
     entry.scrollback = (entry.scrollback + d).slice(-SCROLLBACK_MAX)
   })
   term.onExit(() => {
@@ -1479,6 +1480,8 @@ function pushLog(entry, evt) {
   // A real ts makes ordering wall-clock — immune to eviction AND /clear seq resets.
   // stampEvent is idempotent, so the callers that already stamp are unaffected.
   stampEvent(evt)
+  entry.lastActionAt = evt.ts
+  entry.lastEvent = evt
   // Only TRANSCRIPT events consume a seq (seqable) — replay-chrome kinds the web
   // filters out (system/thinking_tokens/effort) ride the log seq-less so they don't
   // hole the client's applied sequence. See event-id.mjs NO_SEQ_KINDS.
@@ -1541,7 +1544,13 @@ function worktreeSnapshot(cwd) {
 function openStructured({ id, runtime = 'claude', model, effort, resume, log, commands, mode, spawnedBy, rolePrompt, flowSessionId, flowTaskKey, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
   if (sessions.has(id)) return
   runtime = runtime === 'codex' ? 'codex' : 'claude'
-  mode = STRUCTURED_MODES.has(mode) ? mode : 'default'
+  // No explicit mode → a sensible default per runtime (see defaultModeForRuntime):
+  // codex → bypassPermissions, so a freshly-opened codex terminal can fetch /
+  // advance / ship instead of hitting the no-network wall; claude → default.
+  // Only fires when no mode was passed — a person's pick, a resume (persisted
+  // entry.mode), a flow lane, and spawn_terminal (inherits the parent's mode +
+  // its own bypass-escalation gate) all pass an explicit mode and skip this.
+  mode = STRUCTURED_MODES.has(mode) ? mode : defaultModeForRuntime(runtime)
   // The lane's EFFECTIVE model — computed ONCE and used for BOTH the truthful display
   // label (entry.model) and the SDK's `model` option below. These used to be computed
   // separately: the label resolved the provider's configured model while the SDK got the
@@ -1783,7 +1792,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       ...createViewportTools({ tool, z, manager: entry.viewport }),
       tool(
         'read_terminal',
-        'Read-only view of ANOTHER terminal in this ThinkPool Code room (a sibling agent or a shell the people are using). Call with no arguments to list the other open terminals; call with `terminal` (a ref, id, or command from that list) to read its recent activity. It never changes another terminal — reading only. Use it when your work depends on what another terminal is doing.',
+        'Read-only view of ANOTHER terminal in this ThinkPool Code room (a sibling agent or a shell the people are using). Call with no arguments to list every open terminal with busy/idle state, last-action age, and any STUCK/BLOCKED flag; call with `terminal` (a ref, id, or command from that list) to read its recent activity. It never changes another terminal — reading only. Use the one-read roster to identify a lane that needs attention before opening its transcript.',
         {
           terminal: z.string().optional().describe('ref, id, or command of the terminal to read; omit to list the open terminals'),
           lines: z.number().int().positive().max(PEEK.maxLines).optional().describe(`how many recent lines to return (default ${PEEK.defaultLines})`),
@@ -2216,6 +2225,10 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // id, an event that arrives both live AND in a reconnect replay renders
       // twice (the 2026-06-19 duplicate-message bug). See event-id.mjs.
       stampEvent(evt)
+      const stalledChanged = evt.kind === 'stalled' ? !entry.stalled : !!entry.stalled
+      entry.stalled = evt.kind === 'stalled'
+      entry.lastEvent = evt
+      if (evt.kind !== 'stalled') entry.lastActionAt = evt.ts
       // Re-announce the roster on THIS session's busy EDGE — turn start (turnActive
       // flips true on the turn's first event) and turn end (false on result/error).
       // Edge-triggered: one announce per transition, not per token event. This is what
@@ -2227,7 +2240,9 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // bridge sees "this lane just began working". `result`/`error` reads it to decide
       // whether the turn was long enough that nobody was watching (Slice 3).
       { const busyNow = entry.session?.turnActive ?? false
-        if (busyNow !== entry._busyAnn) { if (busyNow) entry._turnStart = Date.now(); entry._busyAnn = busyNow; announce() } }
+        const busyChanged = busyNow !== entry._busyAnn
+        if (busyChanged) { if (busyNow) entry._turnStart = Date.now(); entry._busyAnn = busyNow }
+        if (busyChanged || stalledChanged) announce() }
       // Capture this session's current MODEL (resolved full id, with version — from
       // system/result `model` or usage `ctx.model`) and the SDK's supported-model
       // LIST (from the `models` event) so the announce carries them to EVERY device.
@@ -2416,6 +2431,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // (replay-request handler) — pending cards never enter the replayed event log.
       const payload = { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan, questions: req.questions }
       entry.pending.set(req.id, { resolve, payload })
+      announce()
       bcast('code-perm-req', payload)
       // Slice 3 — arm the grace timer. Fires a "needs you" push only if the card is
       // STILL unanswered 20s from now (you're not in the room). Every resolve path —
@@ -3040,11 +3056,11 @@ channel
     // use run/accept/keep (claude-session interprets). Default deny on missing.
     // Answered from a device → retract the "needs you" banner on every OTHER device
     // (permNotifier.resolve is a no-op unless its grace timer already fired).
-    if (p) { s.pending.delete(payload.id); s.permNotifier?.resolve(payload.id); p.resolve(payload.decision || 'deny') }
+    if (p) { s.pending.delete(payload.id); s.permNotifier?.resolve(payload.id); p.resolve(payload.decision || 'deny'); announce() }
   })
   .on('broadcast', { event: 'code-abort' }, ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
-    if (s) { drainPending(s); s.session.abort() }   // settle any open permission card so the hook doesn't hang
+    if (s) { drainPending(s); s.session.abort(); announce() }   // settle any open permission card so the hook doesn't hang
   })
   .on('broadcast', { event: 'code-mode' }, ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
@@ -3067,6 +3083,7 @@ channel
       if (payload.mode === 'bypassPermissions') allowPending(s)
       // Flipping to acceptEdits = "auto-approve writes" — clear the write cards already raised.
       else if (payload.mode === 'acceptEdits') acceptEditsPending(s)
+      announce()
     }
   })
   .on('broadcast', { event: 'code-effort' }, ({ payload }) => {

package/codex-session.mjs

@@ -44,6 +44,21 @@ export function codexConfigForMode(mode) {
   return CODEX_MODE_CONFIG[mode] || CODEX_MODE_CONFIG.default
 }
 
+/**
+ * The permission mode a FRESHLY-OPENED terminal gets when none was specified
+ * (the person clicked "+ New terminal" without picking a mode). Codex defaults
+ * to bypassPermissions: its workspace-write sandbox has NO network, so a
+ * default-mode codex lane can't fetch / advance git metadata / push / publish
+ * (the 2026-07-13 "sandbox won't let it advance Git metadata" wall) and is
+ * hobbled out-of-the-box. bypass gives a person-opened codex terminal parity
+ * with how Claude lanes run. Claude keeps 'default' — its permission modes don't
+ * gate network. Explicit modes (a person's pick, resume's persisted entry.mode,
+ * a flow lane, spawn_terminal's inherited mode) always override this.
+ */
+export function defaultModeForRuntime(runtime) {
+  return runtime === 'codex' ? 'bypassPermissions' : 'default'
+}
+
 export function readCodexDefaultModel({ home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), fsImpl = fs } = {}) {
   try {
     const text = fsImpl.readFileSync(path.join(home, 'config.toml'), 'utf8')

package/cross-terminal.mjs

@@ -18,6 +18,76 @@ export const PEEK = {
   rosterPreview: 100, // last-line preview length in the roster listing
 }
 
+// One shared lane-status classifier for every roster consumer: the bridge wire,
+// read_terminal, and ROOM NOW. Timestamps stay absolute on the wire so clients can
+// keep the displayed age current without a broadcast every second.
+export const LANE_STATUS = {
+  stuckAfterMs: 90_000,       // matches the structured-turn stall watchdog
+  repeatedFailureCount: 2,
+  failureWindow: 12,
+}
+
+const failureEvent = (e) => !!e && (
+  e.kind === 'error'
+  || (e.kind === 'tool_result' && e.isError)
+  || (e.kind === 'result' && e.subtype && e.subtype !== 'success')
+)
+
+const recentFailureCount = (log, limits = LANE_STATUS) => {
+  let failures = 0, seen = 0
+  for (let i = (Array.isArray(log) ? log.length : 0) - 1; i >= 0 && seen < limits.failureWindow; i--) {
+    const e = log[i]
+    if (!e || typeof e !== 'object') continue
+    seen++
+    // A clean completion or a fresh human task closes the prior failure streak.
+    if ((e.kind === 'result' && (!e.subtype || e.subtype === 'success')) || e.kind === 'you') break
+    if (failureEvent(e)) failures++
+  }
+  return failures
+}
+
+export const laneStatusOf = (entry = {}, now = Date.now(), limits = LANE_STATUS) => {
+  const baseLog = Array.isArray(entry?.log) ? entry.log : []
+  const log = baseLog.slice(-limits.failureWindow)
+  if (entry?.lastEvent && entry.lastEvent !== baseLog[baseLog.length - 1]
+    && (!entry.lastEvent.cid || entry.lastEvent.cid !== baseLog[baseLog.length - 1]?.cid)) log.push(entry.lastEvent)
+  let lastLogAt = null
+  for (let i = log.length - 1; i >= 0; i--) {
+    if (Number.isFinite(log[i]?.ts)) { lastLogAt = log[i].ts; break }
+  }
+  const lastActionAt = Number.isFinite(entry?.lastActionAt) ? entry.lastActionAt : (lastLogAt ?? null)
+  const lastActionAgeMs = lastActionAt == null ? null : Math.max(0, now - lastActionAt)
+  const busy = typeof entry?.busy === 'boolean' ? entry.busy : (entry?.session?.turnActive ?? false)
+  const pendingCount = entry?.pending instanceof Map
+    ? entry.pending.size
+    : Math.max(0, Number(entry?.pendingCount) || 0)
+  const failures = recentFailureCount(log, limits)
+
+  let statusFlag = null, statusReason = null
+  if (pendingCount > 0) {
+    statusFlag = 'BLOCKED'; statusReason = 'waiting for input'
+  } else if (entry?.stalled || (busy && !entry?.compacting && lastActionAgeMs != null && lastActionAgeMs >= limits.stuckAfterMs)) {
+    statusFlag = 'STUCK'; statusReason = 'no events while busy'
+  } else if (failures >= limits.repeatedFailureCount) {
+    statusFlag = 'BLOCKED'; statusReason = 'repeated errors'
+  }
+
+  return { busy: !!busy, lastActionAt, lastActionAgeMs, statusFlag, statusReason }
+}
+
+export const formatLaneAge = (ageMs) => {
+  if (!Number.isFinite(ageMs)) return 'no activity'
+  const s = Math.max(0, Math.floor(ageMs / 1000))
+  if (s < 60) return `${s}s ago`
+  const m = Math.floor(s / 60)
+  if (m < 60) return `${m}m ago`
+  const h = Math.floor(m / 60)
+  if (h < 24) return `${h}h ago`
+  return `${Math.floor(h / 24)}d ago`
+}
+
+const laneStatusText = (x) => `${x.busy ? 'busy' : 'idle'} · ${formatLaneAge(x.lastActionAgeMs)}${x.statusFlag ? ` · ${x.statusFlag}` : ''}`
+
 const clip = (s, cap) => {
   const t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim()
   return t.length > cap ? t.slice(0, cap - 1) + '…' : t
@@ -67,16 +137,16 @@ export const siblingRef = (id) => String(id).slice(0, 8)
 // is the bridge's id→label map (termNames) — the HUMAN names people actually use
 // ("Pivot", "Grug"); without it the roster is just hashes and an agent can't map
 // "what is Pivot doing" to a lane.
-export const siblingsOf = ({ selfId, sessions, terms, names = {} } = {}) => {
+export const siblingsOf = ({ selfId, sessions, terms, names = {}, now = Date.now() } = {}) => {
   const nm = (id) => (names && names[id]) || ''
   const sib = []
   for (const [id, s] of (sessions || new Map())) {
     if (id === selfId) continue
-    sib.push({ id, ref: siblingRef(id), name: nm(id), kind: 'agent', cmd: s?.cmd || 'claude', log: Array.isArray(s?.log) ? s.log : [] })
+    sib.push({ id, ref: siblingRef(id), name: nm(id), kind: 'agent', cmd: s?.cmd || 'claude', log: Array.isArray(s?.log) ? s.log : [], ...laneStatusOf(s, now) })
   }
   for (const [id, t] of (terms || new Map())) {
     if (id === selfId) continue
-    sib.push({ id, ref: siblingRef(id), name: nm(id), kind: 'shell', cmd: t?.cmd || 'shell', buf: t?.buf || '' })
+    sib.push({ id, ref: siblingRef(id), name: nm(id), kind: 'shell', cmd: t?.cmd || 'shell', buf: t?.buf || '', ...laneStatusOf(t, now) })
   }
   return sib
 }
@@ -121,9 +191,9 @@ export const resolveSibling = (siblings, terminal) => {
 
 const label = (x) => `${x.ref}${x.name ? ` · "${x.name}"` : ''}`
 
-export const formatPeek = ({ selfId, sessions, terms, names = {}, terminal, lines } = {}) => {
+export const formatPeek = ({ selfId, sessions, terms, names = {}, terminal, lines, now = Date.now() } = {}) => {
   const n = Math.min(PEEK.maxLines, Math.max(1, Number(lines) || PEEK.defaultLines))
-  const sib = siblingsOf({ selfId, sessions, terms, names })
+  const sib = siblingsOf({ selfId, sessions, terms, names, now })
   if (!sib.length) return 'No other terminals are open in this room right now.'
 
   if (!terminal) {
@@ -131,7 +201,7 @@ export const formatPeek = ({ selfId, sessions, terms, names = {}, terminal, line
       let preview
       if (x.kind === 'agent') { const ls = x.log.map(e => digestLogEvent(e, PEEK.rosterPreview)).filter(Boolean); preview = ls[ls.length - 1] || '(no activity yet)' }
       else { preview = cleanPtyTail(x.buf, 1)[0] || '(no output yet)' }
-      return `- ${label(x)} · ${x.kind} · ${x.cmd} — ${clip(preview, PEEK.rosterPreview)}`
+      return `- ${label(x)} · ${x.kind} · ${x.cmd} · ${laneStatusText(x)} — ${clip(preview, PEEK.rosterPreview)}`
     })
     return `Other terminals in this room (call read_terminal with a ref or name to read one):\n${rows.join('\n')}`
   }
@@ -162,8 +232,8 @@ export const formatPeek = ({ selfId, sessions, terms, names = {}, terminal, line
 // when there is nothing to show (the reminder then carries no tail at all).
 // Spec ask (2026-07-02): "terminals need to be completely aware of the session."
 export const ROOMNOW = { laneCap: 8, previewLen: 70, wtCap: 10 }
-export const formatRoomNow = ({ selfId, sessions, terms, names = {}, worktrees = [] } = {}, limits = ROOMNOW) => {
-  const sib = siblingsOf({ selfId, sessions, terms, names })
+export const formatRoomNow = ({ selfId, sessions, terms, names = {}, worktrees = [], now = Date.now() } = {}, limits = ROOMNOW) => {
+  const sib = siblingsOf({ selfId, sessions, terms, names, now })
   const out = []
   if (sib.length) {
     const shown = sib.slice(0, limits.laneCap)
@@ -171,7 +241,7 @@ export const formatRoomNow = ({ selfId, sessions, terms, names = {}, worktrees =
       let preview
       if (x.kind === 'agent') { const ls = x.log.map(e => digestLogEvent(e, limits.previewLen)).filter(Boolean); preview = ls[ls.length - 1] || '(no activity yet)' }
       else preview = cleanPtyTail(x.buf, 1)[0] || '(no output yet)'
-      return `- ${label(x)} · ${x.kind} — ${clip(preview, limits.previewLen)}`
+      return `- ${label(x)} · ${x.kind} · ${laneStatusText(x)} — ${clip(preview, limits.previewLen)}`
     })
     if (sib.length > shown.length) rows.push(`- … +${sib.length - shown.length} more (read_terminal lists all)`)
     out.push(`Other lanes in this room right now (read_terminal for detail):\n${rows.join('\n')}`)

package/package.json

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