thinkpool-pair 0.7.126 → 0.7.127

package/bridge.mjs

@@ -38,7 +38,7 @@ 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;
@@ -2156,6 +2156,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.127",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {