thinkpool-pair 0.7.338 → 0.7.340

package/bridge.mjs

@@ -58,6 +58,7 @@ import { startStructuredSession } from './runtime-session.mjs'
 import { fallbackTerminalName } from './terminal-name.mjs'
 import { defaultStructuredMode, normalizeStructuredEffort, shouldDeferStructuredRuntime, structuredModeForSlice, structuredModeLocked, structuredModesForLane, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { commandCatalogForRuntime, commandHelpLine, reconcileCommandCatalog } from './command-catalog.mjs'
+import { gitDiffReport } from './git-diff-report.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
 import { hermesRequiredMcpTools, hermesRoleFor } from './hermes-policy.mjs'
 import { canonicalRoomFilePath, waitForNativeImages } from './codex-images.mjs'
@@ -118,7 +119,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, readTerminalTurnBudgetDecision, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, CROSSROOM_BUS, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint, closeLaneDecision, laneBusyOf, laneStatusOf, settleLaneBusy, nativeClaudeFallbackHint, buildDispatchPreview, authorizeDirectDispatch } from './cross-terminal.mjs'
+import { formatPeek, PEEK, readTerminalTurnBudgetDecision, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, CROSSROOM_BUS, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint, closeLaneDecision, laneBusyOf, laneStatusOf, settleLaneBusy, settleLaneControl, nativeClaudeFallbackHint, buildDispatchPreview, authorizeDirectDispatch } from './cross-terminal.mjs'
 import { createStandalonePairResponder, standalonePairIdentity } from './direct-pair-room.mjs'
 import { dispatchPendingRecap, recoverInterruptedTurn, recoverMissingResumeOnce, sendInterruptedContinue, shouldAttemptNativeResume, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { supersedeDispatchLease } from './dispatch-lease.mjs'
@@ -129,6 +130,7 @@ import { createLatestReplayPump, requestedReplayIds } from './replay-transport.m
 import { classifyCodeEvent, unknownCodeEventNotice } from './code-event-contract.mjs'
 import { fetchPairControlDeliveryAuthority } from './pair-control-authority.mjs'
 import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, dispatchSideContexts, sideContextBlock, sideSnapshot } from './side-lane.mjs'
+import { acknowledgeWorkerCompletions, enqueueWorkerCompletion, workerCompletionPrompt, workerCompletionRecord } from './worker-completion.mjs'
 import { planMeterLine } from './plan-meters.mjs'
 import { priceForModel } from './model-prices.mjs'
 import { loadHermesModelCache, saveHermesModelCache } from './hermes-model-cache.mjs'
@@ -1109,6 +1111,42 @@ function schedulePendingSideContexts(entry) {
   entry._sideContextTimer.unref?.()
 }
 
+function dispatchPendingWorkerCompletions(entry) {
+  if (!entry?.pendingWorkerCompletions?.length || typeof entry.session?.sendTurn !== 'function') return false
+  if (entry.workerCompletionsInFlight?.length) return false
+  if (laneBusyOf(entry) || (entry.pending?.size || 0) > 0) return false
+  const batch = entry.pendingWorkerCompletions.slice()
+  const prompt = workerCompletionPrompt(batch)
+  if (!prompt) {
+    entry.pendingWorkerCompletions = []
+    return false
+  }
+  // Write the dispatch intent before sendTurn. A process death after acceptance
+  // must leave enough durable state to resume or redeliver the continuation.
+  entry.workerCompletionsInFlight = batch
+  entry.flush?.()
+  const dispatched = dispatchStructuredTurn(entry, prompt, {
+    rejectionMessage: 'The worker-completion continuation was not accepted; it remains queued.',
+  })
+  if (!dispatched.accepted) {
+    entry.workerCompletionsInFlight = []
+    entry.flush?.()
+    return false
+  }
+  return true
+}
+
+function schedulePendingWorkerCompletions(entry) {
+  if (!entry?.pendingWorkerCompletions?.length || entry._workerCompletionTimer) return
+  entry._workerCompletionTimer = setTimeout(() => {
+    entry._workerCompletionTimer = null
+    if (dispatchPendingWorkerCompletions(entry)) {
+      process.stderr.write('\n  ◆ worker finished — continued its owning terminal.\n')
+    }
+  }, 0)
+  entry._workerCompletionTimer.unref?.()
+}
+
 function stampStructuredTurn(entry, event) {
   if (event && event.turnRev == null && Number(entry?._turnRev) > 0) event.turnRev = entry._turnRev
   return event
@@ -2138,7 +2176,7 @@ function worktreeSnapshot(cwd) {
 // relay STRUCTURED events. onEvent → broadcast `code-event` + print locally +
 // persist to the host file; tool calls round-trip through the perm card; the
 // rolling log replays to joiners and survives bridge restarts (session-store).
-function openStructured({ id, runtime = 'claude', model, models, effort, resume, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, rolePrompt, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
+function openStructured({ id, runtime = 'claude', model, models, effort, resume, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, pendingWorkerCompletions, workerCompletionsInFlight, rolePrompt, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
   if (sessions.has(id)) return
   runtime = structuredRuntimeMetadata(runtime) ? runtime : 'claude'
   mode = structuredModeForSlice(runtime, { mode, sliceType, flowRole })
@@ -2191,7 +2229,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       : (!provider || provider === 'anthropic')
       ? (laneModel || null)
       : (laneModel || providerNameMap()[provider] || provider),
-    provider: provider || null, spawnedBy: spawnedBy || undefined, spawnDepth: structuralDepth, cascadeRole: cascadeRole === 'conductor' || cascadeRole === 'worker' ? cascadeRole : null, hop: initialHop, sideParent: sideParent || undefined, sideTask: sideTask || undefined, pendingSideContexts: Array.isArray(pendingSideContexts) ? pendingSideContexts.filter(Boolean).slice(-4) : [], flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null, managedWorktree: managedWorktree || null,
+    provider: provider || null, spawnedBy: spawnedBy || undefined, spawnDepth: structuralDepth, cascadeRole: cascadeRole === 'conductor' || cascadeRole === 'worker' ? cascadeRole : null, hop: initialHop, sideParent: sideParent || undefined, sideTask: sideTask || undefined, pendingSideContexts: Array.isArray(pendingSideContexts) ? pendingSideContexts.filter(Boolean).slice(-4) : [], pendingWorkerCompletions: Array.isArray(pendingWorkerCompletions) ? pendingWorkerCompletions.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], workerCompletionsInFlight: Array.isArray(workerCompletionsInFlight) ? workerCompletionsInFlight.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null, managedWorktree: managedWorktree || null,
     sliceType: sliceType === 'review' ? 'review' : null,
     flowRole: flowRole || (flowSessionId ? (flowTaskKey ? ((flowReviewTargets?.length || reviewSliceRoots?.length) ? 'reviewer' : 'builder') : 'conductor') : null),
     flowReviewTarget: flowReviewTarget || null,
@@ -2209,6 +2247,12 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   entry._settledTurnRev = Number(restoredBoundary?.turnRev) || null
   entry._turnSettledAt = Number(restoredBoundary?.ts) || null
   entry.interruptedRecap = restoredTurnOpen(entry.log) ? buildRecapFromLog(entry.log, RECAP_CAP) : null
+  // If the bridge died after recording dispatch intent but before the synthetic
+  // turn emitted any transcript evidence, no native turn can be resumed. Keep
+  // the pending outbox and make it eligible for redelivery.
+  if (entry.workerCompletionsInFlight.length && !entry.interruptedRecap) {
+    entry.workerCompletionsInFlight = []
+  }
   // Slice 3 — a permission card left unanswered past the grace window pushes
   // "<lane> — needs you: <what>"; answering it anywhere retracts the banner
   // everywhere. Worker/flow lanes are excluded at arm() time (isUserFacingLane).
@@ -2457,7 +2501,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   // restart. Without this, sessionData omitted it → on restart the resumed session
   // re-launched on the host default (Opus) regardless of the last switch, and the
   // switch looked like it "never changed the model" (Max 2026-07-02). Restored below.
-  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, models: entry.runtime === 'hermes' ? (entry.models || []) : undefined, provider: entry.provider || null, spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth || 0, cascadeRole: entry.cascadeRole || null, hop: entry.hop || 0, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, flowRole: entry.flowRole || null, flowReviewTargets: entry.flowReviewTargets || [], flowReviewSnapshots: entry.flowReviewSnapshots || [], flowReviewRound: entry.flowReviewRound || 0, dispatchBaseSha: entry.dispatchBaseSha || null, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null })
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, models: entry.runtime === 'hermes' ? (entry.models || []) : undefined, provider: entry.provider || null, spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth || 0, cascadeRole: entry.cascadeRole || null, hop: entry.hop || 0, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, pendingWorkerCompletions: entry.pendingWorkerCompletions, workerCompletionsInFlight: entry.workerCompletionsInFlight, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, flowRole: entry.flowRole || null, flowReviewTargets: entry.flowReviewTargets || [], flowReviewSnapshots: entry.flowReviewSnapshots || [], flowReviewRound: entry.flowReviewRound || 0, dispatchBaseSha: entry.dispatchBaseSha || null, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null })
   const persist = () => saveSession(room, id, sessionData())
   // Synchronous flush of this session's record. Used on open (so a brand-new session
   // has a file under its id BEFORE its first event — surviving a restart inside the
@@ -3268,7 +3312,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
             openStructured({
               id, runtime: entry.runtime, model: entry.model || model, effort: entry.effort,
               provider: entry.provider, log: entry.log, commands: entry.commands, mode: entry.mode,
-              spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth, cascadeRole: entry.cascadeRole, hop: entry.hop, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId,
+              spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth, cascadeRole: entry.cascadeRole, hop: entry.hop, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, pendingWorkerCompletions: entry.pendingWorkerCompletions, workerCompletionsInFlight: entry.workerCompletionsInFlight, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId,
               flowTaskKey: entry.flowTaskKey, flowRole: entry.flowRole, flowReviewTarget: entry.flowReviewTarget,
               flowReviewTargets: entry.flowReviewTargets, flowReviewSnapshots: entry.flowReviewSnapshots, flowReviewRound: entry.flowReviewRound,
               dispatchBaseSha: entry.dispatchBaseSha, revertTarget: entry.revertTarget, cwd: entry.cwd,
@@ -3490,6 +3534,14 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       // _turnStart is cleared unconditionally so a stray post-settle event can't
       // re-notify off a stale stamp.
       if (evt.kind === 'result' || evt.kind === 'error') {
+        if (terminalBoundary && entry.workerCompletionsInFlight?.length) {
+          entry.pendingWorkerCompletions = acknowledgeWorkerCompletions(
+            entry.pendingWorkerCompletions,
+            entry.workerCompletionsInFlight,
+          )
+          entry.workerCompletionsInFlight = []
+          entry.flush?.()
+        }
         const edit = designActive.get(id)
         if (edit) {
           const successful = evt.kind === 'result' && (!evt.subtype || evt.subtype === 'success')
@@ -3533,9 +3585,31 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
         const stalePermissionIds = [...entry.pending.keys()]
         drainPending(entry)
         for (const pendingId of stalePermissionIds) bcast('code-perm', { term: id, id: pendingId, decision: 'deny', name: 'agent' })
+        // A spawned worker settling is an execution signal for its owning main
+        // terminal, not a human-facing push. Queue it durably, then start the
+        // owner's continuation immediately if idle (or after its current turn).
+        if (terminalBoundary && entry.spawnedBy && !String(entry.spawnedBy).startsWith('flow:')) {
+          const parent = sessions.get(entry.spawnedBy)
+          const turnRev = Number(evt.turnRev) || Number(entry._turnRev) || 0
+          if (parent && turnRev > 0 && entry._ownerNotifiedTurnRev !== turnRev) {
+            const completion = workerCompletionRecord({
+              workerId: id,
+              workerName: termNames[id],
+              turnRev,
+              subtype: evt.subtype,
+            })
+            if (completion) {
+              entry._ownerNotifiedTurnRev = turnRev
+              parent.pendingWorkerCompletions = enqueueWorkerCompletion(parent.pendingWorkerCompletions, completion)
+              parent.flush?.()
+              schedulePendingWorkerCompletions(parent)
+            }
+          }
+        }
         // Bring-to-main never interrupts an active parent turn. If a handoff arrived
         // while this lane was working, start it on the first idle tick after settle.
         schedulePendingSideContexts(entry)
+        schedulePendingWorkerCompletions(entry)
         const settledAt = Date.now()
         if (shouldRecordTurnDone({ entry, subtype: evt.subtype, startedAt, now: settledAt })) {
           persistAgentEvent({
@@ -3596,6 +3670,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   // before the first debounced save still restores this id instead of dropping it (the
   // room would otherwise show a fresh empty terminal + strand the transcript).
   if (!entry.log.length) entry.flush()
+  schedulePendingWorkerCompletions(entry)
   announce()
   if (!entry.log.length) process.stderr.write(`\n  ◆ structured ${structuredRuntimeMetadata(runtime)?.label || 'agent'} session (${id.slice(0, 8)}) — driven from the room.\n`)
   return entry
@@ -3748,7 +3823,7 @@ function respawnStructured(id, provider) {
   // openStructured seed from the TARGET provider's configured model, which is the
   // only model this lane was ever asked for. A same-env model change never reaches
   // here — that path is an in-place setModel (see provider-switch).
-  const { runtime, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, rolePrompt, reviewSliceRoots, openedAt, lastUsage } = s
+  const { runtime, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, pendingWorkerCompletions, workerCompletionsInFlight, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, rolePrompt, reviewSliceRoots, openedAt, lastUsage } = s
   // Context-carry (2026-07-08): a provider switch is not an SDK resume — the new backend
   // starts blank mid-conversation. Synthesize a plain-text recap from the VISIBLE log NOW
   // (before teardown) and hand it to the fresh session as its first turn so the agent
@@ -3767,7 +3842,7 @@ function respawnStructured(id, provider) {
   // sessionData() (provider included) synchronously on open, so a bridge restart
   // restores the lane on its CURRENT provider, not the original — and its next
   // announce carries the new provider badge (additive {id,name} projection).
-  openStructured({ id, runtime, provider, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, rolePrompt, reviewSliceRoots, openedAt, lastUsage, carryRecap })
+  openStructured({ id, runtime, provider, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, pendingWorkerCompletions, workerCompletionsInFlight, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, rolePrompt, reviewSliceRoots, openedAt, lastUsage, carryRecap })
   return true
 }
 
@@ -4365,8 +4440,7 @@ channel
     if (/^\/diff\s*$/.test(text)) {
       try {
         const cwd = s.cwd || process.cwd()
-        const summary = execFileSync('git', ['-C', cwd, 'status', '--short'], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).trim()
-        ctlLine(summary ? `Working tree changes\n${summary.slice(0, 1600)}` : 'Working tree clean')
+        ctlLine(gitDiffReport({ cwd }))
       } catch { ctlLine('Working-tree diff unavailable outside a readable Git checkout') }
       return
     }
@@ -4447,7 +4521,22 @@ channel
         }
         const preTokens = s.lastUsage?.ctx?.used || null
         bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
-        const nativeCompacted = await s.session.compactContext?.()
+        let nativeCompacted = false
+        try {
+          nativeCompacted = await s.session.compactContext?.()
+        } catch {
+          // The bounded recap below is the safe fallback for a native transport
+          // failure. The roster edge is still settled in finally.
+        } finally {
+          // Native compaction emits usage while compactActive=true, so onEvent
+          // legitimately announces a busy edge. It has no ordinary result event;
+          // close that borrowed edge here after compactContext's finally clears
+          // compactActive, or "Compacting…" degrades into stale "Thinking…".
+          // A browser turn may have arrived while compactContext awaited App
+          // Server readiness. Never let control cleanup settle that ordinary
+          // turn's busy edge; the normal result boundary owns it.
+          if (!s.session.turnActive && settleLaneControl(s)) announce()
+        }
         if (nativeCompacted) {
           const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by, native: true }
           pushLog(s, ce)
@@ -4711,7 +4800,7 @@ channel
             // FL-M6 — restore the flow context (id/role/cwd) so an in-flight flow survives a
             // bridge restart: the conductor keeps its subagent-block + plan interception, and
             // lanes keep their worktree cwd + the ability to mark done.
-            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, models: rec.models, effort: rec.effort, provider: rec.runtime === 'claude' ? rec.provider || undefined : undefined, resume: resumable ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, spawnDepth: rec.spawnDepth, cascadeRole: rec.cascadeRole, hop: rec.hop, sideParent: rec.sideParent, sideTask: rec.sideTask, pendingSideContexts: rec.pendingSideContexts, sliceType: rec.sliceType, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, flowRole: rec.flowRole, flowReviewTarget: rec.flowReviewTarget, flowReviewTargets: rec.flowReviewTargets, flowReviewSnapshots: rec.flowReviewSnapshots, flowReviewRound: rec.flowReviewRound, dispatchBaseSha: rec.dispatchBaseSha, revertTarget: rec.revertTarget, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: wasInterrupted ? recoveryRecap : rec.carryRecap,
+            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, models: rec.models, effort: rec.effort, provider: rec.runtime === 'claude' ? rec.provider || undefined : undefined, resume: resumable ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, spawnDepth: rec.spawnDepth, cascadeRole: rec.cascadeRole, hop: rec.hop, sideParent: rec.sideParent, sideTask: rec.sideTask, pendingSideContexts: rec.pendingSideContexts, pendingWorkerCompletions: rec.pendingWorkerCompletions, workerCompletionsInFlight: rec.workerCompletionsInFlight, sliceType: rec.sliceType, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, flowRole: rec.flowRole, flowReviewTarget: rec.flowReviewTarget, flowReviewTargets: rec.flowReviewTargets, flowReviewSnapshots: rec.flowReviewSnapshots, flowReviewRound: rec.flowReviewRound, dispatchBaseSha: rec.dispatchBaseSha, revertTarget: rec.revertTarget, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: wasInterrupted ? recoveryRecap : rec.carryRecap,
               // Lazy-boot restored terminals that were IDLE + not part of a flow: their transcript
               // shows immediately; the query boots on first turn. Mid-turn + flow terminals boot now
               // (mid-turn needs auto-resume; flow needs its lane live).

package/codex-session.mjs

@@ -1099,7 +1099,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         armTurnLiveness()
       }
       // start the pump if idle
-      if (queue.length === 1) pump()
+      if (queue.length === 1 && !compactActive) pump()
       return true
     },
     abort() {
@@ -1169,7 +1169,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       return true
     },
     async compactContext() {
-      if (turnActive || compactActive || !await ensureAppServer()) return false
+      if (turnActive || compactActive) return false
+      const readyAppServer = await ensureAppServer()
+      // ensureAppServer may need to boot the transport. Re-check after that
+      // await so a normal turn that began meanwhile owns the lane exclusively.
+      if (!readyAppServer || turnActive || compactActive) return false
       compactActive = true
       let startTimer = null
       try {
@@ -1195,6 +1199,9 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         if (startTimer) clearTimeout(startTimer)
         compactStartWaiter = null
         compactActive = false
+        // A human turn accepted while compaction owned the App Server is queued,
+        // not started concurrently. Hand it to the ordinary serialized pump now.
+        if (queue.length) pump()
       }
     },
     async accountUsage() {

package/command-catalog.mjs

@@ -19,7 +19,7 @@ export const CODE_ROOM_COMMANDS = Object.freeze([
   command('/status', 'runtime, model, permissions, and busy state', 'control'),
   command('/usage', 'session usage and provider limits', 'control'),
   command('/context', 'current context-window usage', 'control'),
-  command('/diff', 'working-tree change summary', 'control'),
+  command('/diff', 'Git changes and branch status', 'control'),
   command('/compact', 'compact context', 'runtime'),
   command('/clear', 'clear context · confirms', 'clear'),
   command('/model', 'pick model — opens selector', 'model'),

package/cross-terminal.mjs

@@ -123,6 +123,18 @@ export const settleLaneBusy = (entry) => {
   return true
 }
 
+// Structured controls such as native Codex compaction can borrow the runtime's
+// turnActive flag without emitting an ordinary result event. Close that borrowed
+// roster edge with the same durable revision proof as a normal terminal boundary.
+export const settleLaneControl = (entry, now = Date.now()) => {
+  if (!entry || entry._busyAnn !== true) return false
+  if (!settleLaneBusy(entry)) return false
+  entry._settledTurnRev = Number(entry._turnRev) || null
+  entry._turnSettledAt = Number(now) || Date.now()
+  entry._turnStart = null
+  return true
+}
+
 export const laneStatusOf = (entry = {}, now = Date.now(), limits = LANE_STATUS) => {
   const baseLog = Array.isArray(entry?.log) ? entry.log : []
   const log = baseLog.slice(-limits.failureWindow)

package/git-diff-report.mjs

@@ -0,0 +1,118 @@
+import { execFileSync } from 'node:child_process'
+
+const DEFAULT_MAX_FILES = 24
+const DEFAULT_MAX_COMMITS = 5
+const DEFAULT_MAX_CHARS = 1800
+
+const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`
+
+function defaultRunGit(args, cwd) {
+  return execFileSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 3000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
+function cleanLine(value, max = 240) {
+  return String(value || '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max)
+}
+
+function gitText(runGit, cwd, args) {
+  return String(runGit(args, cwd) || '').trim()
+}
+
+function tryGit(runGit, cwd, args) {
+  try { return gitText(runGit, cwd, args) } catch { return '' }
+}
+
+function resolveComparisonRef(runGit, cwd) {
+  const remoteHead = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])
+  if (remoteHead && tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', remoteHead])) return remoteHead
+  for (const candidate of ['origin/main', 'origin/master', 'main', 'master']) {
+    if (tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', candidate])) return candidate
+  }
+  return ''
+}
+
+function boundedReport(lines, maxChars) {
+  const kept = []
+  let length = 0
+  for (const raw of lines) {
+    const line = cleanLine(raw)
+    if (!line) continue
+    const nextLength = length + (kept.length ? 1 : 0) + line.length
+    if (nextLength > maxChars) {
+      const suffix = '… output shortened'
+      if (length + (kept.length ? 1 : 0) + suffix.length <= maxChars) kept.push(suffix)
+      break
+    }
+    kept.push(line)
+    length = nextLength
+  }
+  return kept.join('\n')
+}
+
+export function gitDiffReport({
+  cwd = process.cwd(),
+  runGit = defaultRunGit,
+  maxFiles = DEFAULT_MAX_FILES,
+  maxCommits = DEFAULT_MAX_COMMITS,
+  maxChars = DEFAULT_MAX_CHARS,
+} = {}) {
+  gitText(runGit, cwd, ['rev-parse', '--show-toplevel'])
+
+  const status = tryGit(runGit, cwd, ['status', '--porcelain=v1', '--untracked-files=normal'])
+  const statusLines = status ? status.split(/\r?\n/).filter(Boolean) : []
+  const branch = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD']) || 'detached HEAD'
+  const head = tryGit(runGit, cwd, ['rev-parse', '--short=8', 'HEAD']) || 'unknown'
+  const subject = cleanLine(tryGit(runGit, cwd, ['log', '-1', '--pretty=%s']), 160)
+  const comparisonRef = resolveComparisonRef(runGit, cwd)
+  const lines = []
+
+  if (statusLines.length) {
+    lines.push(`${plural(statusLines.length, 'uncommitted file')}`)
+    for (const line of statusLines.slice(0, Math.max(0, maxFiles))) lines.push(line)
+    if (statusLines.length > maxFiles) lines.push(`… ${plural(statusLines.length - maxFiles, 'more file')}`)
+  } else {
+    lines.push('No uncommitted changes')
+  }
+
+  lines.push(`Branch · ${branch} · ${head}`)
+
+  if (!comparisonRef) {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
+    return boundedReport(lines, maxChars)
+  }
+
+  const counts = tryGit(runGit, cwd, ['rev-list', '--left-right', '--count', `${comparisonRef}...HEAD`])
+    .split(/\s+/)
+    .map((value) => Number(value))
+  const behind = Number.isFinite(counts[0]) ? counts[0] : 0
+  const ahead = Number.isFinite(counts[1]) ? counts[1] : 0
+
+  if (ahead > 0) {
+    lines.push(`${plural(ahead, 'commit')} ahead of ${comparisonRef}${behind ? ` · ${plural(behind, 'commit')} behind` : ''}`)
+    const commitLines = tryGit(runGit, cwd, ['log', `--max-count=${Math.max(0, maxCommits)}`, '--pretty=%h %s', `${comparisonRef}..HEAD`])
+      .split(/\r?\n/)
+      .filter(Boolean)
+    if (commitLines.length) {
+      lines.push(`Commits not in ${comparisonRef}`)
+      lines.push(...commitLines)
+      if (ahead > commitLines.length) lines.push(`… ${plural(ahead - commitLines.length, 'more commit')}`)
+    }
+  } else if (behind > 0) {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject} · already in ${comparisonRef}`)
+    lines.push(`${plural(behind, 'commit')} behind ${comparisonRef}`)
+  } else {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
+    lines.push(`Up to date with ${comparisonRef}`)
+  }
+
+  return boundedReport(lines, maxChars)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.338",
+  "version": "0.7.340",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
@@ -47,6 +47,7 @@
     "hermes-delegation-guard.mjs",
     "runtime-registry.mjs",
     "command-catalog.mjs",
+    "git-diff-report.mjs",
     "runtime-session.mjs",
     "turn-stall.mjs",
     "update-gate.mjs",
@@ -62,6 +63,7 @@
     "transcript-sanitize.mjs",
     "session-store.mjs",
     "side-lane.mjs",
+    "worker-completion.mjs",
     "cross-terminal.mjs",
     "pair-bus.mjs",
     "direct-pair-room.mjs",

package/worker-completion.mjs

@@ -0,0 +1,57 @@
+// Plus permits six simultaneously dispatched workers. The durable owner queue
+// must retain a completion from every one of them while the owner is busy.
+export const WORKER_COMPLETION_CAP = 6
+
+const clean = (value, cap = 160) => String(value || '').replace(/\s+/g, ' ').trim().slice(0, cap)
+
+export function workerCompletionRecord({
+  workerId,
+  workerName,
+  turnRev,
+  subtype,
+} = {}) {
+  const id = clean(workerId, 80)
+  const rev = Math.max(0, Number(turnRev) || 0)
+  if (!id || !rev) return null
+  return {
+    workerId: id,
+    workerRef: id.slice(0, 8),
+    workerName: clean(workerName, 80) || null,
+    turnRev: rev,
+    outcome: subtype && subtype !== 'success' ? clean(subtype, 40) : 'completed',
+  }
+}
+
+export function enqueueWorkerCompletion(pending, completion, cap = WORKER_COMPLETION_CAP) {
+  const queue = (Array.isArray(pending) ? pending : [])
+    .filter((item) => item?.workerId && Number(item?.turnRev) > 0)
+  if (!completion?.workerId || Number(completion?.turnRev) <= 0) return queue.slice(-cap)
+  const key = `${completion.workerId}:${completion.turnRev}`
+  const deduped = queue.filter((item) => `${item.workerId}:${item.turnRev}` !== key)
+  return [...deduped, completion].slice(-cap)
+}
+
+export function acknowledgeWorkerCompletions(pending, inFlight) {
+  const acknowledged = new Set((Array.isArray(inFlight) ? inFlight : [])
+    .filter((item) => item?.workerId && Number(item?.turnRev) > 0)
+    .map((item) => `${item.workerId}:${item.turnRev}`))
+  return (Array.isArray(pending) ? pending : [])
+    .filter((item) => item?.workerId && Number(item?.turnRev) > 0)
+    .filter((item) => !acknowledged.has(`${item.workerId}:${item.turnRev}`))
+}
+
+export function workerCompletionPrompt(pending) {
+  const queue = (Array.isArray(pending) ? pending : [])
+    .filter((item) => item?.workerId && Number(item?.turnRev) > 0)
+    .slice(-WORKER_COMPLETION_CAP)
+  if (!queue.length) return ''
+  const lanes = queue.map((item) => {
+    const label = item.workerName ? `${item.workerName} (${item.workerRef || String(item.workerId).slice(0, 8)})` : (item.workerRef || String(item.workerId).slice(0, 8))
+    return `- ${label}: ${item.outcome || 'completed'}`
+  }).join('\n')
+  return `[ThinkPool worker completion signal]
+Your owned worker lane${queue.length === 1 ? ' has finished and is' : 's have finished and are'} idle:
+${lanes}
+
+Continue the current task now. Call read_terminal exactly once for each finished worker, verify and integrate its result, then call close_terminal for that worker. Do not wait for a person to prompt you.`
+}