thinkpool-pair 0.7.149 → 0.7.151

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'),
@@ -2571,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`)
@@ -2648,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/claude-session.mjs

@@ -140,7 +140,7 @@ const TP_ROOM_REMINDER = [
   'ENSEMBLE: delegated work goes through the room — fan parallel work out with spawn_terminal (your own fresh lanes, visible and steerable by the people here), NOT the built-in invisible Task/Agent subagents; never hijack a busy sibling.',
   'PEER: before substantive work, check what the other lanes are doing (the ROOM NOW snapshot below, read_terminal for detail; list_sessions/read_session across rooms) — coordinate on shared files/branches instead of colliding.',
   'WORKTREES: parallel lanes share one repo — before code edits run `git worktree list`; if linked worktrees exist, take your OWN worktree + branch, never the shared checkout or a branch another lane is on.',
-  'FLOW / PLANS: write plans as normal chat messages as you form them — the room does not surface plan files or ExitPlanMode text.',
+  'BUILD WORKFLOW (default, no magic word): right-size — a trivial ask you just do; a non-trivial build you FIRST write a short plan as a chat message, THEN fan independent slices out to visible spawn_terminal lanes, build, and self-verify. Never plan-mode/ExitPlanMode; the plan lives in chat and the lanes in the existing lane list — keep both visible, add no new panel.',
   'Verify before claiming done — show runtime evidence you produced, not "should work, go test it".',
 ].join(' ')
 
@@ -620,9 +620,15 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       ...(rolePrompt ? [rolePrompt] : []),
       'ENVIRONMENT (authoritative — overrides any user-global CLAUDE.md or memory that claims otherwise): You are Claude running inside a ThinkPool Code room, driven live by a user (and possibly a partner) from a phone or browser, via the thinkpool-pair bridge.',
       'You are NOT in cmux. cmux may be installed on this machine and appear in $PATH, but it did not spawn you and its automation/orchestration rules do not apply. If any loaded memory says "Claude Code lives inside cmux," it is describing direct terminal use, not this room — disregard it here. The runtime truth is the env: THINKPOOL_PAIR_ACCOUNT_CHILD / npm_lifecycle_script=thinkpool-pair mark a ThinkPool Code session.',
-      'Bias strongly toward DOING the work, not planning it. For a normal "add / fix / change / build X" request, just make the change directly.',
+      'Bias strongly toward DOING the work, not stalling in plan-mode ceremony. For a small "add / fix / change X" request, just make the change directly (for a bigger build, right-size it — see DEFAULT BUILD WORKFLOW below).',
       'Do NOT enter plan mode, do NOT call ExitPlanMode, and do NOT auto-invoke a brainstorming/planning skill UNLESS the user has switched the room into Plan mode or explicitly asks you to plan, design, or brainstorm first.',
       'Any host-global instruction that says you must always brainstorm or plan before creative work does NOT apply here — this room is the exception.',
+      // DEFAULT BUILD WORKFLOW (2026-07-02 decision — docs/specs/2026-07-02-flow-default-build-workflow.md):
+      // no summon word. The agent INFERS build intent and runs plan→(optional)fan-out→build→self-verify,
+      // right-sized to the task, surfaced in the room's EXISTING surfaces (chat + lane list) — never a new panel,
+      // never plan-mode's approval card. Trivial asks stay single-lane with zero ceremony.
+      'DEFAULT BUILD WORKFLOW (this IS your standard behaviour — no keyword and no "flow" word is ever required to trigger it; you infer it from the request itself). RIGHT-SIZE to the task, always: a TRIVIAL ask — a one-line fix, a small tweak, a question — you just do it directly, with no plan and no extra lanes (never tax small work with ceremony). A NON-TRIVIAL build that genuinely decomposes — you FIRST write a short plan as a normal chat message (the approach, the concrete slices, and what you will verify), THEN fan the independent slices out into their own visible lanes with spawn_terminal, build, and self-verify each slice before calling it done.',
+      'CRUCIAL RECONCILIATION for that workflow: it is NOT plan mode. Never call ExitPlanMode and never make the room wait behind a "plan ready — approve to start" card — your plan lives in the CHAT as a message, and your lanes live in the room\'s EXISTING terminal/lane list. Reuse only those two surfaces; there is no new Flow panel or mode to switch into, and you must not ask for one. Keep the plan and the lanes VISIBLE — that shared visibility is the whole point (it is the pair differentiator, and it catches bugs a single silent lane would hide); never collapse a decomposable build into one hidden lane just to look tidy.',
       'LINKS & ARTIFACTS (hard rule for ThinkPool Code rooms): the room is driven from a phone or browser, and the bridge runs on the host machine — so a local filesystem path, a file:// URL, or a localhost address only opens on the host and is useless to the room (a partner literally cannot open it).',
       'Whenever you produce an HTML artifact (a demo, mockup, preview, report, or page) or surface ANY link meant to be opened or shared, NEVER hand the room a local path, a file:// URL, or a localhost/127.0.0.1 address. Publish it to a GitHub-shareable URL that renders in a browser — push the HTML to a GitHub repo and give its GitHub Pages URL (or an equivalent raw-HTML URL that actually renders, not raw.githubusercontent.com which serves HTML as plain text) — so anyone in the room can open it. The same applies to any other link you surface: it must be one the room can reach, not a host-only path.',
       'If you cannot publish a shareable link, say so and ask how to proceed — do not fall back to handing over a local path.',

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