thinkpool-pair 0.7.311 → 0.7.312

package/bridge.mjs

@@ -55,6 +55,8 @@ import { readCodexDefaultModel, readCodexModels, codexConfigForMode, codexThread
 import { codexAccountUsageLine, codexCreditsReportLine, codexLimitReportLine } from './codex-commands.mjs'
 import { withMcpSessionFactory } from './codex-mcp-http.mjs'
 import { startStructuredSession } from './runtime-session.mjs'
+import { claudeOneShot } from './claude-session.mjs'
+import { fallbackTerminalName, suggestTerminalName } from './terminal-name.mjs'
 import { defaultStructuredMode, normalizeStructuredEffort, shouldDeferStructuredRuntime, structuredModeForSlice, structuredModeLocked, structuredModesForLane, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { commandCatalogForRuntime, commandHelpLine, reconcileCommandCatalog } from './command-catalog.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
@@ -1160,6 +1162,9 @@ const replayPump = createLatestReplayPump({
 // Persisted on the host so a rename is cross-device + survives a bridge restart;
 // every announce carries them so a late-joining or second device sees them too.
 const termNames = loadNames(room)
+const manualNameTouched = new Set()
+const autoNameAttempts = new Set()
+const autoNames = new Map()
 // The SDK's supported-model LIST (value/displayName/description), captured from
 // any session's `models` event. Announced room-level so EVERY device gets it on
 // connect — not just the one that saw the one-shot event (the picker fell back to
@@ -1254,6 +1259,91 @@ const announce = () => {
     ],
   }) }
 
+const uniqueTerminalName = (id, candidate) => {
+  const used = new Set(Object.entries(termNames)
+    .filter(([otherId]) => otherId !== id)
+    .map(([, label]) => String(label).toLowerCase()))
+  if (!used.has(candidate.toLowerCase())) return candidate
+  for (let n = 2; n < 100; n++) {
+    const suffix = ` ${n}`
+    const next = `${candidate.slice(0, 48 - suffix.length).trim()}${suffix}`
+    if (!used.has(next.toLowerCase())) return next
+  }
+  return candidate
+}
+
+// Best-effort row convergence: the bridge map updates the room immediately and
+// survives this host's restarts; the row carries the generated name to another host.
+const persistAutoTerminalName = async (id, label, previous, retry = true) => {
+  if (!codeAuthToken || !id || !label) return
+  try {
+    // Compare-and-set: an in-flight generated write must never overwrite a
+    // manual rename that won just before this request reached Postgres.
+    const expected = previous
+      ? `&name=eq.${encodeURIComponent(previous)}`
+      : `&or=${encodeURIComponent('(name.is.null,name.eq.Terminal)')}`
+    const response = await fetch(`${SUPABASE_URL}/rest/v1/code_terminals?id=eq.${encodeURIComponent(id)}${expected}&select=id`, {
+      method: 'PATCH',
+      headers: {
+        apikey: SUPABASE_ANON,
+        Authorization: `Bearer ${codeAuthToken}`,
+        'Content-Type': 'application/json',
+        Prefer: 'return=representation',
+      },
+      body: JSON.stringify({ name: label }),
+    })
+    const rows = response.ok ? await response.json().catch(() => []) : []
+    // Bridge-created lanes can receive work before the browser inserts their row.
+    if (retry && (!response.ok || !Array.isArray(rows) || rows.length === 0)) {
+      const timer = setTimeout(() => { void persistAutoTerminalName(id, label, previous, false) }, 1500)
+      timer.unref?.()
+    }
+  } catch {
+    if (retry) {
+      const timer = setTimeout(() => { void persistAutoTerminalName(id, label, previous, false) }, 1500)
+      timer.unref?.()
+    }
+  }
+}
+
+const applyAutoTerminalName = (id, candidate) => {
+  if (!candidate || manualNameTouched.has(id)) return false
+  const currentAuto = autoNames.get(id)
+  if (termNames[id] && termNames[id] !== currentAuto) return false
+  const previous = termNames[id] || null
+  const label = uniqueTerminalName(id, candidate)
+  if (termNames[id] === label) return true
+  termNames[id] = label
+  autoNames.set(id, label)
+  saveNames(room, termNames)
+  void persistAutoTerminalName(id, label, previous)
+  announce()
+  return true
+}
+
+// First real task only. A zero-token title appears immediately. Built-in Claude
+// may refine it through the existing raw Haiku path; other runtimes stay local so
+// a Codex/Hermes/custom-provider prompt is never leaked across providers.
+const autoNameTerminal = (id, text) => {
+  const entry = sessions.get(id)
+  if (!entry || termNames[id] || manualNameTouched.has(id) || autoNameAttempts.has(id)) return
+  if (entry.log?.some((event) => event?.kind === 'you')) return
+  const fallback = fallbackTerminalName(text)
+  if (!fallback) return
+  autoNameAttempts.add(id)
+  applyAutoTerminalName(id, fallback)
+  const canUseHaiku = entry.runtime === 'claude'
+    && (!entry.provider || entry.provider === 'anthropic')
+    && hostMemoryAdmission('name this terminal').ok
+  if (!canUseHaiku) return
+  const context = `Repository: ${repoLabel}. Existing terminal names: ${Object.values(termNames).filter(Boolean).slice(-8).join(', ') || 'none'}.`
+  void suggestTerminalName({
+    text,
+    context,
+    generate: (prompt) => claudeOneShot({ prompt, cwd: entry.cwd || process.cwd(), env: process.env, timeoutMs: 8000 }),
+  }).then((candidate) => applyAutoTerminalName(id, candidate))
+}
+
 // (cross-person grantee yield removed 2026-07-06 — owner-only serving now; the owner's
 //  bridge never stands down. See docs/specs/2026-07-06-remove-cross-person-serve.md.)
 
@@ -1345,6 +1435,7 @@ async function receiveCrossRoomPost({ fromRoom, fromHost, fromTerminalName, text
   te.roomHop = 1; te.hop = (te.hop || 0) + 1; te.peekCount = 0; te.postCount = 0; te.pairPeekCount = 0; te.crossRoomPostCount = 0
   const msg = `[From: room ${fromLabel} — relayed via the ThinkPool cross-room Ensemble, approved by a person in this room]\n${body}`
   const evt = { kind: 'you', text: msg, by: `room ${fromRoom}`, crosspost: true, relaySourceName: String(fromTerminalName || '').trim().slice(0, 80) || undefined }
+  autoNameTerminal(targetId, body)
   stampEvent(evt); pushLog(te, evt); bcast('code-event', { term: targetId, evt })
   try { if (te.session.sendTurn(msg) === false) return { error: `Could not deliver to room ${room} — the lane refused the turn (check its visible host-memory/runtime error).` } } catch { return { error: `Could not deliver to room ${room} — the lane may have just closed.` } }
   return { ok: true, ref: String(targetId).slice(0, 8) }
@@ -2577,6 +2668,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
           // Echo the injected prompt into the TARGET lane so both people see what
           // arrived (rides the existing code-event 'you' path — no new topic).
           const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
+          autoNameTerminal(target.id, args.text)
           stampEvent(evt)
           pushLog(te, evt)
           bcast('code-event', { term: target.id, evt })
@@ -2630,6 +2722,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
           announce()
           const msg = `[Task from main terminal ${fromRef}'s agent — opened as an independent MAIN CASCADE CONDUCTOR terminal, not an Ensemble child]\n${String(args.task).trim()}`
           const evt = { kind: 'you', text: msg, by: `main terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
+          autoNameTerminal(newId, args.task)
           stampEvent(evt); pushLog(conductor, evt); bcast('code-event', { term: newId, evt })
           try { if (conductor.session.sendTurn(msg) === false) return okText(`Opened main conductor ${newRef}, but host pressure prevented its runtime from starting. Existing lanes remain connected; free memory and retry the task.`) }
           catch { return okText(`Opened main conductor ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — the initial task could not be delivered.`) }
@@ -2749,6 +2842,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
               : ''
             const msg = `[Task from terminal ${fromRef}'s agent — relayed via ThinkPool Ensemble; you are its WORKER SUB-TERMINAL, never a main terminal or Cascade conductor]\n${args.task}${reviewTarget}`
             const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
+            autoNameTerminal(newId, args.task)
             stampEvent(evt); pushLog(ne, evt); bcast('code-event', { term: newId, evt })
             try { if (ne.session.sendTurn(msg) === false) return okText(`Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but host pressure prevented its runtime from accepting the task. Existing lanes remain connected; free memory and retry.`) } catch { return okText(`Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — could not hand off the task. Try post_to_terminal shortly.`) }
             return okText(`Opened agent lane ${newRef}${args?.name ? ` ("${args.name}")` : ''} and handed it the task. It runs in its own lane — check back with read_terminal, then close_terminal when done.`)
@@ -4241,6 +4335,7 @@ channel
     // Sample the runtime before dispatch so a missed prior falling edge cannot
     // make this genuinely new turn inherit the previous turn's revision.
     syncStructuredTurn(s)
+    autoNameTerminal(payload.term, payload.body != null ? String(payload.body) : text)
     const accepted = s.session.sendTurn(sendText, Object.keys(turnOptions).length ? turnOptions : undefined)
     if (accepted === false) syncStructuredTurn(s)
     else beginStructuredTurn(s)
@@ -4410,6 +4505,8 @@ channel
   // LATER (or a second machine) — those only ever see the announce.
   .on('broadcast', { event: 'term-rename' }, ({ payload }) => {
     if (!payload?.id) return
+    manualNameTouched.add(payload.id)
+    autoNames.delete(payload.id)
     if (payload.name) termNames[payload.id] = String(payload.name).slice(0, 80)
     else delete termNames[payload.id]
     saveNames(room, termNames)

package/claude-session.mjs

@@ -27,10 +27,42 @@ import { stallDecision, stallEvent, isCompactTurn } from './turn-stall.mjs'
 
 // The caret-pulled SDK's real version (^0.3.x auto-upgrades on restart). Resolved
 // once at import by walking up from the package entry to its own package.json.
+const req = createRequire(import.meta.url)
+
+// Shared raw one-shot for tiny bridge-owned inference jobs. No settings, skills,
+// MCP servers, or repo instructions are loaded; callers provide the model + prompt.
+export async function claudeOneShot({ prompt, model = 'claude-haiku-4-5', cwd, env, timeoutMs = 8000 } = {}) {
+  const abortController = new AbortController()
+  const timer = setTimeout(() => { try { abortController.abort() } catch { /* noop */ } }, timeoutMs)
+  try {
+    const result = query({
+      prompt,
+      options: {
+        model,
+        ...(cwd ? { cwd } : {}),
+        env,
+        maxTurns: 1,
+        permissionMode: 'bypassPermissions',
+        settingSources: [],
+        strictMcpConfig: true,
+        mcpServers: {},
+        abortController,
+      },
+    })
+    let out = ''
+    for await (const message of result) {
+      if (message.type === 'assistant') {
+        for (const block of (message.message?.content || [])) if (block.type === 'text') out += block.text
+      }
+      if (message.type === 'result') break
+    }
+    return out.trim()
+  } finally { clearTimeout(timer) }
+}
+
 // Named in the [SDK-REGRESSION] guard below so a silent gate-change is attributable.
 const SDK_VERSION = (() => {
   try {
-    const req = createRequire(import.meta.url)
     let d = dirname(req.resolve('@anthropic-ai/claude-agent-sdk'))
     for (let i = 0; i < 8; i++) {
       try { const p = JSON.parse(readFileSync(join(d, 'package.json'), 'utf8')); if (p.name === '@anthropic-ai/claude-agent-sdk') return p.version } catch { /* keep walking */ }
@@ -788,35 +820,17 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
     if (!suggest) return
     const seed = (lastAssistantText || '').trim().slice(-1500)
     if (!seed || closed) return
-    const ac2 = new AbortController()
-    const t = setTimeout(() => { try { ac2.abort() } catch { /* noop */ } }, 8000)
     try {
-      const hq = query({
+      let out = await claudeOneShot({
         prompt: `You are predicting the user's NEXT chat message in a live coding session, to prefill their composer. Given the assistant's latest reply below, output the single most likely next user message — short and natural (often just "proceed", "go with option A", "yes do that", or a brief follow-up). One line, <=12 words, imperative, no preamble, no quotes, no markdown.\n\nAssistant's latest reply:\n"""\n${seed}\n"""\n\nNext user message:`,
-        options: {
-          model: 'claude-haiku-4-5',
-          ...(cwd ? { cwd } : {}),
-          env: opts.env,
-          maxTurns: 1,
-          permissionMode: 'bypassPermissions',
-          settingSources: [],          // no CLAUDE.md / commands / agents — raw call
-          strictMcpConfig: true,
-          mcpServers: {},              // no MCP servers — fast cold start
-          abortController: ac2,
-        },
+        model: 'claude-haiku-4-5', cwd, env: opts.env, timeoutMs: 8000,
       })
-      let out = ''
-      for await (const mm of hq) {
-        if (mm.type === 'assistant') for (const b of (mm.message?.content || [])) if (b.type === 'text') out += b.text
-        if (mm.type === 'result') break
-      }
       out = out.trim().split('\n')[0].replace(/^["'`]+|["'`]+$/g, '').trim().slice(0, 140)
       if (out && !sawSuggestion && !closed && !/^(sure|of course|certainly|let me know|i can help|happy to)\b/i.test(out)) {
         emit({ kind: 'suggestion', text: out, source: 'haiku' })
         process.stderr.write(`  ◆ [suggestion] haiku fallback: ${JSON.stringify(out)}\n`)
       }
     } catch { /* fallback failed (rate limit / abort / model error) — silent */ }
-    finally { clearTimeout(t) }
   }
 
   const admitColdStart = () => {

package/cross-terminal.mjs

@@ -266,7 +266,7 @@ export const nativeClaudeProviderAccessFailed = (events) => {
   let text = ''
   try { text = typeof events === 'string' ? events : JSON.stringify(events || '') }
   catch { text = String(events || '') }
-  return /organization has disabled (?:claude )?subscription access|(?:claude )?subscription access (?:has been |is )?disabled|invalid anthropic (?:api )?key|invalid x-api-key|not logged in to claude|(?:run|use) \/login[^\n]{0,80}claude|no valid anthropic (?:api )?key/i.test(text)
+  return /organization has disabled (?:claude(?: subscription access)?|subscription access)|(?:claude )?subscription access (?:has been |is )?disabled|invalid anthropic (?:api )?key|invalid x-api-key|not logged in to claude|(?:run|use) \/login[^\n]{0,80}claude|no valid anthropic (?:api )?key/i.test(text)
 }
 
 const HERMES_CLAUDE_REVIEW_PREFERENCE = Object.freeze([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.311",
+  "version": "0.7.312",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "byok-detect.mjs",
     "context-windows.mjs",
     "claude-session.mjs",
+    "terminal-name.mjs",
     "claude-command-catalog.mjs",
     "codex-session.mjs",
     "question-response.mjs",

package/terminal-name.mjs

@@ -0,0 +1,54 @@
+import { nativeClaudeProviderAccessFailed } from './cross-terminal.mjs'
+
+const SKIP = new Set([
+  'a', 'an', 'and', 'are', 'at', 'be', 'can', 'could', 'for', 'from', 'how', 'i',
+  'in', 'is', 'it', 'just', 'like', 'maybe', 'me', 'my', 'of', 'on', 'or', 'our',
+  'please', 'something', 'that', 'the', 'this', 'to', 'we', 'with', 'would', 'you',
+])
+
+const GENERIC = /^(?:new )?(?:agent |coding )?(?:terminal|task|lane|session|work)$/i
+
+export function cleanTerminalName(value) {
+  let name = String(value || '')
+    .trim()
+    .split(/\r?\n/, 1)[0]
+    .replace(/^\s*(?:[-*#>]+|title\s*:?)\s*/i, '')
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .replace(/[^\p{L}\p{N}+#&.' -]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+  if (!name || GENERIC.test(name) || nativeClaudeProviderAccessFailed(name)) return null
+  if (/^(?:error|failed|sorry|unable|i (?:cannot|can't)|rate limit|request failed)\b/i.test(name)) return null
+  if (name.length > 48) name = name.slice(0, 48).replace(/\s+\S*$/, '').trim()
+  return name || null
+}
+
+export function fallbackTerminalName(text) {
+  const body = String(text || '')
+    .replace(/^\s*\[[^\]\n]{1,240}\]\s*/g, '')
+    .replace(/^\s*(?:hey|hi|okay|ok|so)\b[,:!]?\s*/i, '')
+    .replace(/^\s*(?:can|could|would|will)\s+you\s+/i, '')
+    .replace(/^\s*(?:how about|i (?:do not|don't) know|i guess)\s+/i, '')
+    .replace(/[`*_>#()[\]{}]/g, ' ')
+    .slice(0, 600)
+  const words = body.match(/[\p{L}\p{N}][\p{L}\p{N}+#.'-]*/gu) || []
+  const useful = words.filter((word) => !SKIP.has(word.toLowerCase()) && !/^https?$/i.test(word))
+  if (!useful.length) return null
+  const title = useful.slice(0, 5).map((word) => {
+    if (/^[A-Z\d+#.-]{2,}$/.test(word) || /\d/.test(word)) return word
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  }).join(' ')
+  return cleanTerminalName(title)
+}
+
+export async function suggestTerminalName({ text, context = '', generate } = {}) {
+  const fallback = fallbackTerminalName(text)
+  if (!fallback || typeof generate !== 'function') return fallback
+  const prompt = [
+    'Name one terminal lane from its first task. Output only a distinctive 2-5 word title, title case, at most 40 characters. Describe the concrete work, not the person or model. Never output “Terminal”, “Task”, “Session”, or a numbered label.',
+    context ? `Room context: ${String(context).slice(0, 500)}` : '',
+    `First task:\n${String(text || '').slice(0, 1600)}`,
+  ].filter(Boolean).join('\n\n')
+  try { return cleanTerminalName(await generate(prompt)) || fallback }
+  catch { return fallback }
+}