thinkpool-pair 0.7.126 → 0.7.128

package/bridge.mjs

@@ -34,11 +34,12 @@ import path from 'node:path'
 import readline from 'node:readline'
 import { spawn, execSync, execFileSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
 import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
-import { startClaudeSession } from './claude-session.mjs'
+import { startClaudeSession, oneShotSummary } from './claude-session.mjs'
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
 import { normalizePlanOutput } from './flow-task-graph.mjs'   // FL-B1 — validate the conductor's submit_flow_plan task-graph
 // S1 (context-offload) — durable digest store. mark_flow_done digests a closed slice in;
@@ -303,6 +304,51 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
   process.exit(0)
 }
 
+// ── agent-SDK compatibility gate ────────────────────────────────────────────
+// The SDK tracks a caret (^0.3.x), so a restart can auto-pull a NEW SDK, and its
+// interrupt/turn API has broken between 0.3.x minors before. Smoke-test the API
+// surface (offline, no tokens) the FIRST time a given SDK version is seen, so a
+// bad one is caught + surfaced loudly (stderr + the announce banner) instead of
+// silently breaking turns. sdkStatus feeds the announce. Fully guarded — a check
+// error never blocks serving.
+const SMOKE_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), 'sdk-smoke.mjs')
+let sdkStatus = { ok: null, version: 'unknown', reason: '' }
+function currentSdkVersion() {
+  try {
+    const req = createRequire(import.meta.url)
+    let d = path.dirname(req.resolve('@anthropic-ai/claude-agent-sdk'))
+    for (let i = 0; i < 8; i++) {
+      try { const p = JSON.parse(fs.readFileSync(path.join(d, 'package.json'), 'utf8')); if (p.name === '@anthropic-ai/claude-agent-sdk') return p.version } catch { /* keep walking */ }
+      const up = path.dirname(d); if (up === d) break; d = up
+    }
+  } catch { /* unresolved */ }
+  return 'unknown'
+}
+function runSmoke() {
+  try { return execFileSync(process.execPath, [SMOKE_PATH], { encoding: 'utf8', timeout: 22000, stdio: ['ignore', 'pipe', 'ignore'] }).trim() }
+  catch (e) { return (e.stdout || '').toString().trim() || `SMOKE:FAIL:${currentSdkVersion()}:${e.code === 'ETIMEDOUT' ? 'timeout' : (e.message || 'run error').slice(0, 80)}` }
+}
+if (argv[0] === 'verify-sdk') {
+  const out = runSmoke(); console.log(out); process.exit(/^SMOKE:PASS/.test(out) ? 0 : 1)
+}
+function checkSdkCompat() {
+  const dir = path.join(os.homedir(), '.thinkpool-pair'); const okFile = path.join(dir, 'sdk-ok')
+  const version = currentSdkVersion(); sdkStatus.version = version
+  let known = ''; try { known = fs.readFileSync(okFile, 'utf8').trim() } catch { /* none */ }
+  if (known && known === version) { sdkStatus.ok = true; return }   // this exact SDK already verified
+  const m = runSmoke().match(/^SMOKE:(PASS|FAIL):([^:\n]*)(?::(.*))?$/m)
+  if (m && m[1] === 'PASS') {
+    sdkStatus = { ok: true, version: m[2] || version, reason: '' }
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(okFile, sdkStatus.version) } catch { /* noop */ }
+    process.stderr.write(`\n  ◆ agent SDK v${sdkStatus.version} passed the compatibility smoke test.\n`)
+  } else {
+    sdkStatus = { ok: false, version: (m && m[2]) || version, reason: (m && m[3]) || 'unknown' }
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, 'sdk-bad'), `${sdkStatus.version}: ${sdkStatus.reason}`) } catch { /* noop */ }
+    process.stderr.write(`\n  ⚠⚠ agent SDK v${sdkStatus.version} FAILED the compatibility smoke test — ${sdkStatus.reason}.\n  ⚠⚠ turns may misbehave. Pin a known-good SDK + restart:\n     bridge/package.json → "@anthropic-ai/claude-agent-sdk": "<good version>", then republish + Restart & update.\n`)
+  }
+}
+try { checkSdkCompat() } catch (e) { process.stderr.write(`  ⚠ SDK smoke check skipped: ${e.message}\n`) }
+
 if (!argv[0] || argv[0].startsWith('-')) { const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON) }
 
 const room = (argv[0] || '').toUpperCase().trim()
@@ -694,6 +740,9 @@ let roomModels = null
 const announce = () =>
   bcast('bridge', {
     v: 2, name, repo: repoLabel, branch: readBranch(),
+    // sdkWarn: the auto-pulled agent SDK failed its boot compatibility smoke test —
+    // surfaced so the room can show a banner (turns may misbehave; pin a good SDK).
+    ...(sdkStatus.ok === false ? { sdkWarn: `${sdkStatus.version}: ${sdkStatus.reason}` } : {}),
     // models: the SDK's supported-model list, so the /model picker shows the real
     // set (incl. Fable + version labels) on every device without hardcoding.
     models: roomModels || undefined,
@@ -2156,6 +2205,71 @@ channel
     saveNames(room, termNames)
     announce()
   })
+  // Session Info panel (2026-07-02) — a cheap one-shot recap on demand. NAMES live
+  // terminals with doing/done status; aggregates CLOSED terminals into one line
+  // without naming them (Max's spec). Runs on the room's own subscription auth via
+  // oneShotSummary (cheap haiku → provider-default fallback). Never auto — only on
+  // the panel button. The web caches the result in React state (no re-charge on
+  // re-open within a page load).
+  .on('broadcast', { event: 'code-summarize' }, async ({ payload }) => {
+    const by = payload?.by || null
+    bcast('code-summary', { status: 'generating', by })
+    try {
+      // Pull assistant/user text out of a transcript-event array, keep the tail.
+      const logDigest = (events, max = 1200) => {
+        const parts = []
+        for (const e of (events || [])) {
+          if (e?.kind === 'assistant') { for (const b of (e.blocks || [])) if (b?.type === 'text' && b.text) parts.push(b.text) }
+          else if (e?.kind === 'you' && e.text) parts.push(`user: ${e.text}`)
+        }
+        return parts.join('\n').replace(/\n{3,}/g, '\n\n').slice(-max)
+      }
+      // LIVE structured terminals — named, doing/done, with a recent digest.
+      const live = []
+      let env = null, cwd = null
+      for (const [id, e] of sessions) {
+        if (e.kind !== 'structured') continue
+        live.push({ name: termNames[id] || 'Terminal', status: e.session?.turnActive ? 'working' : 'done', digest: logDigest(e.log, 1100) })
+        if (!env) { env = { ...process.env }; cwd = e.cwd || process.cwd() }
+      }
+      // CLOSED terminals — named but not live. Aggregate only; cap the read to bound cost.
+      const liveIdSet = new Set(sessions.keys())
+      const closedIds = Object.keys(termNames).filter(id => !liveIdSet.has(id))
+      const closedDigests = []
+      for (const id of closedIds.slice(0, 4)) {
+        try {
+          const page = readDurablePage(room, id, Number.MAX_SAFE_INTEGER, 30)
+          const evs = Array.isArray(page) ? page : (Array.isArray(page?.events) ? page.events : [])
+          const d = logDigest(evs, 450)
+          if (d) closedDigests.push(d)
+        } catch { /* no retained detail for this closed lane */ }
+      }
+      if (!live.length && !closedIds.length) { bcast('code-summary', { status: 'error', error: 'Nothing to summarize yet.', by }); return }
+
+      const liveBlock = live.length
+        ? live.map(t => `LIVE TERMINAL "${t.name}" [${t.status}]:\n${t.digest || '(no recent activity)'}`).join('\n\n')
+        : '(no live terminals)'
+      const closedBlock = closedIds.length
+        ? `\n\nThere are also ${closedIds.length} CLOSED terminal(s). Recent excerpts (do NOT name them individually):\n${(closedDigests.join('\n---\n') || '(no retained detail)').slice(0, 1400)}`
+        : ''
+
+      const prompt = `Write a concise recap of this multi-terminal coding session for someone glancing at it. Rules:
+- NAME each LIVE terminal and say whether it is working or done, and briefly what it is doing/did.
+- Do NOT name the CLOSED terminals individually — fold them into ONE aggregate clause ("plus N closed lanes that handled …").
+- 2 to 4 sentences total, plain prose, no markdown, no headers, no bullet lists.
+
+${liveBlock}${closedBlock}
+
+Recap:`
+
+      const res = await oneShotSummary({ prompt, env: env || process.env, cwd: cwd || process.cwd() })
+      if (!res || !res.text) { bcast('code-summary', { status: 'error', error: 'Summary model unavailable on this provider.', by }); return }
+      bcast('code-summary', { status: 'done', text: res.text, model: res.model, generatedAt: Date.now(), by })
+      process.stderr.write(`\n  ◆ session summary generated (${res.model}) for ${by || 'someone'}.\n`)
+    } catch (e) {
+      bcast('code-summary', { status: 'error', error: String(e?.message || e).slice(0, 140), by })
+    }
+  })
   .on('broadcast', { event: 'who' }, announce)
   .subscribe(status => {
     if (status === 'SUBSCRIBED') {

package/claude-session.mjs

@@ -139,6 +139,48 @@ const TP_ROOM_REMINDER = [
   'Verify before claiming done — show runtime evidence you produced, not "should work, go test it".',
 ].join(' ')
 
+// ── One-shot summary (2026-07-02, Session Info panel) ────────────────────────
+// A bare, cheap, cold model call — same shape as the haikuSuggest fallback: runs
+// on the room's own subscription auth (env carries the OAuth — no API key), NO
+// settingSources / MCP / tools, maxTurns 1. Used by the bridge's code-summarize
+// handler to write a session recap on demand. Model fallback (Max's ask): prefer a
+// cheap haiku-class model; if the provider (GLM / OpenRouter / custom base-url) has
+// no such model, retry with the provider default. Returns { text, model } or null.
+export async function oneShotSummary({ prompt, env, cwd, timeoutMs = 25000 }) {
+  const attempt = async (model) => {
+    const ac = new AbortController()
+    const t = setTimeout(() => { try { ac.abort() } catch { /* noop */ } }, timeoutMs)
+    try {
+      const hq = query({
+        prompt,
+        options: {
+          ...(model ? { model } : {}),
+          ...(cwd ? { cwd } : {}),
+          env,
+          maxTurns: 1,
+          permissionMode: 'bypassPermissions',
+          settingSources: [],
+          strictMcpConfig: true,
+          mcpServers: {},
+          abortController: ac,
+        },
+      })
+      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
+      }
+      return out.trim()
+    } finally { clearTimeout(t) }
+  }
+  // Prefer cheap haiku; fall back to the provider's default model if it's absent.
+  try { const out = await attempt('claude-haiku-4-5'); if (out) return { text: out, model: 'claude-haiku-4-5' } }
+  catch { /* provider has no haiku — fall through to default */ }
+  try { const out = await attempt(undefined); if (out) return { text: out, model: 'default' } }
+  catch { /* provider default also failed */ }
+  return null
+}
+
 export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null }) {
   const ac = new AbortController()
   let input = makeInputStream()   // `let`: auto-restart swaps in a fresh stream

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.126",
+  "version": "0.7.128",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bridge.mjs",
+    "sdk-smoke.mjs",
     "launcher.mjs",
     "byok-detect.mjs",
     "claude-session.mjs",

package/sdk-smoke.mjs

@@ -0,0 +1,60 @@
+// sdk-smoke.mjs — agent-SDK compatibility smoke test.
+//
+// The bridge tracks @anthropic-ai/claude-agent-sdk on a caret (^0.3.x), so a
+// restart can auto-pull a NEW SDK. Our own history (feedback_bridge_sdk_pin_no_bundle)
+// is that the SDK's interrupt/turn API has broken between 0.3.x minors. This verifies
+// the API SURFACE the bridge depends on — BEFORE the bridge commits to serving with a
+// freshly-pulled SDK — so a bad one is caught + surfaced instead of silently breaking
+// every turn.
+//
+// Deliberately CHEAP + OFFLINE: no Claude key, no network, no token spend. It only
+// checks that the SDK imports, query() constructs, and the control methods the bridge
+// calls (interrupt / setModel / setPermissionMode / supportedModels) exist as
+// functions. It does NOT run a real turn (that would cost tokens + need auth). A
+// surface break — a removed/renamed method — is the failure mode this guards; a subtle
+// behavioural break still needs a live turn (out of scope for a boot gate).
+//
+// Runs as a SHORT-LIVED SUBPROCESS with a hard timeout, so a hung SDK import/construct
+// = FAIL, never a hung bridge. One line to stdout: `SMOKE:PASS:<version>` /
+// `SMOKE:FAIL:<version>:<reason>`. Exit 0 = pass, 1 = incompatible, 2 = timeout.
+
+import { createRequire } from 'node:module'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+const HARD_TIMEOUT_MS = Math.max(4000, parseInt(process.env.TP_SDK_SMOKE_TIMEOUT, 10) || 12000)
+const guard = setTimeout(() => { emit('FAIL', ver(), 'timeout importing/constructing the SDK'); process.exit(2) }, HARD_TIMEOUT_MS)
+
+function emit(status, version, reason) {
+  try { process.stdout.write(`SMOKE:${status}:${version || 'unknown'}${reason ? ':' + reason : ''}\n`) } catch { /* noop */ }
+}
+// Resolve the SDK's real version from wherever node just resolved the package (the
+// caret pick), by walking up from its entry to the package.json with the right name.
+function ver() {
+  try {
+    const require = createRequire(import.meta.url)
+    let d = dirname(require.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 */ }
+      const up = dirname(d); if (up === d) break; d = up
+    }
+  } catch { /* unresolved */ }
+  return 'unknown'
+}
+
+const version = ver()
+try {
+  const sdk = await import('@anthropic-ai/claude-agent-sdk')
+  if (typeof sdk.query !== 'function') { emit('FAIL', version, 'query is not a function'); clearTimeout(guard); process.exit(1) }
+  async function* noInput() { return }   // ends immediately — never blocks the construct
+  const q = sdk.query({ prompt: noInput(), options: { permissionMode: 'default' } })
+  const need = ['interrupt', 'setModel', 'setPermissionMode', 'supportedModels']
+  const missing = need.filter((m) => typeof q?.[m] !== 'function')
+  try { q?.interrupt?.() } catch { /* don't leave it running */ }
+  if (missing.length) { emit('FAIL', version, `missing methods: ${missing.join('/')}`); clearTimeout(guard); process.exit(1) }
+  emit('PASS', version)
+  clearTimeout(guard); process.exit(0)
+} catch (e) {
+  emit('FAIL', version, `import/construct threw: ${(e?.message || e).toString().slice(0, 120)}`)
+  clearTimeout(guard); process.exit(1)
+}