thinkpool-pair 0.7.214 → 0.7.216

package/bridge.mjs

@@ -104,6 +104,7 @@ import { armInterruptedResume, sendInterruptedContinue, supersedeInterruptedResu
 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'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine, codexUsageReportLine, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
+import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, sideContextBlock, sideSnapshot } from './side-lane.mjs'
 import { planMeterLine } from './plan-meters.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 import { resolveAnonKey, DEFAULT_SUPABASE_URL } from './supabase-key.mjs'
@@ -1045,7 +1046,7 @@ const announce = () => {
       // 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 || [], canSteer: s.session?.canSteer ?? false } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
+      ...[...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 || [], canSteer: s.session?.canSteer ?? false } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.sideParent ? { sideParent: s.sideParent, sideTask: s.sideTask || undefined, sideHandback: !!s.sideHandback } : {}), ...(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 +
@@ -1542,7 +1543,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, effort, resume, log, commands, mode, spawnedBy, rolePrompt, flowSessionId, flowTaskKey, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
+function openStructured({ id, runtime = 'claude', model, effort, resume, log, commands, mode, spawnedBy, sideParent, sideTask, pendingSideContexts, rolePrompt, flowSessionId, flowTaskKey, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
   if (sessions.has(id)) return
   runtime = runtime === 'codex' ? 'codex' : 'claude'
   // No explicit mode → a sensible default per runtime (see defaultModeForRuntime):
@@ -1579,7 +1580,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       : (!provider || provider === 'anthropic')
       ? (laneModel || null)
       : (laneModel || providerNameMap()[provider] || provider),
-    provider: provider || null, spawnedBy: spawnedBy || undefined, flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null, managedWorktree: managedWorktree || null,
+    provider: provider || null, spawnedBy: spawnedBy || undefined, 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,
     // Stable creation order — persisted so a bridge restart restores tabs in the SAME
     // order (not readdir/filesystem order). Legacy recs (no openedAt) derive it from the
     // first transcript event ts, so even the first post-fix restart is ordered right.
@@ -1773,7 +1774,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // 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, provider: entry.provider || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, 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, provider: entry.provider || null, spawnedBy: entry.spawnedBy, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, 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
@@ -1936,7 +1937,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // fork-bomb breaker, now one level deeper (2026-07-10 cascade-spawn-depth spec).
       tool(
         'spawn_terminal',
-        'Open a NEW agent terminal (Claude or Codex) in this ThinkPool Code room — YOUR lane to use, not a sibling that is already working. The runtime defaults to inheriting this lane, or pass `runtime` to dispatch across runtimes. Use it to fan work out or run a cascade: give it an initial `task`, collect its result later with read_terminal, then ALWAYS close_terminal it — a finished lane left open holds a slot against the room cap and blocks the next fan-out. By default the new lane INHERITS your current permission mode. ALWAYS prefer spawning a fresh lane over post_to_terminal into one that is already busy. Bounded by cascade depth, the room terminal cap, and per-turn limits.',
+        'Open a NEW agent terminal (Claude or Codex) in this ThinkPool Code room — YOUR lane to use, not a sibling that is already working. The runtime defaults to inheriting this lane, or pass `runtime` to dispatch across runtimes. Choose `model` explicitly from advertised metadata when practical: for Codex use Luna/Mini for mechanical work, Terra for ordinary feature/fix work, and Sol only for repeated-failure, architecture/conductor, or adversarial final-review work; never inherit Sol by default, and omit `model` for runtime fallback when the named tier is unavailable. Give the lane an initial `task`, collect its result later with read_terminal, then ALWAYS close_terminal it — a finished lane left open holds a slot against the room cap and blocks the next fan-out. By default the new lane INHERITS your current permission mode. ALWAYS prefer spawning a fresh lane over post_to_terminal into one that is already busy. Bounded by cascade depth, the room terminal cap, and per-turn limits.',
         {
           name: z.string().max(80).optional().describe('a short label for the new lane so the room (and you) can find it, e.g. "Research: topologies"'),
           task: z.string().optional().describe('an initial task to hand the new lane immediately; omit to open it idle'),
@@ -2216,7 +2217,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
         try { entry.mockupWatcher?.close() } catch { /* noop */ }
         try { void entry.viewport?.stop()?.catch(() => {}) } catch { /* noop */ }
         sessions.delete(id)
-        openStructured({ id, runtime: entry.runtime, model, log: entry.log, commands: entry.commands, mode: entry.mode })
+        openStructured({ id, runtime: entry.runtime, model, log: entry.log, commands: entry.commands, mode: entry.mode, provider: entry.provider, spawnedBy: entry.spawnedBy, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, rolePrompt: entry.rolePrompt, cwd: entry.cwd, managedWorktree: entry.managedWorktree })
         return
       }
       // Stamp a wall-clock ts AND a stable cid on every transcript event before
@@ -2391,6 +2392,26 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       // _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 (entry.sideHandback) {
+          const request = entry.sideHandback
+          entry.sideHandback = null
+          const parent = sessions.get(request.parentId)
+          const successful = evt.kind === 'result' && (!evt.subtype || evt.subtype === 'success')
+          const summary = successful ? (String(evt.resultText || '').trim() || assistantTextSince(entry.log, request.afterSeq)) : ''
+          if (parent && summary) {
+            const context = sideContextBlock({ sideId: id, sideName: termNames[id], task: entry.sideTask, summary })
+            parent.pendingSideContexts = appendSideContext(parent.pendingSideContexts, context)
+            const handoff = { kind: 'side-handback', sideId: id, sideName: termNames[id] || 'Side lane', task: entry.sideTask || '', text: summary, by: request.by }
+            stampEvent(handoff); pushLog(parent, handoff); bcast('code-event', { term: request.parentId, evt: handoff })
+            const done = { kind: 'control', text: 'Brought to main.', by: request.by }
+            stampEvent(done); pushLog(entry, done); bcast('code-event', { term: id, evt: done })
+            parent.flush?.()
+          } else {
+            const failed = { kind: 'control', text: parent ? 'Couldn’t prepare a handoff — try again.' : 'The main terminal is no longer available.', by: request.by }
+            stampEvent(failed); pushLog(entry, failed); bcast('code-event', { term: id, evt: failed })
+          }
+          entry.flush?.(); announce()
+        }
         const startedAt = entry._turnStart
         entry._turnStart = null
         // A canceled/failed App Server request can settle the turn without the
@@ -2589,7 +2610,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, flowSessionId, flowTaskKey, cwd, rolePrompt, reviewSliceRoots, openedAt } = s
+  const { runtime, log, commands, mode, spawnedBy, sideParent, sideTask, pendingSideContexts, flowSessionId, flowTaskKey, cwd, rolePrompt, reviewSliceRoots, openedAt } = 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
@@ -2608,7 +2629,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, flowSessionId, flowTaskKey, cwd, rolePrompt, reviewSliceRoots, openedAt, carryRecap })
+  openStructured({ id, runtime, provider, log, commands, mode, spawnedBy, sideParent, sideTask, pendingSideContexts, flowSessionId, flowTaskKey, cwd, rolePrompt, reviewSliceRoots, openedAt, carryRecap })
   return true
 }
 
@@ -2660,7 +2681,7 @@ function endStructured(id) {
     // Cascade-close its direct children (spawnedBy === this id — a real terminal id, not a
     // `flow:<id>` marker, so flow lanes are untouched; maxHop:1 means no deeper recursion).
     for (const [cid, ce] of [...sessions]) {
-      if (ce.spawnedBy === id) endStructured(cid)
+      if (ce.spawnedBy === id || ce.sideParent === id) endStructured(cid)
     }
   }
   deleteSession(room, id)   // remove <id>.json so loadAll() won't bring it back
@@ -2771,11 +2792,60 @@ channel
       // previous terminal's model (and the first uses the provider default). Falls
       // through to the SDK default when absent. Stamped on the entry so the announce
       // carries it at open (chip shows the model immediately, not the branch).
-      const runtime = structuredRuntime(payload.cmd)
+      let runtime = structuredRuntime(payload.cmd)
+      let sideParent = null
+      let parent = null
+      if (payload.sideParent) {
+        const requested = sessions.get(payload.sideParent)
+        sideParent = requested?.sideParent || payload.sideParent
+        parent = sessions.get(sideParent)
+        if (!parent || !String(payload.sideTask || '').trim()) {
+          bcast('side-open-failed', { id: payload.id, parent: sideParent, message: parent ? 'Add a task after /side.' : 'The main terminal is not live.' })
+          return
+        }
+        runtime = parent.runtime || runtime
+        if (payload.name) { termNames[payload.id] = String(payload.name).slice(0, 80); saveNames(room, termNames) }
+      }
       // Opening a tab is not work. Paint and announce it immediately, then cold-boot the
       // expensive Claude/Codex runtime on its first real turn. This keeps a fresh terminal
       // instant and prevents abandoned tabs from becoming permanent resident processes.
