thinkpool-pair 0.7.114 → 0.7.115

package/bridge.mjs

@@ -450,11 +450,18 @@ const repoLabel = path.basename(cwd)
 // thinkpool-pair's own version — surfaced in the room's welcome banner.
 let VERSION = null
 try { VERSION = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { /* unknown — banner omits it */ }
-let branch = null
-try {
-  const head = fs.readFileSync(path.join(cwd, '.git', 'HEAD'), 'utf8').trim()
-  branch = head.startsWith('ref:') ? head.split('/').pop() : head.slice(0, 7)
-} catch { /* not a git repo — fine */ }
+// Read the CURRENT branch LIVE (not once at boot) so the room's mode row reflects a
+// branch switch instead of showing whatever branch the dir was on when the bridge spawned
+// (the stale-branch bug). Handles a .git dir (normal checkout) AND a .git FILE (linked
+// worktree → "gitdir: <path>"). Cheap byte reads, no subprocess.
+function readBranch() {
+  try {
+    let gitPath = path.join(cwd, '.git')
+    if (fs.statSync(gitPath).isFile()) gitPath = fs.readFileSync(gitPath, 'utf8').replace(/^gitdir:\s*/i, '').trim()
+    const head = fs.readFileSync(path.join(gitPath, 'HEAD'), 'utf8').trim()
+    return head.startsWith('ref:') ? head.split('/').pop() : head.slice(0, 7)
+  } catch { return null /* not a git repo — fine */ }
+}
 
 // ── room file drops ────────────────────────────────────────────────
 // Files dropped/pasted in the web room arrive as `file-put { id, name, url }`
@@ -660,7 +667,7 @@ const termNames = loadNames(room)
 
 const announce = () =>
   bcast('bridge', {
-    v: 2, name, repo: repoLabel, branch,
+    v: 2, name, repo: repoLabel, branch: readBranch(),
     // cwd + version: the host's working dir + thinkpool-pair version, shown in
     // the room's welcome banner. Re-sent per announce so late joiners get them.
     cwd, version: VERSION,
@@ -1759,6 +1766,23 @@ function endStructured(id) {
   if (s) announce()
 }
 
+// Close every lane of a FINISHED flow — its task lanes AND its conductor — after a grace
+// so the final output / assembled result stays readable. A flow lane is keyed by
+// flowSessionId (task lanes) or spawnedBy `flow:<id>` (the conductor). Without this a flow
+// that assembles or is cancelled leaves its lanes running forever with no owner to close
+// them (only the spawner can close_terminal) — the dormant-lane bug Max hit.
+function cleanupFlowLanes(flowId, graceMs = 4000) {
+  if (!flowId) return
+  const marker = `flow:${flowId}`
+  setTimeout(() => {
+    for (const [sid, e] of [...sessions]) {
+      if (e.flowSessionId === flowId || e.spawnedBy === marker) {
+        try { endStructured(sid) } catch { /* already gone */ }
+      }
+    }
+  }, graceMs)
+}
+
 // Slice 3 — surface a pending update to the room as the "update ready" chip:
 // broadcast a chrome code-event per structured term + stash it on the announce so
 // reloads/late-joiners see it too. The restart itself is gated to between turns.
@@ -2311,6 +2335,7 @@ flowChannel
       bcast('flow-assembled', { term: 'flow', flowId: payload.flowId, previewUrl, outDir, files: merged.files, conflicts: merged.conflicts }, flowChannel)
       process.stderr.write(`\n  ${A.mag}◆ flow assembled — ${merged.files.length} file(s)${merged.conflicts.length ? `, ${merged.conflicts.length} conflict(s)` : ''}${previewUrl ? ` · preview ${previewUrl}` : ''} (flow ${short}).${A.rst}\n`)
       announce()
+      cleanupFlowLanes(payload.flowId)   // flow assembled → retire its lanes + conductor (no orphans)
     } catch (e) {
       process.stderr.write(`\n  ${A.yel}◆ flow assemble failed: ${e?.message || e}${A.rst}\n`)
     }
@@ -2359,6 +2384,15 @@ flowChannel
       process.stderr.write(`\n  ${A.yel}◆ flow slice reverted — ${payload.taskKey} (${branch}).${A.rst}\n`)
     } catch (e) { process.stderr.write(`\n  ${A.yel}◆ flow revert failed: ${e?.message || e}${A.rst}\n`) }
   })
