thinkpool-pair 0.7.148 → 0.7.150

package/bridge.mjs

@@ -41,7 +41,7 @@ import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
 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
+import { normalizePlanOutput, laneModelFor } from './flow-task-graph.mjs'   // FL-B1 — validate the conductor's submit_flow_plan task-graph; laneModelFor — per-slice model tier (2026-07-03-flow-lane-model-tiers)
 // S1 (context-offload) — durable digest store. mark_flow_done digests a closed slice in;
 // the dispatch loop reads the bounded cross-wave context back out (via assembleCrossWaveContext,
 // which enforces the CEILING). Consume the store — the internals live in flow-context-store.mjs.
@@ -1565,7 +1565,7 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // recursively spawn/post onward — the fork-bomb breaker (mirrors Tier C).
       tool(
         'spawn_terminal',
-        'Open a NEW agent terminal (a fresh Claude lane) in this ThinkPool Code room — YOUR lane to use, not a sibling that is already working. Use it to fan work out: give it an initial `task` and it runs in parallel in its own lane; collect its result later with read_terminal, and close it with close_terminal when done. By default the new lane INHERITS your current permission mode — so if you are in bypass, it runs autonomously with no per-action clicking; pass `mode` to override. ALWAYS prefer spawning a fresh lane over post_to_terminal into one that is already busy. Bounded by the room terminal cap and a per-turn limit.',
+        'Open a NEW agent terminal (a fresh Claude lane) in this ThinkPool Code room — YOUR lane to use, not a sibling that is already working. Use it to fan work out: give it an initial `task` and it runs in parallel in its own lane; collect its result later with read_terminal, and close it with close_terminal when done. By default the new lane INHERITS your current permission mode — so if you are in bypass, it runs autonomously with no per-action clicking; pass `mode` to override. ALWAYS prefer spawning a fresh lane over post_to_terminal into one that is already busy. Tier guidance: default worker lanes to opus; use sonnet for mechanical work (renames, boilerplate, doc sweeps); reserve your own model for planning/review. Bounded by the room terminal cap and a per-turn limit.',
         {
           name: z.string().max(80).optional().describe('a short label for the new lane so the room (and you) can find it, e.g. "Research: topologies"'),
           task: z.string().optional().describe('an initial task to hand the new lane immediately; omit to open it idle'),
@@ -1840,8 +1840,21 @@ function openStructured({ id, model, resume, log, commands, mode, spawnedBy, rol
       // mid-turn) flash a brief "Compacting…" beat so it isn't silent — we only learn of it
       // post-hoc, so there's no real duration to animate (Max, 2026-07-02).
       if (evt.kind === 'compaction') {
-        if (entry.compacting) evt.by = entry.compactBy || null
-        else if (evt.trigger === 'auto') {
+        if (entry.compacting) {
+          // MANUAL /compact: attribute the recap card, then CLEAR the "Compacting…"
+          // indicator right here — the compact_boundary milestone IS the "done" signal.
+          // We used to wait for the turn's `result` (below), but a real /compact re-inits
+          // the SDK session, so the result can land after entry.compacting was lost →
+          // the indicator hung forever and kept counting (Max, 2026-07-03). The milestone
+          // is emitted with compacting still true (that's how we attribute `by`), so it's
+          // the reliable place to stop it. The result handler below stays as the backstop
+          // for a NO-OP /compact ("nothing to compact"), which emits a result but no
+          // compaction milestone.
+          evt.by = entry.compactBy || null
+          entry.compacting = false
+          entry.compactBy = null
+          bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+        } else if (evt.trigger === 'auto') {
           bcast('code-event', { term: id, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
           setTimeout(() => { bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } }) }, 2500)
         }
@@ -2558,7 +2571,10 @@ flowChannel
     // lanes form ONE Ensemble group (same ensembleRoot) — the drilled flow shows a row of
     // all its terminals to hop between, with a working Back. (No flowTaskKey → it's still
     // the conductor, excluded from the lane cap below.)
-    openStructured({ id: cid, mode: 'default', rolePrompt: FLOW_CONDUCTOR_PROMPT, flowSessionId: payload.flowId, spawnedBy: `flow:${payload.flowId}` })
+    // Model tiers (2026-07-03-flow-lane-model-tiers): the conductor keeps whatever brain it was
+    // given by default (TP_FLOW_CONDUCTOR_MODEL unset → undefined → today's behavior); set the env
+    // to pin a cheaper/smarter conductor. Lanes get tiered below via laneModelFor.
+    openStructured({ id: cid, model: process.env.TP_FLOW_CONDUCTOR_MODEL || undefined, mode: 'default', rolePrompt: FLOW_CONDUCTOR_PROMPT, flowSessionId: payload.flowId, spawnedBy: `flow:${payload.flowId}` })
     const ce = sessions.get(cid)
     if (ce?.session) { try { ce.session.sendTurn(payload.prompt || '') } catch { /* session still starting */ } }
     process.stderr.write(`\n  ${A.mag}◆ flow conductor launched — flow ${String(payload.flowId).slice(0, 8)} (plan mode).${A.rst}\n`)
@@ -2635,7 +2651,10 @@ flowChannel
         // no dangling tool_use → no 400) instead of a cold start; undefined for a fresh lane.
         const laneBase = isReview ? FLOW_REVIEWER_PROMPT : FLOW_LANE_PROMPT
         const laneRolePrompt = buildLanePrompt({ base: laneBase })
-        openStructured({ id: laneId, cwd: dir, mode: 'bypassPermissions', rolePrompt: laneRolePrompt, flowSessionId: payload.flowId, flowTaskKey: t.task_key, spawnedBy: `flow:${payload.flowId}`, resume: redispatch?.resumeSessionId || undefined, reviewSliceRoots })
+        // Model tiers (2026-07-03-flow-lane-model-tiers): pick the lane's brain by slice_type
+        // (scaffold→sonnet, feature/fix/review→opus; env can blanket-override or `inherit` to
+        // restore today's exact behavior). undefined → no model key passed (openStructured default).
+        openStructured({ id: laneId, cwd: dir, model: laneModelFor(t.slice_type), mode: 'bypassPermissions', rolePrompt: laneRolePrompt, flowSessionId: payload.flowId, flowTaskKey: t.task_key, spawnedBy: `flow:${payload.flowId}`, resume: redispatch?.resumeSessionId || undefined, reviewSliceRoots })
         const le = sessions.get(laneId)
         if (le) {
           // S4 — stamp the surviving revert target on the resumed lane so a later reviewer still

package/flow-task-graph.mjs

@@ -172,3 +172,34 @@ export function normalizePlanOutput (raw) {
   validateDag(tasks)
   return { summary, tasks }
 }
+
+// ── Flow lane model tiers ───────────────────────────────────────────────────
+// Spec: docs/specs/2026-07-03-flow-lane-model-tiers.md
+// The conductor thinks; the worker lanes type. Running every lane on the same
+// expensive brain is wasteful — the tier map picks a model per slice_type so
+// intelligence matches the job:
+//   scaffold → sonnet   (boilerplate / project bootstrap — mechanical, cheap)
+//   feature  → opus     (real building — needs the smart brain)
+//   fix      → opus     (root-cause debugging — needs the smart brain)
+//   review   → opus     (adversarial verification is intelligence-SENSITIVE; never cheapen it)
+// Unknown/missing slice types fall to opus (safe default — never silently cheapen).
+// Dev-only, no product gating. The conductor's own model is untouched by this map
+// (bridge reads TP_FLOW_CONDUCTOR_MODEL at the conductor spawn site instead).
+//
+// Env overrides (checked FIRST, in order):
+//   TP_FLOW_LANE_MODEL='inherit'  → return undefined (no model key passed → today's exact behavior)
+//   TP_FLOW_LANE_MODEL=<model>    → blanket-override every lane to that model
+//   (empty-string / unset)        → fall through to the tier map
+const LANE_MODEL_TIERS = {
+  scaffold: 'sonnet',
+  feature: 'opus',
+  fix: 'opus',
+  review: 'opus',
+}
+
+export function laneModelFor (sliceType, env = process.env) {
+  const override = env.TP_FLOW_LANE_MODEL
+  if (override === 'inherit') return undefined          // sentinel — restore today's behavior exactly
+  if (override) return override                          // blanket override for all lanes (non-empty string)
+  return LANE_MODEL_TIERS[sliceType] || 'opus'           // tier map; unknown/missing → opus (never cheapen by accident)
+}

package/package.json

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