-      openStructured({ id: payload.id, runtime, mode: payload.mode, model: payload.model || undefined, provider: runtime === 'codex' ? undefined : payload.provider || undefined, defer: true })
+      openStructured({
+        id: payload.id,
+        runtime,
+        mode: parent?.mode || payload.mode,
+        model: parent?.model || payload.model || undefined,
+        provider: runtime === 'codex' ? undefined : (parent?.provider || payload.provider || undefined),
+        cwd: parent ? (parent.cwd || process.cwd()) : undefined,
+        sideParent: sideParent || undefined,
+        sideTask: sideParent ? String(payload.sideTask).trim() : undefined,
+        rolePrompt: sideParent ? SIDE_ROLE_PROMPT : undefined,
+        defer: true,
+      })
+      if (sideParent) {
+        const child = sessions.get(payload.id)
+        const task = String(payload.sideTask).trim()
+        const by = String(payload.by || 'A room member')
+        const sideName = termNames[payload.id] || 'Side lane'
+        if (!child) {
+          bcast('side-open-failed', { id: payload.id, parent: sideParent, message: 'The side lane could not start.' })
+          return
+        }
+        child.hop = 0
+        const childEvent = { kind: 'you', text: task, by }
+        stampEvent(childEvent); pushLog(child, childEvent); bcast('code-event', { term: payload.id, evt: childEvent })
+        const parentEvent = { kind: 'side-started', sideId: payload.id, sideName, task, by }
+        stampEvent(parentEvent); pushLog(parent, parentEvent); bcast('code-event', { term: sideParent, evt: parentEvent })
+        const snapshot = sideSnapshot(parent.log.filter((event) => event.cid !== parentEvent.cid))
+        const prompt = snapshot ? `${snapshot}\n\n--- side task ---\n${task}` : task
+        try { child.session.sendTurn(prompt) } catch {
+          bcast('side-open-failed', { id: payload.id, parent: sideParent, message: 'The side agent could not start.' })
+          endStructured(payload.id)
+          return
+        }
+        child.flush?.(); parent.flush?.(); announce()
+        process.stderr.write(`\n  ◆ ${by} opened side lane ${String(payload.id).slice(0, 8)} under ${String(sideParent).slice(0, 8)}.\n`)
+        return
+      }
       process.stderr.write(`\n  ◆ web opened a structured "${payload.cmd}" session (${payload.mode || 'default'}${payload.model ? `, model ${payload.model}` : ''}).\n`)
       return
     }
@@ -2924,6 +2994,27 @@ channel
     if (payload?.host && payload.host !== name) return
     openStructured({ id: payload?.id || randomUUID(), runtime: payload?.runtime, model: payload?.model, provider: payload?.runtime === 'codex' ? undefined : payload?.provider, resume: payload?.resume, mode: payload?.mode, defer: true })
   })
+  .on('broadcast', { event: 'side-handback-request' }, ({ payload }) => {
+    const side = payload?.term && sessions.get(payload.term)
+    if (!side?.sideParent || side.sideParent !== payload?.parent) return
+    const by = String(payload?.by || 'A room member')
+    if (side.sideHandback || side.session?.turnActive) {
+      const busy = { kind: 'control', text: 'Finish or stop the current side-lane turn before bringing it to main.', by }
+      stampEvent(busy); pushLog(side, busy); bcast('code-event', { term: payload.term, evt: busy })
+      return
+    }
+    side.sideHandback = { parentId: side.sideParent, by, afterSeq: maxSeq(side.log) }
+    const preparing = { kind: 'control', text: 'Preparing a compact handoff for main…', by }
+    stampEvent(preparing); pushLog(side, preparing); bcast('code-event', { term: payload.term, evt: preparing })
+    side.flush?.(); announce()
+    try { side.session.sendTurn(SIDE_HANDOFF_PROMPT) }
+    catch {
+      side.sideHandback = null
+      const failed = { kind: 'control', text: 'Couldn’t start the handoff — try again.', by }
+      stampEvent(failed); pushLog(side, failed); bcast('code-event', { term: payload.term, evt: failed })
+      side.flush?.(); announce()
+    }
+  })
   .on('broadcast', { event: 'code-turn' }, async ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
     if (!s || payload.text == null) return
@@ -3069,7 +3160,10 @@ channel
     // — a separate recap turn would race + double-fire) and clear the flag so the init handler
     // no-ops. The visible `you` echo is unchanged; the recap is context for the agent only.
     let sendText = text
-    if (s.pendingRecap) { sendText = `${s.pendingRecap}\n\n--- the person's next message ---\n${text}`; s.pendingRecap = null; s.flush?.() }
+    const carried = []
+    if (s.pendingRecap) { carried.push(s.pendingRecap); s.pendingRecap = null }
+    if (s.pendingSideContexts?.length) { carried.push(...s.pendingSideContexts); s.pendingSideContexts = [] }
+    if (carried.length) { sendText = `${carried.join('\n\n')}\n\n--- the person's next message ---\n${text}`; s.flush?.() }
     // The browser's `hostPath` is display metadata, not host authority. Rebuild
     // image paths from the bridge-owned UPDIR + deterministic attachment fields,
     // then cover the separate file-put/code-turn download race with a bounded
@@ -3312,7 +3406,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, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: rec.carryRecap,
+            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, sideParent: rec.sideParent, sideTask: rec.sideTask, pendingSideContexts: rec.pendingSideContexts, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: 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-app-server.mjs

@@ -214,13 +214,14 @@ export class CodexAppServerClient {
     return id
   }
 
-  async startTurn({ threadId, input, images, model, effort, approvalPolicy } = {}) {
+  async startTurn({ threadId, input, images, model, effort, approvalPolicy, collaborationMode } = {}) {
     const result = await this.request('turn/start', {
       threadId,
       input: turnInput(input, images),
       ...(model ? { model } : {}),
       ...(effort ? { effort } : {}),
       ...(approvalPolicy ? { approvalPolicy } : {}),
+      ...(collaborationMode ? { collaborationMode } : {}),
     }, this.turnStartTimeoutMs)
     const turnId = result?.turn?.id || result?.turnId
     if (!turnId) throw new Error('Codex App Server did not return a turn id')

package/codex-session.mjs

@@ -46,6 +46,18 @@ export function codexConfigForMode(mode) {
   return CODEX_MODE_CONFIG[mode] || CODEX_MODE_CONFIG.default
 }
 
+export function codexDefaultCollaborationMode(model, effort) {
+  if (!model) return null
+  return {
+    mode: 'default',
+    settings: {
+      model: String(model),
+      reasoning_effort: EFFORT_LEVELS.has(effort) ? effort : null,
+      developer_instructions: null,
+    },
+  }
+}
+
 /**
  * The permission mode a FRESHLY-OPENED terminal gets when none was specified
  * (the person clicked "+ New terminal" without picking a mode). Codex defaults
@@ -476,6 +488,10 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         model: activeModel,
         sandbox,
         approvalPolicy: modeConfig.approvalPolicy,
+        // Codex 0.144.1 gates request_user_input by INTERNAL collaboration
+        // mode. Enable it for Default mode on this thread without changing the
+        // independent ThinkPool sandbox / approval posture above.
+        config: { 'features.default_mode_request_user_input': true },
       })
       appServerThreadReady = true
       mapper.push({ type: 'thread.started', thread_id: sessionId })
@@ -505,6 +521,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         model: activeModel,
         effort: activeEffort,
         approvalPolicy: modeConfig.approvalPolicy,
+        collaborationMode: codexDefaultCollaborationMode(activeModel, activeEffort),
       })
       const completed = await appServer.waitForTurn(activeTurnId)
       const status = completed?.turn?.status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.214",
+  "version": "0.7.216",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -30,6 +30,7 @@
     "recap.mjs",
     "transcript-sanitize.mjs",
     "session-store.mjs",
+    "side-lane.mjs",
     "cross-terminal.mjs",
     "interrupted-resume.mjs",
     "flow-conductor.mjs",

package/side-lane.mjs

@@ -0,0 +1,42 @@
+import { buildRecapFromLog } from './recap.mjs'
+
+export const SIDE_RECAP_CAP = 12_000
+
+export const SIDE_ROLE_PROMPT = `You are a ThinkPool side lane attached to a main terminal.
+Focus first on reading, searching, comparing, and answering the side task. You are a full agent and share the main terminal's working directory, so coordinate through ThinkPool Peer before changing files that another lane may be editing. Do not make edits unless a person explicitly asks for them in this side lane. Keep the investigation self-contained; the main terminal receives nothing until a person chooses Bring to main.`
+
+export const SIDE_HANDOFF_PROMPT = `Prepare a compact handoff for the main terminal now.
+Return only the handoff. Include: conclusion, strongest evidence, files changed or artifacts produced, and any unresolved question or recommended next action. Do not continue the investigation and do not address the reader conversationally.`
+
+export function sideSnapshot(log) {
+  return buildRecapFromLog(Array.isArray(log) ? log : [], SIDE_RECAP_CAP)
+}
+
+export function assistantTextSince(log, afterSeq = 0) {
+  const chunks = []
+  for (const event of Array.isArray(log) ? log : []) {
+    if (event?.kind !== 'assistant') continue
+    if (Number.isFinite(afterSeq) && Number.isFinite(event.seq) && event.seq <= afterSeq) continue
+    for (const block of Array.isArray(event.blocks) ? event.blocks : []) {
+      if (block?.type === 'text' && String(block.text || '').trim()) chunks.push(String(block.text).trim())
+    }
+  }
+  return chunks.join('\n\n').trim()
+}
+
+export function sideContextBlock({ sideId, sideName, task, summary }) {
+  const label = String(sideName || 'Side lane').trim()
+  const ref = String(sideId || '').slice(0, 8)
+  const lines = [
+    `--- side-lane handoff: ${label}${ref ? ` (${ref})` : ''} ---`,
+    task ? `Task: ${String(task).trim()}` : '',
+    String(summary || '').trim(),
+    '--- end side-lane handoff ---',
+  ]
+  return lines.filter(Boolean).join('\n')
+}
+
+export function appendSideContext(contexts, context, cap = 4) {
+  if (!context) return Array.isArray(contexts) ? contexts.slice(-cap) : []
+  return [...(Array.isArray(contexts) ? contexts : []), context].slice(-cap)
+}

package/thinkpool-room-prompt.mjs

@@ -15,5 +15,6 @@ export const THINKPOOL_REMOTE_DELIVERY_RULES = Object.freeze([
 
 export const CODEX_THINKPOOL_FIRST_TURN_PREAMBLE = [
   'ENVIRONMENT (authoritative): You are Codex running inside a ThinkPool Code room, driven live through the thinkpool-pair bridge by a user and possibly a partner. This is a shared remote workspace, not an ordinary local terminal session; act accordingly.',
+  'MODEL TIERING FOR DISPATCH: When calling spawn_terminal for Codex, explicitly choose from the available model metadata when practical: gpt-5.6-luna or gpt-5.4-mini for mechanical/scaffold/search/formatting work; gpt-5.6-terra for ordinary feature/fix work; gpt-5.6-sol only for trap-laden repeated failures, architecture/conductor work, or adversarial final review. Do not inherit or select Sol by default. If a named model is unavailable, use the nearest advertised lower tier or omit model and allow runtime fallback.',
   ...THINKPOOL_REMOTE_DELIVERY_RULES,
 ].join(' ')