thinkpool-pair 0.7.53 → 0.7.55

package/claude-session.mjs

@@ -177,6 +177,16 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // the catch self-heals.
   const FORCE_STOP_MS = Math.max(STALL_MS * 3, parseInt(process.env.TP_FORCE_STOP_MS, 10) || 300000)
   let forceStopped = false
+  // ── Haiku suggestion fallback ──
+  // Claude Code's own `prompt_suggestion` rarely fires in /code — the binary suppresses it
+  // per-turn (cache_cold when a turn's tokens > 10k, rate_limit when throttled, first turn).
+  // When it doesn't arrive shortly after `result`, we generate one ourselves with a cheap
+  // one-shot Haiku call on the SAME subscription auth (no API key), fed ONLY the last
+  // assistant reply (suggestions are short: "proceed" / "go with A") — fast + ~free.
+  let sawSuggestion = false       // did Claude's own prompt_suggestion fire this turn?
+  let lastAssistantText = ''      // most recent assistant prose — the only context the fallback needs
+  let sugTimer = null             // pending fallback timer
+  const SUGGEST_FALLBACK_MS = Math.max(1200, parseInt(process.env.TP_SUGGEST_FALLBACK_MS, 10) || 2500)
 
   const emit = (evt) => { lastEvtTs = Date.now(); if (evt && evt.kind !== 'stalled') stalledSent = false; try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
   const stallTimer = setInterval(() => {
@@ -374,6 +384,44 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     if (healed.blocks) process.stderr.write(`\n  ◆ healed ${healed.blocks} cross-provider tool block(s) in the transcript before resume.\n`)
   }
 
+  // One-shot Haiku fallback suggestion. Runs on the SAME subscription auth as the room
+  // (opts.env carries the OAuth — no API key needed), but as a BARE model call: no
+  // settingSources, no MCP, no tools — so it's a fast cold call, not a full session boot.
+  // Fed only `lastAssistantText` (trimmed). Never blocks a turn; any failure is silent.
+  const haikuSuggest = async () => {
+    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({
+        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,
+        },
+      })
+      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 runQuery = async () => {
     try {
       q = query({ prompt: input.stream, options: { ...opts, ...(sessionId ? { resume: sessionId } : {}) } })
@@ -421,6 +469,8 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             // parentToolUseId: non-null when this assistant message comes from a
             // sub-agent (Task tool) — the universal nesting spine. Thread it so the
             // room can group sub-agent activity under its parent Task card.
+            // Capture the latest assistant prose — the only context the Haiku fallback needs.
+            { const txt = (m.message?.content || []).filter((b) => b?.type === 'text').map((b) => b.text).join('\n').trim(); if (txt) lastAssistantText = txt }
             emit({ kind: 'assistant', blocks: simplifyBlocks(m.message?.content), parentToolUseId: m.parent_tool_use_id || null })
             break
           case 'user':
@@ -456,6 +506,10 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             restartCount = 0                 // a successful turn refills the auto-restart budget
             forceStopped = false
             emit({ kind: 'result', subtype: m.subtype, sessionId, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns, durationMs: m.duration_ms ?? null, denials: Array.isArray(m.permission_denials) ? m.permission_denials.length : 0 })
+            // Arm the Haiku fallback: if Claude's own prompt_suggestion doesn't arrive within
+            // the window, generate one from the last assistant reply. (Skip aborted turns.)
+            if (sugTimer) clearTimeout(sugTimer)
+            if (m.subtype !== 'aborted') sugTimer = setTimeout(() => { sugTimer = null; if (!sawSuggestion && !closed) haikuSuggest() }, SUGGEST_FALLBACK_MS)
             // Surface a usage/context meter (chrome, not a transcript line). The
             // context window % comes from the control request; cost is cumulative.
             ;(async () => {
@@ -472,7 +526,8 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
             // Claude Code's own predicted next prompt (promptSuggestions opt-in).
             // Arrives once per turn AFTER `result`; surfaced verbatim as ephemeral
             // chrome (a ghost-text chip in the room composer), never persisted.
-            if (m.suggestion) emit({ kind: 'suggestion', text: m.suggestion })
+            if (sugTimer) { clearTimeout(sugTimer); sugTimer = null }   // built-in won — cancel the Haiku fallback
+            if (m.suggestion) { sawSuggestion = true; emit({ kind: 'suggestion', text: m.suggestion }) }
             break
           default:
             break
@@ -504,7 +559,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   runQuery()
 
   return {
-    sendTurn(text) { if (!closed) { turnActive = true; lastEvtTs = Date.now(); stalledSent = false; input.push(String(text)) } },
+    sendTurn(text) { if (!closed) { turnActive = true; sawSuggestion = false; if (sugTimer) { clearTimeout(sugTimer); sugTimer = null } lastEvtTs = Date.now(); stalledSent = false; input.push(String(text)) } },
     // Set the permission mode — Claude Code's ⇧⇥ cycle. setPermissionMode is a
     // streaming control request (drives plan-mode behaviour SDK-side); the local
     // `mode` drives our PreToolUse auto-approve policy. Echo so the room syncs.

package/package.json

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