thinkpool-pair 0.7.197 → 0.7.199

package/account.mjs

@@ -39,25 +39,26 @@ function pidAlive(pid) {
   try { process.kill(pid, 0); return true } catch (e) { return e.code === 'EPERM' }
 }
 
-// Returns true if we now hold the lock, false if another LIVE supervisor holds it.
-// A stale lock (holder dead / garbage / ours) is taken over. fs errors fail-OPEN
-// (return true) — a lock we can't manage must never block the real bridge.
+// Returns true only if we demonstrably hold the lock. A stale lock (holder dead /
+// garbage / ours) is taken over. Filesystem errors fail CLOSED: serving without a
+// lock can start a second bridge, and duplicate bridges can race terminal reconcile
+// and delete room history. A temporarily unmanageable lock is safer than that.
 export function acquireSingleton(lockPath = LOCK) {
-  try { fs.mkdirSync(path.dirname(lockPath), { recursive: true }) } catch { /* noop */ }
+  try { fs.mkdirSync(path.dirname(lockPath), { recursive: true }) } catch { return false }
   for (let i = 0; i < 3; i++) {
     try {
       const fd = fs.openSync(lockPath, 'wx')        // atomic create-exclusive
       fs.writeSync(fd, String(process.pid)); fs.closeSync(fd)
       return true
     } catch (e) {
-      if (e.code !== 'EEXIST') return true           // can't create for another reason → fail open
+      if (e.code !== 'EEXIST') return false          // cannot prove ownership → refuse to serve
       let pid = 0
-      try { pid = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10) || 0 } catch { /* unreadable */ }
+      try { pid = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10) || 0 } catch { return false }
       if (pidAlive(pid)) return false                // a live supervisor owns it → refuse
-      try { fs.rmSync(lockPath, { force: true }) } catch { return true }   // stale → drop + retry
+      try { fs.rmSync(lockPath, { force: true }) } catch { return false }  // stale but unmanageable
     }
   }
-  return true
+  return false
 }
 
 // Release only if WE own it (don't unlink a lock another instance took over).

package/bridge.mjs

