thinkpool-pair 0.6.6 → 0.6.8

package/bridge.mjs

@@ -330,6 +330,7 @@ function printLocal(evt) {
     case 'pool': return w(evt.pending ? `${A.cyan}◌ pool synthesizing…${A.rst}` : `${A.cyan}◆ pool → ${evt.text}${A.rst}`)
     case 'note': return w(`${A.dim}— ${evt.text} —${A.rst}`)
     case 'clear': return w(`${A.dim}— context cleared —${A.rst}`)
+    case 'usage': { const c = evt.ctx; return c ? w(`${A.dim}  ctx ${c.pct}% · ${Math.round(c.used / 1000)}k/${Math.round(c.max / 1000)}k${evt.costUsd != null ? ` · $${evt.costUsd.toFixed(3)}` : ''}${A.rst}`) : undefined }
     case 'error': return w(`${A.red}✗ ${evt.message}${A.rst}`)
     case 'tool_result': {
       const c = evt.content
@@ -370,18 +371,25 @@ function openStructured({ id, model, resume, log }) {
         openStructured({ id, model, log: entry.log })
         return
       }
-      entry.log.push(evt)
-      if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
+      // Chrome events (mode / usage / clear) are transient state, not transcript —
+      // broadcast + print them, but keep them out of the persisted/replayed log.
+      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear'
+      if (!chrome) {
+        entry.log.push(evt)
+        if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
+      }
       bcast('code-event', { term: id, evt })
       printLocal(evt)
-      persist()
+      if (!chrome) persist()
     },
     requestPermission: (req) => new Promise((resolve) => {
       entry.pending.set(req.id, resolve)
-      bcast('code-perm-req', { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan })
+      bcast('code-perm-req', { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan, questions: req.questions })
       process.stderr.write(req.risk === 'plan'
         ? `\n  ${A.mag}◆ plan ready — approve in the room.${A.rst}\n`
-        : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
+        : req.risk === 'ask'
+          ? `\n  ${A.cyan}● Claude is asking: ${(req.questions || []).map((q) => q.question).join(' / ').slice(0, 100)} — answer in the room.${A.rst}\n`
+          : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
     }),
   })
   announce()

package/claude-session.mjs

@@ -91,6 +91,7 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
   let q = null            // the live Query — control requests (interrupt /
                           // setPermissionMode) route through it once streaming.
   let mode = 'default'    // mirrors Claude Code's ⇧⇥ cycle
+  const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
 
   const emit = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
 
@@ -119,16 +120,43 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
       }
       return { continue: true, hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: 'The user chose "keep planning" in the ThinkPool room. Do not exit plan mode — keep refining the plan, then call ExitPlanMode again when ready.' } }
     }
+    // ── AskUserQuestion — the agent asks the user a multiple-choice question.
+    // It can't run its interactive dialog headless (allowing it errors), so we
+    // render the choice card in the room and feed the selection back as the tool
+    // outcome. PreToolUse can't inject a tool_result, but a deny's reason IS what
+    // the model receives — so we deny and put the answer in the reason.
+    if (toolName === 'AskUserQuestion') {
+      let decision = ''
+      try { decision = await requestPermission?.({ id: randomUUID(), toolName, input: toolInput, risk: 'ask', questions: toolInput?.questions || [] }) ?? '' }
+      catch { decision = '' }
+      const ans = (typeof decision === 'string' && decision.startsWith('answer:')) ? decision.slice(7) : ''
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: ans
+            ? `The user answered in the ThinkPool room — ${ans}. Treat this as their selection and continue; do not call AskUserQuestion again for the same question.`
+            : 'The user dismissed the question in the ThinkPool room without selecting. Ask in plain prose, or proceed with a sensible default.',
+        },
+      }
+    }
     const risk = classifyRisk(toolName, toolInput)
+    // "Don't ask again" is keyed by tool + risk tier, so allowing medium Bash
+    // never silently allows a future destructive one (high always re-asks).
+    const sig = `${toolName}:${risk}`
     const auto =
       risk === 'low' ||
       mode === 'bypassPermissions' ||
-      (mode === 'acceptEdits' && WRITE_TOOLS.has(toolName) && risk !== 'high')
+      (mode === 'acceptEdits' && WRITE_TOOLS.has(toolName) && risk !== 'high') ||
+      alwaysAllow.has(sig)
     let decision = 'allow'
     if (!auto) {
       try {
         decision = await requestPermission?.({ id: randomUUID(), toolName, input: toolInput, risk }) ?? 'allow'
       } catch { decision = 'deny' } // a broken permission path must fail safe (deny)
+      // "Allow & don't ask again" — remember the signature, then allow.
+      if (decision === 'always') { alwaysAllow.add(sig); decision = 'allow' }
     }
     // On deny, permissionDecisionReason IS what the model receives as the
     // tool error — make it a real instruction, not an opaque tag.
@@ -178,6 +206,17 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
           case 'result':
             if (m.session_id) sessionId = m.session_id
             emit({ kind: 'result', subtype: m.subtype, sessionId, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns })
+            // Surface a usage/context meter (chrome, not a transcript line). The
+            // context window % comes from the control request; cost is cumulative.
+            ;(async () => {
+              let ctx = null
+              try {
+                const c = await q?.getContextUsage?.()
+                if (c) ctx = { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }
+              } catch { /* control req may be unavailable */ }
+              const u = m.usage || {}
+              emit({ kind: 'usage', costUsd: m.total_cost_usd ?? null, tokens: (u.input_tokens || 0) + (u.output_tokens || 0), ctx })
+            })()
             break
           default:
             break

package/package.json

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