thinkpool-pair 0.7.199 → 0.7.201

package/account.mjs

@@ -20,6 +20,7 @@ import { publicKeyB64, announceProviders, listProviders, addProvider, addProvide
 import { supervisorServes } from './serve-consent.mjs'
 import { resolveServeDir } from './serve-dir.mjs'
 import { pairKeyFor, pairTopic, CROSSROOM_BUS } from './cross-terminal.mjs'
+import { installedAgentCommands } from './agent-detect.mjs'
 
 const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { return null } })()
 
@@ -557,7 +558,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // to spawn against — re-read each announce so an add/remove reflects immediately.
   // Both are additive; older clients ignore them (feature: multi-provider BYOK, slice 1).
   const PROVIDER_PUBKEY = publicKeyB64()
-  const pushPresence = () => trackPresence({ name: machine, version: VERSION, rooms: [...children.keys()], refused: [...refused].map(([code, reason]) => ({ code, reason })), service: runsAsService(), providerPubKey: PROVIDER_PUBKEY, providers: announceProviders(), ts: Date.now() })
+  const pushPresence = () => trackPresence({ name: machine, version: VERSION, rooms: [...children.keys()], refused: [...refused].map(([code, reason]) => ({ code, reason })), service: runsAsService(), providerPubKey: PROVIDER_PUBKEY, providers: announceProviders(), agents: installedAgentCommands().map((cmd) => ({ cmd })), ts: Date.now() })
 
   // ── Provider registry — the multi-BYOK wire contract (slice 1). ─────────────
   // AUTH: the account channel `tpacct:<uid>` is created WITHOUT config.private:true,

package/agent-detect.mjs

@@ -0,0 +1,28 @@
+// One installed-agent detector shared by the room bridge and account supervisor.
+// Both surfaces announce the same machine; they must not disagree about which
+// coding CLIs it can open merely because they publish on different channels.
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const KNOWN_AGENT_COMMANDS = [
+  'claude', 'codex', 'gemini', 'aider', 'cursor-agent',
+  'opencode', 'copilot', 'goose', 'crush', 'qwen',
+]
+
+export function commandOnPath(command, { env = process.env, platform = process.platform, fsImpl = fs } = {}) {
+  const exts = platform === 'win32'
+    ? (env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
+    : ['']
+  const delimiter = platform === 'win32' ? ';' : path.delimiter
+  for (const dir of (env.PATH || '').split(delimiter)) {
+    if (!dir) continue
+    for (const ext of exts) {
+      try { if (fsImpl.existsSync(path.join(dir, command + ext))) return true } catch { /* unreadable path entry */ }
+    }
+  }
+  return false
+}
+
+export function installedAgentCommands(options) {
+  return KNOWN_AGENT_COMMANDS.filter((command) => commandOnPath(command, options))
+}

package/bridge.mjs

@@ -52,6 +52,7 @@ import { z } from 'zod'
 import { startClaudeSession } from './claude-session.mjs'
 import { startCodexSession, readCodexDefaultModel, readCodexModels, codexConfigForMode } from './codex-session.mjs'
 import { createManagedLaneWorktree, removeManagedLaneWorktree } from './lane-worktree.mjs'
+import { commandOnPath } from './agent-detect.mjs'
 
 const STRUCTURED_MODES = new Set(['default', 'acceptEdits', 'plan', 'bypassPermissions'])
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
@@ -178,19 +179,7 @@ function claudeHasSession() {
   } catch { return false }
 }
 
-// Is `c` on PATH? Pure-Node scan (no `which` subprocess), cross-platform.
-const onPath = (c) => {
-  const exts = process.platform === 'win32'
-    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
-    : ['']
-  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
-    if (!dir) continue
-    for (const ext of exts) {
-      try { if (fs.existsSync(path.join(dir, c + ext))) return true } catch { /* noop */ }
-    }
-  }
-  return false
-}
+const onPath = (command) => commandOnPath(command)
 
 // Pick which installed agent to share → resolves to a command string. A single
 // match (or non-TTY stdin, e.g. piped) auto-selects with no prompt.
@@ -855,15 +844,16 @@ const sessions = new Map()
 let attachedId = null
 let shuttingDown = false
 