@@ -1053,7 +1053,7 @@ const announce = () => {
       // turnActive). Authoritative — the bridge owns the turn — so the /code
       // dashboard reads "N agents working" off the roster instead of sniffing
       // the live code-event stream (which a passive dashboard channel misses).
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, commands: s.commands, mode: s.mode || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(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, busy: s.session?.turnActive ?? false, 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 || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(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 +
@@ -1546,7 +1546,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, 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, rolePrompt, flowSessionId, flowTaskKey, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage }) {
   if (sessions.has(id)) return
   runtime = runtime === 'codex' ? 'codex' : 'claude'
   mode = STRUCTURED_MODES.has(mode) ? mode : 'default'
@@ -1563,7 +1563,8 @@ function openStructured({ id, runtime = 'claude', model, resume, log, commands,
   // spawnedBy: set when this lane was Dispatched (spawn_terminal). Restored from the
   // session store so the Ensemble flag survives a bridge restart (else a respin
   // stripped it and the lane reverted to a plain tab — the t6 "no chip" bug).
-  const entry = { cmd: runtime, runtime, kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode, models: runtime === 'codex' ? readCodexModels() : undefined,
+  effort = new Set(['low', 'medium', 'high', 'xhigh', 'max']).has(effort) ? effort : 'high'
+  const entry = { cmd: runtime, runtime, kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode, effort, models: runtime === 'codex' ? readCodexModels() : undefined,
     // model: truthful active-model label — now the SAME `laneModel` the SDK is given, so the
     // chip cannot disagree with the wire. When this lane runs on a custom (non-anthropic)
     // registered provider the SDK id is impersonated (see the onEvent guard below), so
@@ -1767,7 +1768,7 @@ function openStructured({ id, runtime = 'claude', model, resume, log, commands,
   // 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 || resume || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, 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 })
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || resume || 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 })
   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
@@ -2114,7 +2115,7 @@ function openStructured({ id, runtime = 'claude', model, resume, log, commands,
     // laneModel, NOT the raw `model` param: the SDK's `model` option OVERRIDES the
     // ANTHROPIC_MODEL supplied by resolveProviderEnv() in `env` below, so an inherited
     // Claude id here defeats the whole per-provider env. undefined → option omitted.
-    cwd: cwd || process.cwd(), model: laneModel, resume, mode, rolePrompt,
+    cwd: cwd || process.cwd(), model: laneModel, effort, resume, mode, rolePrompt,
     // Idle ordinary tabs create nothing. Immediately before the FIRST real
     // turn (human prompt, dispatch, or cascade task), the runtime calls this
     // while still cold; subsequent turns reuse the persisted worktree.
@@ -3006,6 +3007,23 @@ channel
       else if (payload.mode === 'acceptEdits') acceptEditsPending(s)
     }
   })
+  .on('broadcast', { event: 'code-effort' }, ({ payload }) => {
+    const s = payload?.term && sessions.get(payload.term)
+    const valid = new Set(['low', 'medium', 'high', 'xhigh', 'max'])
+    if (!s || !valid.has(payload.level)) return
+    if (s.session?.turnActive) {
+      const evt = { kind: 'control', text: 'finish or stop the current turn before switching thinking power' }
+      pushLog(s, evt)
+      bcast('code-event', { term: payload.term, evt })
+      return
+    }
+    Promise.resolve(s.session.setEffort?.(payload.level)).then((ok) => {
+      if (ok === false) return
+      s.effort = payload.level
+      s.flush?.()
+      announce()
+    }).catch(() => {})
+  })
   .on('broadcast', { event: 'code-close' }, ({ payload }) => {
     endStructured(payload?.id)
   })
@@ -3165,7 +3183,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, 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,
+            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,
               // 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/claude-session.mjs

@@ -205,7 +205,7 @@ const TP_ROOM_REMINDER = [
   'Verify before claiming done — show runtime evidence you produced, not "should work, go test it".',
 ].join(' ')
 
-export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, didSpawnTarget = null, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null, lazy = false, roomContext = null, suggest = true, prepareCwd = null }) {
+export function startClaudeSession({ cwd, model, effort: initialEffort = 'high', resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, didSpawnTarget = null, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null, lazy = false, roomContext = null, suggest = true, prepareCwd = null }) {
   // Per-turn reminder + live ROOM NOW tail. roomContext (bridge-supplied) returns the
   // room's CURRENT state — sibling lanes, active git worktrees — or null. The static
   // rules keep the agent aware of the room's FEATURES; the live tail keeps it aware of
@@ -251,7 +251,8 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   let mode = MODES.has(initialMode) ? initialMode : 'default'  // mirrors ⇧⇥ cycle
   const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
   const toolStart = new Map()     // tool_use id → start time, for the duration badge
-  let effort = null               // active reasoning effort for the turn (from the hook input)
+  const effortLevels = new Set(['low', 'medium', 'high', 'xhigh', 'max'])
+  let effort = effortLevels.has(initialEffort) ? initialEffort : 'high'
   // Live token count for the thinking indicator — mirrors Claude Code's
   // "↓ N tokens": the turn's billed OUTPUT tokens (thinking is billed as
   // output, so this is the full count, not just the reasoning estimate). A
@@ -736,6 +737,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   if (mcpServers && Object.keys(mcpServers).length) opts.mcpServers = { ...(opts.mcpServers || {}), ...mcpServers }
   if (cwd) opts.cwd = cwd
   if (model) opts.model = model
+  opts.effort = effort
   // NB: resume is NOT baked into opts — runQuery sets it per-run from the live `sessionId`
   // (seeded from `resume`). That makes the resume target controllable: a re-create can point
   // it at persistedSessionId, and the "No conversation found" recovery can DROP it (clearing
@@ -1197,6 +1199,16 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       if (turnActive) { pendingSwitch = true; return }
       await recreateForSwitch()
     },
+    async setEffort(level) {
+      if (!effortLevels.has(level) || closed) return false
+      effort = level
+      opts.effort = level
+      emit({ kind: 'effort', level })
+      if (!started) return true
+      if (turnActive) { pendingSwitch = true; return true }
+      await recreateForSwitch()
+      return true
+    },
     async listModels() {
       try {
         const ms = await q?.supportedModels?.()

package/codex-session.mjs

@@ -32,6 +32,7 @@ import { startCodexMcpHttp } from './codex-mcp-http.mjs'
 
 const DEFAULT_SANDBOX = 'workspace-write'
 const SAFE_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access'])
+export const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max'])
 export const CODEX_MODE_CONFIG = {
   default:           { sandbox: 'workspace-write', approvalPolicy: 'untrusted' },
   acceptEdits:       { sandbox: 'workspace-write', approvalPolicy: 'on-request' },
@@ -96,7 +97,7 @@ export function buildCodexPrompt({ text, rolePrompt, roomContext }) {
   return `<thinkpool-context>\n${additions.join('\n\n')}\n</thinkpool-context>\n\n${String(text ?? '')}`
 }
 
-export function buildCodexExecArgs({ sessionId, model, sandbox, approvalPolicy = 'untrusted', providerConfig, mcpUrl, writableDirs = [], prompt }) {
+export function buildCodexExecArgs({ sessionId, model, effort, sandbox, approvalPolicy = 'untrusted', providerConfig, mcpUrl, writableDirs = [], prompt }) {
   const safeSandbox = normalizeCodexSandbox(sandbox)
   const args = sessionId
     // `codex exec resume` deliberately has no --sandbox option. The resumed
@@ -106,6 +107,7 @@ export function buildCodexExecArgs({ sessionId, model, sandbox, approvalPolicy =
     : ['exec', '--json', '--sandbox', safeSandbox, '--skip-git-repo-check']
   if (model) args.push('-m', model)
   args.push('-c', `approval_policy="${approvalPolicy}"`)
+  if (EFFORT_LEVELS.has(effort)) args.push('-c', `model_reasoning_effort="${effort}"`)
   if (providerConfig) args.push('-c', providerConfig)
   // `resume` retains the roots selected by the fresh rollout and does not
   // accept --add-dir itself. Supply these only when creating the thread.
@@ -129,7 +131,7 @@ export function buildCodexExecArgs({ sessionId, model, sandbox, approvalPolicy =
  * @param {string} [o.providerConfig] optional -c overrides / provider block (M2: from the provider registry)
  * @returns {{ sendTurn(text), abort(), end(), readonly sessionId }}
  */
-export function startCodexSession({ cwd, model, resume, env, sandbox, mode = 'default', onEvent, providerConfig, rolePrompt, roomContext, mcpServers, prepareCwd = null }) {
+export function startCodexSession({ cwd, model, effort: initialEffort = 'high', resume, env, sandbox, mode = 'default', onEvent, providerConfig, rolePrompt, roomContext, mcpServers, prepareCwd = null }) {
   let activeMode = CODEX_MODE_CONFIG[mode] ? mode : 'default'
   let modeConfig = codexConfigForMode(activeMode)
   sandbox = normalizeCodexSandbox(sandbox || modeConfig.sandbox)
@@ -142,6 +144,7 @@ export function startCodexSession({ cwd, model, resume, env, sandbox, mode = 'de
   let ended = false
   let turnActive = false
   let activeModel = model || null
+  let activeEffort = EFFORT_LEVELS.has(initialEffort) ? initialEffort : 'high'
   let mcpHttpPromise = null
   // serialize turns: one exec at a time
   let chain = Promise.resolve()
@@ -168,6 +171,7 @@ export function startCodexSession({ cwd, model, resume, env, sandbox, mode = 'de
     const args = buildCodexExecArgs({
       sessionId: turnNo === 0 ? null : sessionId,
       model: activeModel,
+      effort: activeEffort,
       sandbox,
       approvalPolicy: modeConfig.approvalPolicy,
       providerConfig,
@@ -286,6 +290,12 @@ export function startCodexSession({ cwd, model, resume, env, sandbox, mode = 'de
       turnNo = 0
       return true
     },
+    setEffort(nextEffort) {
+      if (turnActive || !EFFORT_LEVELS.has(nextEffort)) return false
+      activeEffort = nextEffort
+      try { onEvent?.({ kind: 'effort', level: activeEffort }) } catch { /* noop */ }
+      return true
+    },
     clearContext() {
       if (turnActive) return false
       sessionId = null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.197",
+  "version": "0.7.199",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {