thinkpool-pair 0.7.221 → 0.7.223

package/codex-session.mjs

@@ -39,6 +39,7 @@ export const CODEX_MODE_CONFIG = {
   default:           { sandbox: 'workspace-write', approvalPolicy: 'untrusted' },
   acceptEdits:       { sandbox: 'workspace-write', approvalPolicy: 'on-request' },
   plan:              { sandbox: 'read-only',       approvalPolicy: 'never' },
+  review:            { sandbox: 'workspace-write', approvalPolicy: 'never' },
   bypassPermissions: { sandbox: 'danger-full-access', approvalPolicy: 'never' },
 }
 
@@ -73,6 +74,15 @@ export function defaultModeForRuntime(runtime) {
   return runtime === 'codex' ? 'bypassPermissions' : 'default'
 }
 
+export function codexWritableDirsForSandbox(sandbox, writableDirs = []) {
+  return normalizeCodexSandbox(sandbox) === 'read-only' ? [] : writableDirs
+}
+
+export function codexExtraWritableDirsForMode(mode, sandbox, writableDirs = []) {
+  if (mode === 'review') return []
+  return codexWritableDirsForSandbox(sandbox, writableDirs)
+}
+
 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')
@@ -183,11 +193,15 @@ export function codexPublishAccess({ cwd, env = process.env, tmpdir = os.tmpdir(
   }
 }
 
+export const CODEX_ROOM_CASCADE_REMINDER = [
+  'THINKPOOL ROOM WORKFLOW: delegated work belongs in visible spawn_terminal lanes, never hidden in-process subagents. Each lane owns its own worktree. For a genuinely decomposable task, state a short plan in chat, use sliceType scaffold for mechanical work, feature/fix for builders, and review for adversarial verification; review must use a balanced model tier. Read results, verify the integrated outcome, and close every lane you spawned so it does not consume room capacity.',
+].join(' ')
+
 export function buildCodexPrompt({ text, rolePrompt, roomContext, firstTurn = false }) {
   const context = typeof roomContext === 'function' ? roomContext() : roomContext
   const additions = [
     firstTurn ? CODEX_THINKPOOL_FIRST_TURN_PREAMBLE : '',
-    rolePrompt,
+    rolePrompt || CODEX_ROOM_CASCADE_REMINDER,
     context,
   ].map((v) => String(v || '').trim()).filter(Boolean)
   if (!additions.length) return String(text ?? '')
@@ -470,7 +484,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         appServer = appServerFactory({
           cwd,
           env: childEnv,
-          args: buildCodexAppServerArgs({ providerConfig, mcpUrl: peer?.url, writableDirs: publishAccess.writableDirs }),
+          args: buildCodexAppServerArgs({ providerConfig, mcpUrl: peer?.url, writableDirs: codexExtraWritableDirsForMode(activeMode, sandbox, publishAccess.writableDirs) }),
           onNotification: appServerNotification,
           onServerRequest: appServerRequest,
           onClose: (error) => {
@@ -572,7 +586,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       approvalPolicy: modeConfig.approvalPolicy,
       providerConfig,
       mcpUrl: peer?.url,
-      writableDirs: publishAccess.writableDirs,
+      writableDirs: codexExtraWritableDirsForMode(activeMode, sandbox, publishAccess.writableDirs),
       images: Array.isArray(options.images) ? options.images : [],
       prompt,
     })

package/design-edit.mjs

@@ -1,5 +1,6 @@
 import crypto from 'node:crypto'
 import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 
 const MAX_SOURCE_BYTES = 2 * 1024 * 1024
@@ -110,11 +111,36 @@ function safeTarget(value) {
     name: clean(value.name, 240),
     text: clean(value.text, MAX_TEXT),
     canEditText: value.canEditText === true,
+    canReplaceImage: value.canReplaceImage === true,
+    nodeKey: clean(value.nodeKey, 80),
+    parentNodeKey: clean(value.parentNodeKey, 80),
     rect,
   }
 }
 
-export function validateDesignRequest(payload, registry) {
+function safeMovement(value) {
+  if (!value || typeof value !== 'object') return null
+  const fromIndex = Number(value.fromIndex)
+  const toIndex = Number(value.toIndex)
+  if (![fromIndex, toIndex].every(Number.isSafeInteger) || fromIndex < 0 || toIndex < 0 || fromIndex > 499 || toIndex > 499) return null
+  return { fromIndex, toIndex }
+}
+
+function safeAsset(value, room) {
+  if (!value || typeof value !== 'object') return null
+  const asset = {
+    path: clean(value.path, 700),
+    name: clean(value.name, 240),
+    mediaType: clean(value.mediaType, 120).toLowerCase(),
+    size: Number(value.size),
+  }
+  const prefix = room ? `code/${String(room).toUpperCase()}/design-drafts/` : 'code/'
+  if (!asset.path.startsWith(prefix) || asset.path.split('/').includes('..') || !asset.mediaType.startsWith('image/')) return null
+  if (!Number.isSafeInteger(asset.size) || asset.size <= 0 || asset.size > 10 * 1024 * 1024) return null
+  return asset
+}
+
+export function validateDesignRequest(payload, registry, room = '') {
   if (!payload || typeof payload !== 'object') return { ok: false, error: 'invalid-request' }
   const previewId = clean(payload.previewId, 64)
   const record = registry.get(previewId)
@@ -122,12 +148,44 @@ export function validateDesignRequest(payload, registry) {
   if (clean(payload.revision, 64) !== record.revision) return { ok: false, error: 'stale-preview' }
   const target = safeTarget(payload.target)
   if (!target?.selector && !target?.xpath) return { ok: false, error: 'select-an-element' }
-  const mode = payload.mode === 'text' ? 'text' : payload.mode === 'prompt' ? 'prompt' : null
+  const mode = ['text', 'prompt', 'move', 'image'].includes(payload.mode) ? payload.mode : null
   if (!mode) return { ok: false, error: 'invalid-mode' }
   const intent = clean(payload.intent, mode === 'text' ? MAX_TEXT : MAX_INTENT)
-  if (!intent) return { ok: false, error: mode === 'text' ? 'enter-text' : 'describe-change' }
+  if (['text', 'prompt'].includes(mode) && !intent) return { ok: false, error: mode === 'text' ? 'enter-text' : 'describe-change' }
   if (mode === 'text' && !target.canEditText) return { ok: false, error: 'text-edit-not-safe' }
-  return { ok: true, record, request: { previewId, revision: record.revision, mode, intent, target, cid: clean(payload.cid, 80) } }
+  const movement = mode === 'move' ? safeMovement(payload.movement) : null
+  if (mode === 'move' && (!movement || movement.fromIndex === movement.toIndex)) return { ok: false, error: 'invalid-move' }
+  const asset = mode === 'image' ? safeAsset(payload.asset, room) : null
+  if (mode === 'image' && (!target.canReplaceImage || !asset)) return { ok: false, error: 'invalid-image' }
+  return { ok: true, record, request: { previewId, revision: record.revision, mode, intent, target, movement, asset, cid: clean(payload.cid, 80) } }
+}
+
+export async function materializeDesignAsset({ webBase, token, room, asset, requestId, fetcher = fetch }) {
+  if (!webBase || !token || !room || !asset?.path || !requestId) return null
+  const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }
+  const signed = await fetcher(`${String(webBase).replace(/\/$/, '')}/api/code-attachment-url`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ code: room, path: asset.path }),
+  })
+  if (!signed.ok) return null
+  const { url } = await signed.json()
+  if (!url) return null
+  const response = await fetcher(url)
+  if (!response.ok) return null
+  const data = Buffer.from(await response.arrayBuffer())
+  if (!data.length || data.length > 10 * 1024 * 1024) return null
+  const ext = path.extname(asset.name).replace(/[^.a-zA-Z0-9]/g, '').slice(0, 9) || '.img'
+  const dir = path.join(os.tmpdir(), 'thinkpool-design-assets')
+  const file = path.join(dir, `${clean(requestId, 80)}${ext}`)
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(file, data)
+  await fetcher(`${String(webBase).replace(/\/$/, '')}/api/code-design-draft`, {
+    method: 'DELETE',
+    headers,
+    body: JSON.stringify({ code: room, path: asset.path }),
+  }).catch(() => {})
+  return file
 }
 
 export function designPrompt({ record, request, by, restore = false, priorRecord = null }) {
@@ -136,6 +194,10 @@ export function designPrompt({ record, request, by, restore = false, priorRecord
     ? `Restore only the immediately previous Design Mode change by comparing the current artifact with this bridge-created verified backup: ${priorRecord?.backupPath || '(backup unavailable)'}. Do not overwrite unrelated changes.`
     : request.mode === 'text'
     ? `Replace only this element's visible text with:\n${request.intent}`
+    : request.mode === 'move'
+    ? `Move only this selected element within its current direct parent, from sibling position ${request.movement.fromIndex + 1} to ${request.movement.toIndex + 1}. Preserve the parent, responsive behavior, semantics, and every other sibling.`
+    : request.mode === 'image'
+    ? `Replace only this selected image's content with the uploaded image at this bridge-local temporary path:\n${request.asset.localPath}\nCopy it into an appropriate durable project asset location. Preserve the existing image frame, dimensions, border radius, object-fit behavior, responsive rules, and surrounding layout.`
     : `Apply this visual change to only the selected element unless the instruction explicitly requires its immediate context:\n${request.intent}`
   return `A room member used ThinkPool Design Mode on the artifact below. This is an authorized source edit in your current workspace.\n\nArtifact source: ${record.sourcePath}\nWorkspace: ${record.workspaceRoot}\nExpected source revision: ${record.revision}\nRequested by: ${clean(by || 'A room member', 120)}\nOperation: ${restore ? 'restore the immediately previous verified Design Mode revision' : request.mode}\n\nSelected element:\n${target}\n\n${action}\n\nRules:\n- Re-read the exact artifact source and confirm its revision/content still matches the selected element before editing.\n- Edit the canonical source above; do not search for or edit a different plausible file.\n- Preserve unrelated content and styling.\n- Use the existing mockup render workflow to produce both desktop and mobile captures after the edit. Run it with TP_DESIGN_REQUEST_ID=${request.cid} and TP_DESIGN_PARENT_REVISION=${record.revision} in the command environment so the proof correlates to this request.\n- Do not claim this is live until both captures succeed and the room receives the manifest.\n- If the target is stale or ambiguous, stop without editing and explain that the person must reselect it.`
 }

package/flow-conductor.mjs

@@ -63,6 +63,12 @@ export const FLOW_CONDUCTOR_PROMPT = [
   'MODE-AWARE. The user picked a mode — steer (watch every lane live), guide (DEFAULT: approve this plan, then review at phase boundaries), or autopilot (full-auto with a budget cap + adaptive escalation that pulls them in only if a lane stalls). Produce the full plan now regardless; the mode changes how much the human intervenes later, not how you decompose.',
 ].join(' ')
 
+export const FLOW_CODEX_CONDUCTOR_PROMPT = [
+  'THINKPOOL FLOW CONDUCTOR — you are decomposition-only. Do not build, edit files, run commands, or spawn agents. Read only when needed to make the decomposition concrete.',
+  'Turn the request into a small acyclic graph of independently runnable slices with disjoint file ownership. Each task needs key, title, scope, acceptance, deps, and sliceType (scaffold, feature, fix, or review). Review is intelligence-sensitive and must never be assigned a cheap/mechanical tier. Every review task must depend on exactly ONE builder task; express builder -> review -> downstream explicitly in the DAG.',
+  'Submit the finished graph by calling the ThinkPool submit_flow_plan MCP tool with one JSON object encoded in its plan argument. Do not write FLOW_PLAN.json and do not use ExitPlanMode. The MCP submission is your only completion path; after it succeeds, stop and wait for the room.',
+].join(' ')
+
 // Env vars handed to a conductor session via startClaudeSession({ env }). The conductor
 // reads these to know which Flow run it owns + what mode the human picked.
 export function buildConductorEnv ({ flowSessionId, mode, budgetCapAutopilot = null }) {
@@ -98,6 +104,13 @@ export const FLOW_LANE_PROMPT = [
   'BE RIGOROUS, NOT VIBES. Trace the data path, root-cause before fixing, verify before claiming done. A lane that ships a guess costs the whole ensemble.',
 ].join(' ')
 
+export const FLOW_CODEX_LANE_PROMPT = [
+  'THINKPOOL FLOW — you are one builder lane in an ensemble. The conductor gives you one runnable slice with disjoint scope. Edit only that scope and never touch another lane or worktree.',
+  'Done means the slice runs and its acceptance proof has been observed. Diagnose before changing code, verify with the real command or behavior, and make one focused git commit in your assigned worktree. Do not push.',
+  'After the commit and verification succeed, call the ThinkPool mark_flow_done MCP tool exactly once. Do not write FLOW_DONE. The MCP call is the completion signal that records your commit and unblocks dependent slices.',
+  'Do not spawn more lanes. If the scope is unsafe or a dependency is missing, report the blocker instead of editing outside your ownership.',
+].join(' ')
+
 // Env vars handed to a lane session so it knows its Flow run + which task it owns.
 export function buildLaneEnv ({ flowSessionId, taskKey, laneId }) {
   return {
@@ -238,4 +251,3 @@ export function activateLaneSkill (name, { publicDir, customDir, fs } = {}) {
   const dirs = publicDir === undefined && customDir === undefined ? flowSkillDirs() : { publicDir, customDir }
   return skillLoadBody(name, { ...dirs, ...(fs ? { fs } : {}) })
 }
-

package/flow-host-revert.mjs

@@ -0,0 +1,42 @@
+// Host-owned Flow revert lifecycle. Supabase broadcast channels use self:false,
+// so a reviewer on this bridge must call this handler directly; remote broadcasts
+// delegate to the same function.
+export async function executeFlowRevert({
+  payload,
+  bridgeName,
+  lanes = [],
+  prepareLane,
+  rememberRedispatch,
+  endLane,
+  stopPreview,
+  revert,
+  broadcastReverted,
+  wait = () => Promise.resolve(),
+  onPrepError = () => {},
+} = {}) {
+  if (!payload?.flowId || !payload?.taskKey) return { ok: false, ignored: 'invalid' }
+  if (payload.host && payload.host !== bridgeName) return { ok: false, ignored: 'wrong-host' }
+  let killed = false
+  for (const [laneId, entry] of lanes) {
+    if (entry?.flowSessionId !== payload.flowId || entry?.flowTaskKey !== payload.taskKey || entry?.flowDone) continue
+    try {
+      const prepared = prepareLane?.(entry, payload)
+      if (prepared) rememberRedispatch?.(prepared, entry, payload)
+    } catch (error) { onPrepError(error, entry, payload) }
+    entry.flowDone = true
+    endLane?.(laneId, entry)
+    stopPreview?.(payload.flowId, laneId)
+    killed = true
+  }
+  if (killed) await wait()
+  const reverted = await revert(payload)
+  const result = {
+    ok: true,
+    flowId: payload.flowId,
+    taskKey: payload.taskKey,
+    reviewTaskKey: payload.reviewTaskKey || null,
+    branch: reverted?.branch || null,
+  }
+  await broadcastReverted(result)
+  return result
+}

package/flow-models.mjs

@@ -0,0 +1,77 @@
+// Runtime-aware model routing for Flow and ordinary room cascades.
+// Pure over the supplied environment/catalog so the bridge never sends a model slug
+// that the selected runtime did not advertise.
+
+const CLAUDE_TIERS = {
+  scaffold: 'sonnet',
+  feature: 'opus',
+  fix: 'opus',
+  review: 'opus',
+}
+
+const CODEX_SCAFFOLD = ['gpt-5.6-luna', 'gpt-5.4-mini', 'gpt-5.3-codex-spark']
+const CODEX_BALANCED = ['gpt-5.6-terra', 'gpt-5.4']
+
+export function normalizeFlowRuntime(runtime, fallback = null) {
+  if (runtime === 'claude' || runtime === 'codex') return runtime
+  return fallback === 'claude' || fallback === 'codex' ? fallback : null
+}
+
+export function modelCatalogValues(catalog = []) {
+  return new Set((Array.isArray(catalog) ? catalog : []).map((model) => (
+    typeof model === 'string' ? model : model?.value || model?.slug
+  )).filter(Boolean))
+}
+
+function firstVisible(candidates, catalog) {
+  const visible = modelCatalogValues(catalog)
+  for (const candidate of candidates) if (visible.has(candidate)) return candidate
+  if (candidates === CODEX_SCAFFOLD) {
+    for (const model of visible) if (/spark/i.test(model)) return model
+  }
+  return undefined
+}
+
+export function flowLaneModelFor({ sliceType, runtime = 'claude', catalog = [], env = process.env } = {}) {
+  if (normalizeFlowRuntime(runtime, 'claude') === 'codex') {
+    const override = env.TP_FLOW_CODEX_LANE_MODEL
+    if (override === 'inherit') return undefined
+    if (override) return modelCatalogValues(catalog).has(override) ? override : undefined
+    return firstVisible(sliceType === 'scaffold' ? CODEX_SCAFFOLD : CODEX_BALANCED, catalog)
+  }
+  const override = env.TP_FLOW_CLAUDE_LANE_MODEL || env.TP_FLOW_LANE_MODEL
+  if (override === 'inherit') return undefined
+  if (override) return override
+  return CLAUDE_TIERS[sliceType] || 'opus'
+}
+
+export function flowConductorModelFor({ runtime = 'claude', originModel, catalog = [], env = process.env } = {}) {
+  if (normalizeFlowRuntime(runtime, 'claude') === 'codex') {
+    const override = env.TP_FLOW_CODEX_CONDUCTOR_MODEL
+    if (override === 'inherit') return undefined
+    const visible = modelCatalogValues(catalog)
+    if (override) return visible.has(override) ? override : undefined
+    return originModel && visible.has(originModel) ? originModel : undefined
+  }
+  const override = env.TP_FLOW_CLAUDE_CONDUCTOR_MODEL || env.TP_FLOW_CONDUCTOR_MODEL
+  if (override === 'inherit') return undefined
+  // Claude non-regression: the conductor historically inherited the host default,
+  // not the invoking lane's selected model.
+  return override || undefined
+}
+
+export function spawnedLaneModelFor({ explicitModel, sliceType, runtime = 'claude', catalog = [], env = process.env } = {}) {
+  return explicitModel || flowLaneModelFor({ sliceType, runtime, catalog, env })
+}
+
+export function resolveCodexModel(requested, catalog = []) {
+  if (!requested) return undefined
+  return modelCatalogValues(catalog).has(requested) ? requested : undefined
+}
+
+export function assertRuntimeModelCompatible({ runtime = 'claude', provider = null, model } = {}) {
+  if (runtime === 'claude' && (!provider || provider === 'anthropic') && /^gpt-/i.test(String(model || ''))) {
+    throw new Error(`Codex model ${JSON.stringify(model)} cannot run on the built-in Claude provider`)
+  }
+  return true
+}

package/flow-review.mjs

@@ -32,6 +32,13 @@ export const FLOW_REVIEWER_PROMPT = [
   'EMIT YOUR VERDICT BY WRITING FLOW_REVIEW.json. Do NOT call mark_flow_done or ExitPlanMode (they hang here). As your LAST action, use the Write tool with file_path "FLOW_REVIEW.json" and content = a single JSON object { "pass": <boolean>, "reasons": ["<specific finding>", ...], "taskKey": "<the slice you reviewed>", "exhausted": <boolean, optional — true only when you have nothing left to check> }. `pass: false` reverts the reviewed slice so it rebuilds. The content of FLOW_REVIEW.json must be ONLY that JSON object (no prose, no markdown fences). Do not edit the slice — you review, you do not fix.',
 ].join('  ')
 
+export const FLOW_CODEX_REVIEWER_PROMPT = [
+  'THINKPOOL FLOW REVIEW — you are a non-mutating adversarial reviewer. Your native sandbox lets you write only inside your OWN disposable reviewer worktree. The reviewed builder worktree is outside that writable root: never edit, commit, revert, install into, or repair it.',
+  'For any install/build/test that produces files, copy the reviewed source into a scratch directory under your own current worktree first, then run the write-producing command against that scratch copy. Read-only inspection may target the reviewed worktree directly.',
+  'Independently reproduce every acceptance criterion and hunt edge cases, reloads, repeated actions, concurrency, malformed input, and error paths. A green happy path is only the floor. If a claim cannot be reproduced, reject it with the exact command/output.',
+  'Submit each review round by calling the ThinkPool submit_flow_review MCP tool with a JSON verdict: {"pass":boolean,"reasons":["specific evidence"],"taskKey":"allowed reviewed task","exhausted":boolean}. Do not write FLOW_REVIEW.json and do not call mark_flow_done. A pass without exhausted=true may trigger another bounded hunt round; a failure triggers the room revert path.',
+].join(' ')
+
 // Parse a reviewer's raw verdict. Accepts an object OR a JSON string (optionally
 // ```json-fenced). Tolerant of the fence the model sometimes wraps; throws on garbage.
 // Returns { pass, reasons } — pass coerced to boolean, reasons normalized to string[].

package/flow-task-graph.mjs

@@ -173,6 +173,27 @@ export function normalizePlanOutput (raw) {
   return { summary, tasks }
 }
 
+// Codex review protocol deliberately maps one reviewer lane to one builder target.
+// Claude's legacy Flow plans may review several deps and remain unchanged.
+export function validatePlanForRuntime (plan, runtime = 'claude') {
+  if (runtime !== 'codex') return plan
+  for (const task of plan?.tasks || []) {
+    if (task.sliceType === SLICE_TYPE.review && task.deps.length !== 1) {
+      throw new Error(`Codex review task "${task.key}" must depend on exactly one builder task`)
+    }
+  }
+  return plan
+}
+
+export function validReviewTargetShape (task, runtime = 'claude') {
+  if (!task || task.slice_type !== SLICE_TYPE.review) return true
+  return runtime !== 'codex' || (Array.isArray(task.deps) && task.deps.length === 1)
+}
+
+export function legacyBuilderCompletionAllowed ({ runtime, flowRole, eventKind, eventSubtype, interrupted = false } = {}) {
+  return runtime === 'claude' && flowRole === 'builder' && !interrupted && eventKind === 'result' && eventSubtype === 'success'
+}
+
 // ── Flow lane model tiers ───────────────────────────────────────────────────
 // Spec: docs/specs/2026-07-03-flow-lane-model-tiers.md
 // The conductor thinks; the worker lanes type. Running every lane on the same

package/interrupted-resume.mjs

@@ -11,6 +11,27 @@ export function sendInterruptedContinue(entry) {
   catch { return false }
 }
 
+// A text recap is the fallback when the native thread cannot be resumed. Claude
+// already has a live init event to trigger this; Codex does not -- sending the
+// recap is what starts its fresh exec process. Consume atomically, but restore it
+// if delivery was refused so the next human turn can still prepend the context.
+export function dispatchPendingRecap(entry) {
+  const recap = typeof entry?.pendingRecap === 'string' ? entry.pendingRecap : ''
+  if (!recap.trim()) return false
+  entry.pendingRecap = null
+  try { entry.flush?.() } catch { /* best effort */ }
+  try {
+    if (entry.session?.sendTurn?.(recap) === false) {
+      entry.pendingRecap = recap
+      return false
+    }
+    return true
+  } catch {
+    entry.pendingRecap = recap
+    return false
+  }
+}
+
 export function armInterruptedResume(entry) {
   if (!entry?.session) return 'unavailable'
   if (entry.runtime === 'codex') return sendInterruptedContinue(entry) ? 'sent' : 'unavailable'
@@ -18,6 +39,37 @@ export function armInterruptedResume(entry) {
   return 'armed'
 }
 
+export function recoverInterruptedTurn(entry, { resumable = false, recap = '' } = {}) {
+  if (!entry?.session) return 'unavailable'
+  if (resumable) return armInterruptedResume(entry)
+  if (!String(recap || '').trim()) return 'unavailable'
+  entry.pendingRecap = String(recap)
+  if (entry.runtime === 'codex') return dispatchPendingRecap(entry) ? 'recap-sent' : 'unavailable'
+  return 'recap-armed'
+}
+
+export function isMissingResumeError(message) {
+  return /No conversation found|no rollout found for thread id|thread\/resume[^\n]*failed[^\n]*no rollout/i.test(String(message || ''))
+}
+
+// Bound the stale-native-thread self-heal at the ownership seam. The old entry is
+// marked before teardown/reopen so duplicate error delivery can never fork another
+// process. `reopen` returns the new structured entry; Codex consumes the recap
+// immediately because a fresh exec has no idle init event.
+export function recoverMissingResumeOnce(entry, { message, recap = '', reopen } = {}) {
+  if (!entry || entry.recovered || !isMissingResumeError(message)) return { recovered: false, delivery: 'ignored' }
+  entry.recovered = true
+  try { entry.session?.end?.() } catch { /* already dead */ }
+  let recovered = null
+  try { recovered = reopen?.(String(recap || '')) || null } catch { /* caller surfaces reopen failure */ }
+  if (!recovered) return { recovered: true, delivery: 'unavailable', entry: null }
+  return {
+    recovered: true,
+    delivery: recoverInterruptedTurn(recovered, { resumable: false, recap }),
+    entry: recovered,
+  }
+}
+
 // A real person speaking always wins the race. Otherwise a human turn that starts a
 // cold Claude/Codex runtime can trigger its init event and enqueue a stale second
 // `continue` behind the person's actual request.
@@ -26,4 +78,3 @@ export function supersedeInterruptedResume(entry) {
   entry.pendingAutoResume = false
   return true
 }
-

package/lane-worktree.mjs

@@ -12,11 +12,26 @@ export function createManagedLaneWorktree({ terminalId, cwd = process.cwd(), git
   if (!root) throw new Error('not a git repository')
   const dir = path.join(root, '.thinkpool', 'worktrees', `terminal-${short}`)
   const branch = `thinkpool/terminal/${short}`
+  const base = resolveLaneBase({ root, git })
   fsImpl.mkdirSync(path.dirname(dir), { recursive: true })
-  git(['worktree', 'add', '-b', branch, dir, 'HEAD'], root)
+  git(['worktree', 'add', '-b', branch, dir, base], root)
   return { terminalId: id, root, dir, branch }
 }
 
+// Ordinary lanes should start from the repository's upstream default branch, not
+// whichever parked/stale branch happens to be checked out in the bridge process.
+// Repositories without a remote remain useful: fall back through conventional local
+// defaults and finally HEAD.
+function resolveLaneBase({ root, git }) {
+  for (const candidate of ['origin/HEAD', 'origin/main', 'origin/master', 'main', 'master', 'HEAD']) {
+    try {
+      const resolved = String(git(['rev-parse', '--verify', '--quiet', candidate], root) || '').trim()
+      if (resolved) return candidate
+    } catch { /* try the next base */ }
+  }
+  return 'HEAD'
+}
+
 export function removeManagedLaneWorktree({ terminalId, managedWorktree, git = runGit } = {}) {
   const id = String(terminalId || '')
   const rec = managedWorktree && typeof managedWorktree === 'object' ? managedWorktree : null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.221",
+  "version": "0.7.223",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -36,6 +36,8 @@
     "flow-conductor.mjs",
     "flow-worktree.mjs",
     "flow-task-graph.mjs",
+    "flow-models.mjs",
+    "flow-host-revert.mjs",
     "flow-preview.mjs",
     "viewport.mjs",
     "design-edit.mjs",