-// Background warmer (2026-07-02): after a restart, proactively cold-boot the lazily-
-// restored IDLE terminals — ready-gated to ≤WARM_CONCURRENCY at once so there's no
-// boot-storm (the contention that made restore take minutes) — so they're warm BEFORE
-// the user clicks them, erasing the lazy-boot first-turn penalty. A user turn to a
-// still-cold terminal boots it on demand as the fallback. warmComplete frees a slot when
-// a terminal's init `system` event proves it live (called from onEvent).
+// Background warming is OPT-IN. Even a per-room cap multiplies under the account
+// supervisor: four rooms at concurrency 3 launched twelve Claude SDK cold boots at once,
+// stretching measured readiness from ~15s to 40–66s and leaving every idle process
+// resident. Restored transcripts already paint immediately and sendTurn boots a cold lane
+// on demand, so the safe default is zero speculative runtimes. TP_BACKGROUND_WARM=1 keeps
+// the old behaviour available for a deliberately single-room host.
 const warmQueue = []
 let warmingCount = 0
 const WARM_CONCURRENCY = 3
+const BACKGROUND_WARM_ENABLED = process.env.TP_BACKGROUND_WARM === '1'
 function pumpWarm() {
   while (warmingCount < WARM_CONCURRENCY && warmQueue.length) {
     const e = warmQueue.shift()
@@ -2704,7 +2694,10 @@ channel
       // 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)
-      openStructured({ id: payload.id, runtime, mode: payload.mode, model: payload.model || undefined, provider: runtime === 'codex' ? undefined : payload.provider || undefined })
+      // 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 })
       process.stderr.write(`\n  ◆ web opened a structured "${payload.cmd}" session (${payload.mode || 'default'}${payload.model ? `, model ${payload.model}` : ''}).\n`)
       return
     }
@@ -2840,7 +2833,7 @@ channel
   // ── structured-session control (Phase 2) ──
   .on('broadcast', { event: 'code-open' }, ({ payload }) => {
     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 })
+    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: 'code-turn' }, async ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
@@ -3231,10 +3224,9 @@ channel
           // saved-session restore above still runs unconditionally, so a bridge
           // restart resumes backgrounded sessions regardless of this guard.
           else if (attachedCmd) openStructured({ id: randomUUID(), runtime: structuredRuntime(attachedCmd) })
-          // Background-warm the lazily-restored idle terminals shortly after restore, so
-          // they're ready before the user clicks them (no first-turn penalty). Delayed so the
-          // eagerly-booted (mid-turn / auto-resumed) sessions get the machine to themselves first.
-          setTimeout(() => {
+          // Optional compatibility lever for deliberately single-room hosts. Account-mode
+          // and normal standalone launches leave restored idle lanes truly lazy by default.
+          if (BACKGROUND_WARM_ENABLED) setTimeout(() => {
             for (const [, e] of sessions) if (e.deferred && !e.warmed && !e.warming && !e.session?.started) warmQueue.push(e)
             if (warmQueue.length) { process.stderr.write(`\n  ◆ background-warming ${warmQueue.length} idle terminal(s) (≤${WARM_CONCURRENCY} at a time)…\n`); pumpWarm() }
           }, 6000)

package/claude-session.mjs

@@ -239,7 +239,9 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   // long time"; settingSources:['user','project','local'] boots every host MCP
   // server + SessionStart hook + plugin before init. This is the A-side baseline;
   // open a terminal with TP_MCP_STRICT=1 (below) for the B-side to isolate MCP's share.
-  const spawnT0 = Date.now()
+  // A lazy lane may sit unopened for hours. Start the latency clock when query() really
+  // launches, not when the lightweight tab/session wrapper is created.
+  let spawnT0 = null
   let readyLogged = false
   let modelsSent = false   // one-shot: emit the SDK's supported-model list on first init
   let sdkToolsChecked = false   // one-shot: run the AskUserQuestion regression guard on the first init carrying tools[]
@@ -804,6 +806,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   const runQuery = async () => {
+    if (spawnT0 == null) spawnT0 = Date.now()
     started = true
     // Per-query AbortController (child of the session `ac`): lets a model switch kill
     // just this query. Resolve the previous qDone in case it's still pending.

package/codex-event-mapper.mjs

@@ -28,16 +28,27 @@
 // the existing risk classifier (claude-session.classifyRisk) and room rendering
 // apply unchanged. Codex v1 is observe-only (no per-tool card) — classification
 // is for display accent + future gating, not blocking (spec §tradeoff).
+import fs from 'node:fs'
+
+const safeMcpPart = (value) => String(value || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_')
+const mcpToolName = (item) => `mcp__${safeMcpPart(item?.server)}__${safeMcpPart(item?.tool)}`
+const resultText = (value) => {
+  if (typeof value === 'string') return value
+  if (value == null) return ''
+  try { return JSON.stringify(value) } catch { return String(value) }
+}
 
 export class CodexEventMapper {
   /**
    * @param {{onEvent:(evt)=>void, model?:string|null, sessionId?:string|null}} opts
    */
-  constructor({ onEvent, model = null, sessionId = null }) {
+  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs }) {
     this._onEvent = onEvent
     this._model = model || null
     this._sessionId = sessionId || null
     this._starts = new Map() // item.id → startMs (for durationMs)
+    this._fileBefore = new Map() // item.id → [{ path, kind, content }]
+    this._fs = fsImpl
     this._systemSent = false
   }
 
@@ -68,10 +79,18 @@ export class CodexEventMapper {
         if (it.type === 'command_execution') {
           this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: 'Bash', input: { command: it.command || '' } }], parentToolUseId: null })
         } else if (it.type === 'file_change') {
-          const c = (it.changes && it.changes[0]) || {}
-          this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: c.kind === 'add' ? 'Write' : 'Edit', input: { path: c.path || '' } }], parentToolUseId: null })
+          const before = (it.changes || []).map((c) => {
+            let content = ''
+            if (c.kind !== 'add' && c.path) {
+              try { content = this._fs.readFileSync(c.path, 'utf8') } catch { /* missing/unreadable → empty */ }
+            }
+            return { path: c.path || '', kind: c.kind || 'update', content }
+          })
+          this._fileBefore.set(it.id, before)
         } else if (it.type === 'web_search') {
           this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: 'WebSearch', input: { query: it.query || '' } }], parentToolUseId: null })