+  .on('broadcast', { event: 'flow-cancel' }, ({ payload }) => {
+    // A user cancelled the flow (or it was interrupted). The client also flips the DB
+    // status; here we CLOSE the flow's lanes + conductor so they don't orphan (only the
+    // spawner could close_terminal them otherwise — the dormant-lane bug). Host-gated.
+    if (!payload?.flowId) return
+    if (payload.host && payload.host !== name) return
+    cleanupFlowLanes(payload.flowId, 600)
+    process.stderr.write(`\n  ${A.yel}◆ flow cancelled — closing its lanes (${String(payload.flowId).replace(/-/g, '').slice(0, 8)}).${A.rst}\n`)
+  })
   .subscribe()
 
 // Watchdog — if the realtime channel is stuck (never connected, or dropped and

package/claude-session.mjs

@@ -152,6 +152,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // open a terminal with TP_MCP_STRICT=1 (below) for the B-side to isolate MCP's share.
   const spawnT0 = Date.now()
   let readyLogged = false
+  let modelsSent = false   // one-shot: emit the SDK's supported-model list on first init
   let q = null            // the live Query — control requests (interrupt /
                           // setPermissionMode) route through it once streaming.
   // The session is CREATED in the caller's chosen mode (not hard-coded default):
@@ -650,6 +651,20 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             // supports: built-ins + the host's custom .claude/commands. Surfaced
             // so the room composer's autocomplete lists what ACTUALLY exists.
             emit({ kind: 'system', sessionId, model: m.model || model || null, commands: Array.isArray(m.slash_commands) ? m.slash_commands : undefined })
+            // Dynamic model list — ask the SDK for its OWN supported models and surface
+            // them to the room so the /model picker renders live options (incl. new
+            // models like Fable) instead of a hardcoded three-item list. Fire-and-forget:
+            // older rooms just never receive it and keep their static fallback; a query
+            // that lacks supportedModels() (old SDK) silently no-ops. One-shot per session.
+            if (!modelsSent) {
+              modelsSent = true
+              Promise.resolve(q?.supportedModels?.()).then((ms) => {
+                const models = (ms || [])
+                  .map((x) => ({ value: x?.value, displayName: x?.displayName, description: x?.description }))
+                  .filter((x) => x.value)
+                if (models.length) emit({ kind: 'models', models })
+              }).catch(() => { /* no list available — room keeps its fallback */ })
+            }
             break
           case 'assistant':
             // Stamp tool-call start times so tool_result can report a duration.
@@ -775,8 +790,12 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     async listModels() {
       try {
         const ms = await q?.supportedModels?.()
-        const names = (ms || []).map((x) => x.model || x.id || x.name).filter(Boolean)
-        emit({ kind: 'note', text: names.length ? `models: ${names.join(', ')}` : 'no model list available' })
+        const models = (ms || [])
+          .map((x) => ({ value: x?.value, displayName: x?.displayName, description: x?.description }))
+          .filter((x) => x.value)
+        // Structured event drives the picker; the note is a human-readable echo for the log.
+        if (models.length) emit({ kind: 'models', models })
+        emit({ kind: 'note', text: models.length ? `models: ${models.map((x) => x.value).join(', ')}` : 'no model list available' })
       } catch { emit({ kind: 'note', text: 'usage: /model <name>' }) }
     },
     // Graceful interrupt (Esc / Stop) — stops the current turn but keeps the

package/package.json

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