thinkpool-pair 0.7.339 → 0.7.340

package/bridge.mjs

@@ -119,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'
@@ -130,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'
@@ -1110,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
@@ -2139,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 })
@@ -2192,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,
@@ -2210,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).
@@ -2458,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
@@ -3269,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,
@@ -3491,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')
@@ -3534,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({
@@ -3597,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
@@ -3749,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
@@ -3768,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
 }
 
@@ -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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.339",
+  "version": "0.7.340",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
@@ -63,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.`
+}