+        } else if (it.type === 'mcp_tool_call') {
+          this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: mcpToolName(it), input: it.arguments || {} }], parentToolUseId: null })
         }
         // agent_message / reasoning have no item.started (burst on completion).
         return
@@ -92,13 +111,30 @@ export class CodexEventMapper {
           const bad = it.exit_code != null ? it.exit_code !== 0 : false
           this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: it.aggregated_output || '' }], isError: bad, durationMs, parentToolUseId: null })
         } else if (it.type === 'file_change') {
-          const c = (it.changes && it.changes[0]) || {}
-          const verb = c.kind === 'add' ? 'wrote' : 'edited'
-          this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: `${verb} ${c.path || ''}` }], isError: false, durationMs, parentToolUseId: null })
+          const before = this._fileBefore.get(it.id) || (it.changes || []).map((c) => ({ path: c.path || '', kind: c.kind || 'update', content: '' }))
+          this._fileBefore.delete(it.id)
+          const edits = before.map((c) => {
+            let next = ''
+            if (c.kind !== 'delete' && c.path) {
+              try { next = this._fs.readFileSync(c.path, 'utf8') } catch { /* deleted/unreadable → empty */ }
+            }
+            return { file_path: c.path, path: c.path, old_string: c.content, new_string: next, kind: c.kind }
+          })
+          const first = edits[0] || { file_path: '', path: '', old_string: '', new_string: '', kind: 'update' }
+          const name = edits.length > 1 ? 'MultiEdit' : first.kind === 'add' ? 'Write' : 'Edit'
+          const input = name === 'MultiEdit'
+            ? { edits }
+            : name === 'Write'
+              ? { file_path: first.file_path, path: first.path, content: first.new_string }
+              : first
+          this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name, input }], parentToolUseId: null })
+          this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: `${name === 'Write' ? 'wrote' : 'edited'} ${first.path}` }], isError: false, durationMs, parentToolUseId: null })
         } else if (it.type === 'web_search') {
           this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: it.query || 'search completed' }], isError: false, durationMs, parentToolUseId: null })
+        } else if (it.type === 'mcp_tool_call') {
+          this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: it.error?.message || resultText(it.result) }], isError: it.status === 'failed' || !!it.error, durationMs, parentToolUseId: null })
         }
-        // mcp_tool_call / plan_update remain additive future event shapes. Unknown
+        // plan_update remains an additive future event shape. Unknown
         // items are ignored rather than risking a malformed transcript row.
         return
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.199",
+  "version": "0.7.201",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
     "turn-stall.mjs",
     "update-gate.mjs",
     "agent-notify.mjs",
+    "agent-detect.mjs",
     "event-id.mjs",
     "plan-meters.mjs",
     "recap.mjs",