thinkpool-pair 0.7.310 → 0.7.312

package/account.mjs

@@ -13,7 +13,7 @@ import path from 'node:path'
 import fs from 'node:fs'
 import { createClient } from '@supabase/supabase-js'
 import os from 'node:os'
-import { saveAuth, loadAuth, loadDirs, bindDir, loadServed, rememberServed, loadDefaultDir, saveDefaultDir, claudeRecentProjectDir } from './auth-store.mjs'
+import { saveAuth, loadAuth, markAuthReconnectRequired, loadDirs, bindDir, loadServed, rememberServed, loadDefaultDir, saveDefaultDir, claudeRecentProjectDir } from './auth-store.mjs'
 import { isSafeToRestart } from './update-gate.mjs'
 import { makeThrottledTrack, presenceSelfEchoObservation } from './presence.mjs'
 import { publicKeyB64, announceProviders, listProviders, addProvider, addProviderModel, removeProvider, unseal } from './providers.mjs'
@@ -252,16 +252,33 @@ export async function refreshAccountSession(sb, holdRefreshToken, deps = {}) {
     if (adopted) return adopted
     const rt = load()?.refresh_token || rt0
     const { data, error } = await sb.auth.refreshSession({ refresh_token: rt })
-    if (error || !data?.session) return null
+    // Preserve the server's structured Auth error. The caller must distinguish a
+    // retryable network/service failure from a refresh token that is definitively
+    // gone; collapsing both to null is what let a disconnected account keep painting
+    // as a healthy bridge until its presence JWT finally expired.
+    if (error || !data?.session) return { session: null, error: error || null }
     save(data.session)   // atomic (auth-store) — never a torn token file
     return { session: data.session, adopted: false }
   } finally { if (locked) release() }
 }
 
+// Supabase documents these as terminal session/refresh-token states. They require a
+// fresh device-code login; request timeouts, rate limits and 5xx errors remain retryable.
+export const ACCOUNT_RECONNECT_ERROR_CODES = new Set([
+  'refresh_token_not_found',
+  'refresh_token_already_used',
+  'session_not_found',
+])
+
+export function accountRefreshNeedsReconnect(error) {
+  return ACCOUNT_RECONNECT_ERROR_CODES.has(String(error?.code || ''))
+}
+
 // Exchange the stored credentials for a live session + authed client.
 export async function authedClient(SUPABASE_URL, SUPABASE_ANON) {
   const a = loadAuth()
   if (!a?.refresh_token) return null
+  if (a.reconnect_required) return { reconnectRequired: true }
   const sb = createClient(SUPABASE_URL, SUPABASE_ANON, { auth: { persistSession: false, autoRefreshToken: false } })
   // F1: skip the refresh entirely when the saved access token is still comfortably valid
   // (>5 min to expiry). Every gratuitous startup rotation is a race window — and, killed
@@ -273,7 +290,13 @@ export async function authedClient(SUPABASE_URL, SUPABASE_ANON) {
   }
   // Near-expiry / missing / invalid access token → do a serialized rotation (F3).
   const r = await refreshAccountSession(sb, a.refresh_token)
-  if (!r?.session) return null
+  if (!r?.session) {
+    if (accountRefreshNeedsReconnect(r?.error)) {
+      markAuthReconnectRequired(r.error.code)
+      return { reconnectRequired: true }
+    }
+    return null
+  }
   return { sb, session: r.session }
 }
 
@@ -289,6 +312,7 @@ export async function authedClientWithRetry(SUPABASE_URL, SUPABASE_ANON, opts =
   let delay = baseMs
   for (let n = 1; n <= maxAttempts; n++) {
     const a = await attempt(SUPABASE_URL, SUPABASE_ANON)
+    if (a?.reconnectRequired) return a
     if (a) return a
     if (!load()?.refresh_token) return null   // not linked — caller says `login`, exits 0
     if (n >= maxAttempts) break
@@ -320,10 +344,11 @@ export function claimLoopWedged({ lastClaimOkAt, now, quietMsThreshold = 40_000
 //   skewMs  — refresh this far ahead of expiry (default 90s)
 //   forceMs — fixed interval override (test hook: TP_TOKEN_REFRESH_FORCE_MS)
 //   retryMs — backoff after a transient failure (offline / rotation race)
-export function scheduleTokenRefresh({ sb, session, onRefreshed, skewMs = 90_000, forceMs = 0, retryMs = 30_000, refresh = refreshAccountSession }) {
+export function scheduleTokenRefresh({ sb, session, onRefreshed, onReconnectRequired, skewMs = 90_000, forceMs = 0, retryMs = 30_000, refresh = refreshAccountSession }) {
   let timer = null
   let cur = session
   let cancelled = false
+  let reconnectRequired = false
   const arm = (delay) => {
     if (cancelled) return
     clearTimeout(timer)
@@ -343,12 +368,21 @@ export function scheduleTokenRefresh({ sb, session, onRefreshed, skewMs = 90_000
       // instead of blindly refreshing with our in-memory `cur.refresh_token` — the old
       // tick retried with a stale token it held and could lose the family to a race.
       const r = await refresh(sb, cur.refresh_token)
-      if (!r?.session) throw new Error('no session')
+      if (!r?.session) {
+        if (accountRefreshNeedsReconnect(r?.error)) {
+          if (!reconnectRequired) {
+            reconnectRequired = true
+            try { await onReconnectRequired?.(r.error) } catch { /* reporting is best-effort; retry still owns recovery */ }
+          }
+        }
+        throw r?.error || new Error('no session')
+      }
       cur = r.session
       // Hand the fresh token to the live realtime socket so the presence
       // connection stays authed across the swap (no drop, no rejoin needed).
       try { sb.realtime?.setAuth?.(cur.access_token) } catch { /* noop */ }
-      try { onRefreshed?.(cur) } catch { /* noop */ }
+      reconnectRequired = false
+      try { await onRefreshed?.(cur) } catch { /* noop */ }
       arm(nextDelay())
     } catch {
       // Transient (offline, or a refresh-token rotation race with another login).
@@ -394,6 +428,12 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
     console.error('\n  ◇ Not linked to a ThinkPool account on this machine.\n    Link it:  npx thinkpool-pair login\n')
     process.exit(0)
   }
+  if (auth.reconnectRequired) {
+    releaseStartupAnchor()
+    releaseSingleton()
+    console.error('\n  ◇ This bridge lost its Thinkpool account link.\n    Reconnect it:  npx thinkpool-pair@latest login\n')
+    process.exit(0)
+  }
   const { sb, session } = auth
   const email = session.user?.email || 'your account'
   // Current owner JWT, handed to each room-bridge child for authed web writes
@@ -548,6 +588,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // lastTrackStatus retains the most recent track()'s server verdict ('ok'|'timed out'|
   // 'error') so the presence self-echo watchdog can log WHY presence went dark.
   let lastTrackStatus = 'init'
+  let accountAuthState = 'connected'
   const trackPresence = makeThrottledTrack(acct, { minMs: 5000, onStatus: (s) => { lastTrackStatus = s } })
   // `service` lets the dashboard show whether this bridge is the durable installed
   // service (always-on, survives reboot) vs a foreground `npx` run that dies with its
@@ -560,7 +601,17 @@ 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, bridgeId: BRIDGE_ID, version: VERSION, rooms: [...children.keys()], readyRooms: [...readyRooms], refused: [...refused].map(([code, reason]) => ({ code, reason })), service: runsAsService(), providerPubKey: PROVIDER_PUBKEY, providers: announceProviders(), agents: installedAgentCommands().map((cmd) => ({ cmd })), ts: Date.now() })
+  const pushPresence = () => trackPresence({ name: machine, bridgeId: BRIDGE_ID, version: VERSION, rooms: [...children.keys()], readyRooms: [...readyRooms], refused: [...refused].map(([code, reason]) => ({ code, reason })), service: runsAsService(), providerPubKey: PROVIDER_PUBKEY, providers: announceProviders(), agents: installedAgentCommands().map((cmd) => ({ cmd })), accountAuthState, ts: Date.now() })
+
+  // Persist account-auth truth separately from process presence. Presence will vanish
+  // when the old JWT expires; the claim row keeps the reconnect instruction visible on
+  // the dashboard until this same bridge refreshes successfully or another bridge takes
+  // over with a healthy login. Older databases simply reject this best-effort RPC.
+  const reportAccountAuthState = async (state) => {
+    try {
+      await withTimeout(sb.rpc('report_bridge_auth_state', { p_bridge_id: BRIDGE_ID, p_state: state }), 5000, 'report_bridge_auth_state')
+    } catch { /* migration not present yet, offline, or the old JWT already expired */ }
+  }
 
   // ── Provider registry — the multi-BYOK wire contract (slice 1). ─────────────
   // AUTH: the account channel `tpacct:<uid>` is created WITHOUT config.private:true,
@@ -647,13 +698,22 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   const keepFresh = scheduleTokenRefresh({
     sb,
     session,
-    onRefreshed: (s) => {
+    onRefreshed: async (s) => {
+      accountAuthState = 'connected'
       saveAuth(s); pushPresence()
+      await reportAccountAuthState('connected')
       // Push the rotated owner token to every live child so their authed writes
       // (code-mockup) never go stale on a long session (whip L16).
       currentAccessToken = s.access_token || currentAccessToken
       for (const c of children.values()) { try { c.send({ t: 'token', accessToken: currentAccessToken }) } catch { /* child not ready */ } }
     },
+    onReconnectRequired: async (error) => {
+      accountAuthState = 'reconnect-required'
+      markAuthReconnectRequired(error?.code || 'refresh-token-invalid')
+      pushPresence()
+      await reportAccountAuthState('reconnect-required')
+      process.stderr.write('\n  ◇ This bridge lost its Thinkpool account link.\n    Reconnect it:  npx thinkpool-pair@latest login\n')
+    },
     forceMs: parseInt(process.env.TP_TOKEN_REFRESH_FORCE_MS, 10) || 0,
   })
 

package/auth-store.mjs

@@ -19,19 +19,8 @@ const SERVED = path.join(DIR, 'served.json')
 
 function ensureDir() { try { fs.mkdirSync(DIR, { recursive: true }) } catch { /* noop */ } }
 
-export function saveAuth(session) {
-  if (!session?.refresh_token) return
+function writeAuthPayload(payload) {
   ensureDir()
-  const payload = JSON.stringify({
-    refresh_token: session.refresh_token,
-    access_token: session.access_token || null,
-    // Unix SECONDS. Lets the bridge adopt the saved access token WITHOUT a refresh while
-    // it's still comfortably valid (account.mjs F1) — every skipped rotation is one fewer
-    // race window (and one fewer chance to be killed mid-rotation and brick the login).
-    expires_at: session.expires_at || null,
-    email: session.user?.email || session.email || null,
-    savedAt: Date.now(),
-  })
   // ATOMIC write (2026-07-08): a crash/kill/kickstart mid-write must never leave a
   // truncated auth.json — an unparseable token file reads as "not linked" and bricks the
   // saved login (three bridge outages in two days, one from a restart landing mid-rotation).
@@ -43,13 +32,38 @@ export function saveAuth(session) {
   const tmp = `${AUTH}.tmp.${process.pid}.${Date.now()}`
   try {
     const fd = fs.openSync(tmp, 'w', 0o600)
-    try { fs.writeSync(fd, payload); fs.fsyncSync(fd) } finally { fs.closeSync(fd) }
+    try { fs.writeSync(fd, JSON.stringify(payload)); fs.fsyncSync(fd) } finally { fs.closeSync(fd) }
     fs.renameSync(tmp, AUTH)
   } catch {
     try { fs.rmSync(tmp, { force: true }) } catch { /* noop */ }
   }
 }
+
+export function saveAuth(session) {
+  if (!session?.refresh_token) return
+  writeAuthPayload({
+    refresh_token: session.refresh_token,
+    access_token: session.access_token || null,
+    // Unix SECONDS. Lets the bridge adopt the saved access token WITHOUT a refresh while
+    // it's still comfortably valid (account.mjs F1) — every skipped rotation is one fewer
+    // race window (and one fewer chance to be killed mid-rotation and brick the login).
+    expires_at: session.expires_at || null,
+    email: session.user?.email || session.email || null,
+    savedAt: Date.now(),
+  })
+}
 export function loadAuth() { try { return JSON.parse(fs.readFileSync(AUTH, 'utf8')) } catch { return null } }
+export function markAuthReconnectRequired(errorCode = null) {
+  const current = loadAuth()
+  if (!current?.refresh_token) return false
+  writeAuthPayload({
+    ...current,
+    reconnect_required: true,
+    reconnect_error_code: errorCode || null,
+    reconnect_required_at: Date.now(),
+  })
+  return true
+}
 export function clearAuth() { try { fs.unlinkSync(AUTH) } catch { /* noop */ } }
 
 export function loadDirs() { try { return JSON.parse(fs.readFileSync(DIRS, 'utf8')) } catch { return {} } }

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/launcher.mjs

@@ -75,8 +75,10 @@ export function detectState() {
   const hermesInstalled = onPath('hermes')
   const hermesReady = onPath('thinkpool') && probeHermesRuntime().available
   const accountSvc = serviceLoaded(null)
+  const reconnectRequired = !!auth?.reconnect_required
   return {
-    loggedIn: !!auth?.refresh_token,
+    loggedIn: !!auth?.refresh_token && !reconnectRequired,
+    reconnectRequired,
     email: auth?.email || auth?.user?.email || null,
     provider: isCustom ? `Custom (${provider.baseUrl || 'endpoint'})` : 'Anthropic (default)',
     providerModel: isCustom ? (provider.model || null) : null,
@@ -106,6 +108,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     ...next,
     agents: Array.isArray(next?.agents) ? next.agents : [],
     loggedIn: !!next?.loggedIn,
+    reconnectRequired: !!next?.reconnectRequired,
     accountSvc: !!next?.accountSvc,
     serviceVersion: typeof next?.serviceVersion === 'string' && next.serviceVersion ? next.serviceVersion : null,
     platform: next?.platform || process.platform,
@@ -130,7 +133,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     io.print('')
     io.print('  ' + C.dim('┌ ') + C.bold('thinkpool-pair') + C.dim(' ' + '─'.repeat(40)))
     io.print(`  ${C.dim('│ launcher ')} ${state.version ? `v${state.version}` : 'version unavailable'}`)
-    io.print(`  ${C.dim('│ account  ')} ${state.loggedIn ? C.green((state.email || 'linked') + ' ✓') : C.yellow('not linked')}`)
+    io.print(`  ${C.dim('│ account  ')} ${state.reconnectRequired ? C.yellow('reconnect required') : state.loggedIn ? C.green((state.email || 'linked') + ' ✓') : C.yellow('not linked')}`)
     io.print(`  ${C.dim('│ agents   ')} ${state.agents.length ? state.agents.map(a => a.label).join(', ') : C.yellow('none ready')}`)
     io.print(`  ${C.dim('│ directory')} ${C.dim(state.cwd)}`)
     const bridgeStatus = !state.accountSvc
@@ -165,7 +168,9 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
   // logged in — offers to link on the spot, re-reads disk, and refuses to serve if still not.
   const ensureLoggedIn = async () => {
     if (state.loggedIn) return true
-    io.print('\n  ' + C.yellow('You are not linked to a ThinkPool account yet.'))
+    io.print('\n  ' + C.yellow(state.reconnectRequired
+      ? 'This bridge lost its Thinkpool account link.'
+      : 'You are not linked to a ThinkPool account yet.'))
     if (await askYesNo('  Link this device now?', true)) { await actions.login(); resync() }
     if (!state.loggedIn) { io.print('  ' + C.yellow('login needed to serve your sessions — back to menu')); return false }
     return true
@@ -230,7 +235,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     for (;;) {
       const options = [
         { key: 'provider', label: 'Provider', hint: `current: ${state.provider}` },
-        { key: 'account', label: 'Account', hint: state.loggedIn ? `linked: ${state.email || 'yes'}` : 'not linked' },
+        { key: 'account', label: 'Account', hint: state.reconnectRequired ? 'reconnect required' : state.loggedIn ? `linked: ${state.email || 'yes'}` : 'not linked' },
       ]
       if (state.hermesInstalled) options.push({ key: 'hermes', label: state.hermesReady ? 'Hermes profile' : 'Set up Hermes', hint: state.hermesReady ? 'isolated profile ready' : 'set up isolated profile + delegation guard' })
       options.push({ key: 'back', label: 'Back to main menu', hint: '' })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.310",
+  "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 }
+}