thinkpool-pair 0.7.257 → 0.7.259

package/bridge.mjs

@@ -119,6 +119,7 @@ import { classifyCodeEvent, unknownCodeEventNotice } from './code-event-contract
 import { fetchPairControlDeliveryAuthority } from './pair-control-authority.mjs'
 import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, sideContextBlock, sideSnapshot } from './side-lane.mjs'
 import { planMeterLine } from './plan-meters.mjs'
+import { priceForModel } from './model-prices.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 import { resolveAnonKey, DEFAULT_SUPABASE_URL } from './supabase-key.mjs'
 import { buildTerminalRolePrompt, HERMES_VISIBLE_WORKER_FALLBACK_RULE } from './thinkpool-room-prompt.mjs'
@@ -869,15 +870,24 @@ function recordRoomSpend (tokens) {
 // TP_BUDGET_OFF (that only governs the cap ledger; usage accounting should still
 // run). input = full input incl. cache; cached = cache-read slice; both mapped to
 // pricing.js's rowCostEur formula. No model → skip (can't price/label it).
-function recordCodeUsage (model, usage) {
+function recordCodeUsage (model, usage, provider) {
   if (!codeAuthToken || !room || !model) return
   const u = usage || {}
   const input  = (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
   const output = u.output_tokens || 0
   const cached = u.cache_read_input_tokens || 0
   if (!input && !output) return
-  budgetRpc('record_code_usage', { p_room: room, p_model: model, p_input: input, p_output: output, p_cached: cached })
-    .catch(() => { /* best-effort — usage accounting is not load-bearing for the turn */ })
+  // Persist the public rate resolved for this exact runtime model. A private
+  // model can lack a public rate; its token row is still written and Settings
+  // marks only the estimate as pending rather than making one up.
+  priceForModel(model).then((rate) => budgetRpc('record_code_usage', {
+    p_room: room, p_model: model, p_input: input, p_output: output, p_cached: cached,
+    p_provider: provider || 'unknown',
+    p_input_usd_per_mtok: rate?.input ?? null,
+    p_output_usd_per_mtok: rate?.output ?? null,
+    p_cached_input_usd_per_mtok: rate?.cached ?? null,
+    p_rate_source: rate?.source ?? null,
+  })).catch(() => { /* usage accounting is never load-bearing for a turn */ })
 }
 // Throttled presence track() (presence.mjs) — a reconnect storm re-fires SUBSCRIBED and
 // the handler re-track()s; without throttle that spirals into the per-client presence
@@ -2862,7 +2872,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       // Fold EVERY completed turn's output tokens into the room's durable monthly ledger
       // (lanes + normal turns) — powers the Session-info "Session tokens" stat. (The cap that
       // consumed this ledger was removed; the accounting stays.)
-      if (evt.kind === 'result' && evt.usage) { recordRoomSpend(evt.usage.output_tokens || 0); recordCodeUsage(evt.model, evt.usage) }
+      if (evt.kind === 'result' && evt.usage) { recordRoomSpend(evt.usage.output_tokens || 0); recordCodeUsage(evt.model, evt.usage, entry.provider) }
       // FL-B1 (lane) — a flow lane that ENDS ITS TURN is done: a bypass lane runs its slice
       // to completion in one turn, then narrates "done" and stops. Models often skip the
       // explicit signal (FLOW_DONE / mark_flow_done), which left the slice stuck 'dispatched'

package/claude-session.mjs

@@ -21,7 +21,7 @@ import { sanitizeSession } from './transcript-sanitize.mjs'
 import { reviewGatePreToolDecision } from './flow-review-gate.mjs'
 import { crossPostNeedsCard } from './cross-terminal.mjs'
 import { correctContext } from './context-windows.mjs'
-import { THINKPOOL_DESIGN_DELIVERY_RULE, THINKPOOL_REMOTE_DELIVERY_RULES } from './thinkpool-room-prompt.mjs'
+import { THINKPOOL_REMOTE_DELIVERY_RULES, THINKPOOL_RUNTIME_TURN_REMINDER, buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
 import { stallDecision, stallEvent, isCompactTurn } from './turn-stall.mjs'
 
 // The caret-pulled SDK's real version (^0.3.x auto-upgrades on restart). Resolved
@@ -183,28 +183,26 @@ const simplifyBlocks = (blocks = []) => blocks.map((b) => {
  */
 const MODES = new Set(['default', 'acceptEdits', 'plan', 'bypassPermissions'])
 
-// Per-turn salience reminder. The full ThinkPool Code ruleset lives in
+// Periodic salience reminder. The full ThinkPool Code ruleset lives in
 // `appendSystemPrompt` (baked once at session start), but on a long session — heavy
 // tool output, and especially after auto-compaction — the model's attention drifts
 // off a system prompt that sits behind the large host CLAUDE.md. The classic tell:
 // the agent hands the room a host-local path (`open …`, "it's in ~/claude-shots/")
 // or narrates instead of showing, forgetting it's driven from a phone. So we re-state
-// the highest-drift rules as a compact <system-reminder> appended to EVERY user turn,
+// the highest-drift rules in a <system-reminder> at session start, after recovery,
+// and every fifth prompt. Ordinary turns get only the compact invariant and any
+// route-specific guidance implied by the request.
 // adjacent to where the model's attention actually is — the same trick the host
-// harness uses to keep CLAUDE.md alive. ~250 tokens/turn; changes nothing but salience.
-// A live "ROOM NOW" tail (sibling lanes + active worktrees) is appended per turn by
-// the bridge's roomContext callback — see roomReminder() inside startClaudeSession.
+// harness uses to keep CLAUDE.md alive. The shared capability router deliberately
+// A live "ROOM NOW" tail (sibling lanes + active worktrees) is appended when it
+// changes and on the same periodic refresh cadence.
 const TP_ROOM_REMINDER = [
   'You are Claude in a ThinkPool Code room, driven live from a phone or browser — NOT a local terminal. Keep using the room\'s features.',
-  'ARTIFACTS: never hand the room a local path, a file:// URL, a localhost address, an `open …`/Preview reference, or "it\'s in ~/claude-shots/" — the room cannot see the host. Surface every image by reading the PNG into your turn so it renders inline.',
-  THINKPOOL_DESIGN_DELIVERY_RULE,
-  'REMOTE USER: the people here may have no terminal and no access to this host — never ask them to run a local command, open a local file, or check something on the machine. Anything host-side, YOU run, and show the result.',
-  'SHOW, don\'t narrate: a picture of the result beats a wall of text on a phone — err toward more screenshots.',
+  THINKPOOL_RUNTIME_TURN_REMINDER,
   'TERMINAL HIERARCHY: obey your authoritative TERMINAL ROLE. Conductors are independent main terminals; Ensemble lanes are workers only. When a person explicitly asks to open, launch, start, or spawn a separate Cascade/conductor terminal, use open_main_terminal — NEVER spawn_terminal. If open_main_terminal is unavailable, say so; never substitute an Ensemble child. Only conductor-capable roles fan worker slices out with spawn_terminal. Leaf, worker, Side, and managed Flow lanes work directly. Never use built-in invisible Task/Agent subagents or 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.',
   'BUILD WORKFLOW (default, no magic word): right-size within your TERMINAL ROLE — a trivial ask or delegated slice you just do; a conductor-capable role with a genuinely decomposable build FIRST writes a short plan in chat, THEN fans worker slices into visible spawn_terminal lanes and verifies them. Worker/leaf/Side/managed Flow roles do not fan out. A requested separate conductor uses open_main_terminal. Never plan-mode/ExitPlanMode; plans live in chat and lanes in the existing list.',
-  'Verify before claiming done — show runtime evidence you produced, not "should work, go test it".',
 ].join(' ')
 
 export function startClaudeSession({ cwd, model, effort: initialEffort = 'high', resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, didSpawnTarget = null, terminalRolePrompt, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null, lazy = false, roomContext = null, suggest = true, prepareCwd = null }) {
@@ -213,11 +211,15 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   // rules keep the agent aware of the room's FEATURES; the live tail keeps it aware of
   // the room's STATE (2026-07-02 ask: "aware at all points that it's in a ThinkPool
   // Code session"). A broken snapshot must never break a turn — fail-quiet to static.
-  const roomReminder = () => {
-    let live = null
-    try { live = roomContext ? roomContext() : null } catch { live = null }
+  const selectRoomContext = createRoomContextSelector(roomContext)
+  let userPromptNo = 0
+  let forceFullReminder = true
+  const roomReminder = (text, { promptIndex = 0, forceFull = false } = {}) => {
+    const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull })
+    const live = selectRoomContext({ force: fullReminder })
     const role = String(terminalRolePrompt || '').trim()
-    return `<system-reminder>\n${role ? `${role}\n\n` : ''}${TP_ROOM_REMINDER}${live ? `\n\n${live}` : ''}\n</system-reminder>`
+    const guidance = fullReminder ? TP_ROOM_REMINDER : buildThinkPoolTurnGuidance({ text, promptIndex, forceFull })
+    return `<system-reminder>\n${fullReminder && role ? `${role}\n\n` : ''}${guidance}${live ? `\n\n${live}` : ''}\n</system-reminder>`
   }
   const ac = new AbortController()
   let input = makeInputStream()   // `let`: auto-restart swaps in a fresh stream
@@ -229,6 +231,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
   // "No conversation found" (Max 2026-07-02). This is always a resumable id.
   let persistedSessionId = resume || null
   let lastTurnText = null   // the most recent turn text, so a bad-resume recovery can re-deliver it
+  let lastTurnReminder = null
   let closed = false
   // Lazy boot (2026-07-02): a RESTORED-IDLE terminal returns a full session object but
   // defers the expensive query() cold-start (MCP + settingSources, ~50s each) until its
@@ -852,6 +855,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
             // old heuristic): trigger ('manual' for /compact vs 'auto') + the token
             // count before compaction. Emit a real recap card the room can pin.
             if (m.subtype === 'compact_boundary') {
+              forceFullReminder = true
               emit({ kind: 'compaction', trigger: m.compact_metadata?.trigger || 'auto', preTokens: m.compact_metadata?.pre_tokens ?? null })
               // Refresh the ctx% meter RIGHT AFTER compaction — it otherwise only updates at
               // turn-end, so the mode row kept showing the stale PRE-compaction window
@@ -973,7 +977,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
                 restartTimer = null
                 if (closed) return
                 runQuery()
-                if (replay != null) { turnActive = true; lastEvtTs = Date.now(); stalledSent = false; input.push([{ type: 'text', text: replay }, { type: 'text', text: roomReminder() }]) }
+                if (replay != null) { turnActive = true; lastEvtTs = Date.now(); stalledSent = false; input.push([{ type: 'text', text: replay }, { type: 'text', text: lastTurnReminder || roomReminder(replay, { forceFull: true }) }]) }
               }, 300)
               break
             }
@@ -1147,7 +1151,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
     if (replay != null) {
       turnActive = true; lastEvtTs = Date.now(); stalledSent = false   // re-arm liveness for the retried turn
       // Match sendTurn's block shape: a slash command goes clean; a normal turn keeps the reminder.
-      input.push(/^\s*\//.test(replay) ? [{ type: 'text', text: replay }] : [{ type: 'text', text: replay }, { type: 'text', text: roomReminder() }])
+      input.push(/^\s*\//.test(replay) ? [{ type: 'text', text: replay }] : [{ type: 'text', text: replay }, { type: 'text', text: lastTurnReminder || roomReminder(replay, { forceFull: true }) }])
       emitRaw({ kind: 'note', text: 'retrying the stalled turn on a fresh connection' })
     }
   }
@@ -1158,6 +1162,10 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
     // is queue-backed, so the pushed turn buffers and runs once the query is ready.
     sendTurn(text) { if (!closed) { if (!started && prepareCwd) { try { const next = prepareCwd(); if (next) { cwd = next; opts.cwd = next } } catch { /* keep original cwd */ } } if (!started) runQuery(); turnActive = true; sawSuggestion = false; lastTurnText = String(text); if (sugTimer) { clearTimeout(sugTimer); sugTimer = null } lastEvtTs = Date.now(); stalledSent = false; stallRetried = false; forceStopped = false;
       const t = String(text)
+      const promptIndex = userPromptNo++
+      const thisTurnForceFull = forceFullReminder
+      forceFullReminder = /^\s*\/(?:compact|clear|reset)\b/i.test(t)
+      lastTurnReminder = /^\s*\//.test(t) ? null : roomReminder(t, { promptIndex, forceFull: thisTurnForceFull })
       // Arm the compaction window BEFORE the push: from here until the `compaction` milestone
       // (or the turn's result) the SDK is allowed to be silent for minutes without the stall
       // watchdog aborting it. See turn-stall.mjs — aborting a compaction is what produced
@@ -1171,7 +1179,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // recognized). So a slash command goes CLEAN; conversational turns keep the reminder.
       // Normal turns never start with "/" (composeAgentStdin prepends the preamble), and the
       // web already routes "/"-prefixed input as a command (pane.jsx), so this matches intent.
-      input.push(/^\s*\//.test(t) ? [{ type: 'text', text: t }] : [{ type: 'text', text: t }, { type: 'text', text: roomReminder() }])
+      input.push(/^\s*\//.test(t) ? [{ type: 'text', text: t }] : [{ type: 'text', text: t }, { type: 'text', text: lastTurnReminder }])
     } },
     // Cold-boot the query WITHOUT sending a turn — the background warmer calls this on
     // lazily-restored idle terminals so they're ready before the user clicks them.

package/codex-session.mjs

@@ -30,7 +30,7 @@ import readline from 'node:readline'
 import { buildCodexAppServerArgs, codexAppServerGate, createCodexAppServer } from './codex-app-server.mjs'
 import { CodexEventMapper } from './codex-event-mapper.mjs'
 import { startCodexMcpHttp } from './codex-mcp-http.mjs'
-import { CODEX_THINKPOOL_FIRST_TURN_PREAMBLE } from './thinkpool-room-prompt.mjs'
+import { CODEX_THINKPOOL_FIRST_TURN_PREAMBLE, buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
 
 const DEFAULT_SANDBOX = 'workspace-write'
 const SAFE_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access'])
@@ -214,12 +214,14 @@ export const CODEX_ROOM_CASCADE_REMINDER = [
   'THINKPOOL ROOM WORKFLOW: obey the authoritative TERMINAL ROLE above. Conductors are independent main terminals; Ensemble lanes are workers only. When a person explicitly asks to open, launch, start, or spawn a separate Cascade/conductor terminal, use open_main_terminal — NEVER spawn_terminal. Use spawn_terminal only for worker slices from a role permitted to delegate. If open_main_terminal is unavailable, say so; never substitute an Ensemble child. Leaf, worker, Side, and managed Flow lanes work directly and must not delegate. Never use hidden in-process subagents. Each worker owns its own worktree. For a genuinely decomposable task in a conductor-capable role, state a short plan in chat, use sliceType scaffold for mechanical work, feature/fix for builders, and review for adversarial verification; review must use a balanced model tier. Read results, verify the integrated outcome, and close every worker you spawned.',
 ].join(' ')
 
-export function buildCodexPrompt({ text, terminalRolePrompt, rolePrompt, roomContext, firstTurn = false }) {
+export function buildCodexPrompt({ text, terminalRolePrompt, rolePrompt, roomContext, firstTurn = false, promptIndex = 0, forceFullReminder = false }) {
   const context = typeof roomContext === 'function' ? roomContext() : roomContext
+  const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: forceFullReminder })
   const additions = [
     firstTurn ? CODEX_THINKPOOL_FIRST_TURN_PREAMBLE : '',
-    terminalRolePrompt,
-    rolePrompt || CODEX_ROOM_CASCADE_REMINDER,
+    fullReminder ? terminalRolePrompt : '',
+    buildThinkPoolTurnGuidance({ text, promptIndex, forceFull: forceFullReminder }),
+    fullReminder ? (rolePrompt || CODEX_ROOM_CASCADE_REMINDER) : '',
     context,
   ].map((v) => String(v || '').trim()).filter(Boolean)
   if (!additions.length) return String(text ?? '')
@@ -395,6 +397,9 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   })
   let sessionId = resumeUsable ? requestedResume : null
   let turnNo = sessionId ? 1 : 0
+  let userPromptNo = 0
+  let forceFullReminder = true
+  const selectRoomContext = createRoomContextSelector(roomContext)
   let child = null
   let aborted = false
   let ended = false
@@ -688,7 +693,16 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // Claude receives these through the Agent SDK's system-reminder path.
       // Codex is one-shot per turn, so give it the same lane identity and live
       // room awareness in a compact envelope before the person's text.
-      const prompt = buildCodexPrompt({ text: next.text, terminalRolePrompt, rolePrompt, roomContext, firstTurn: turnNo === 0 })
+      const fullReminder = usesFullThinkPoolReminder({ promptIndex: next.promptIndex, forceFull: next.forceFullReminder })
+      const prompt = buildCodexPrompt({
+        text: next.text,
+        terminalRolePrompt,
+        rolePrompt,
+        roomContext: () => selectRoomContext({ force: fullReminder }),
+        firstTurn: turnNo === 0,
+        promptIndex: next.promptIndex,
+        forceFullReminder: next.forceFullReminder,
+      })
       const usedAppServer = await runAppServer(prompt, next.options)
       if (!usedAppServer) await runExec(prompt, next.options)
       turnNo++
@@ -704,11 +718,22 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     get started() { return turnNo > 0 || turnActive },
     sendTurn(text, options = {}) {
       if (ended) return false
+      const promptIndex = userPromptNo++
+      const thisTurnForceFull = forceFullReminder
+      forceFullReminder = /^\s*\/(?:compact|reset|clear)\b/i.test(String(text || ''))
       if (!turnActive && turnNo === 0 && prepareCwd) {
         try { cwd = prepareCwd() || cwd } catch { /* keep original cwd */ }
       }
       if (turnActive && appServer && activeTurnId) {
-        const prompt = buildCodexPrompt({ text, terminalRolePrompt, rolePrompt, roomContext })
+        const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: thisTurnForceFull })
+        const prompt = buildCodexPrompt({
+          text,
+          terminalRolePrompt,
+          rolePrompt,
+          roomContext: () => selectRoomContext({ force: fullReminder }),
+          promptIndex,
+          forceFullReminder: thisTurnForceFull,
+        })
         const targetTurnId = activeTurnId
         // Serialize authored follow-ups: parallel RPCs can complete out of order.
         steerChain = steerChain.then(() => appServer.steer({ threadId: sessionId, turnId: targetTurnId, input: prompt, images: Array.isArray(options.images) ? options.images : [] }))
@@ -717,7 +742,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
             // pre-write failure. Timeout/close after write is delivery-uncertain;
             // replaying it as a new turn can execute the same instruction twice.
             if (error?.delivery === 'rejected' || error?.delivery === 'not_sent') {
-              queue.push({ text, options })
+              queue.push({ text, options, promptIndex, forceFullReminder: thisTurnForceFull })
               if (!turnActive && queue.length === 1) pump()
             } else {
               try { onEvent?.({ kind: 'error', message: 'Codex steering delivery is uncertain; the message was not replayed automatically.', recoverable: true }) } catch { /* noop */ }
@@ -725,7 +750,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
           })
         return true
       }
-      queue.push({ text, options })
+      queue.push({ text, options, promptIndex, forceFullReminder: thisTurnForceFull })
       // start the pump if idle
       if (queue.length === 1) pump()
       return true

package/cross-terminal.mjs

@@ -14,7 +14,9 @@ import { BLOCKED_REASON, projectLaneLifecycle } from './lane-lifecycle.mjs'
 // Bounds — the pull tool is self-limiting (the agent only calls it when it needs
 // to), but a runaway loop must still be capped (the cost-guard / C10 class).
 export const PEEK = {
-  defaultLines: 40,
+  // Keep the implicit pull concise for consumer turns. Agents can request more
+  // explicitly when a diagnosis genuinely needs deeper sibling history.
+  defaultLines: 20,
   maxLines: 200,
   perTurnCap: 10,     // read_terminal calls allowed per user turn (bridge resets it)
   lineCap: 200,       // per-line truncation

package/hermes-session.mjs

@@ -10,6 +10,7 @@ import { HERMES_PLAN_SAFE_MCP_TOOLS, HERMES_QUESTION_MCP_TOOL, hermesExactInvent
 import { startCodexMcpHttp } from './codex-mcp-http.mjs'
 import { autoAllow, classifyRisk } from './claude-session.mjs'
 import { crossPostNeedsCard } from './cross-terminal.mjs'
+import { buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
 
 export const HERMES_COMMAND = 'thinkpool'
 export const HERMES_ACP_PROTOCOL_VERSION = 1
@@ -34,6 +35,20 @@ const modelList = (state) => (state?.availableModels || []).map((item) => ({ val
 const mcpDescriptor = (url) => ({ type: 'http', name: 'thinkpool', url, headers: [] })
 const createAcpClient = (options) => new AcpClient(options)
 
+export function buildHermesPromptText({ text, firstTurn = false, terminalRolePrompt, rolePrompt, roomContext, promptIndex = 0, forceFullReminder = false } = {}) {
+  const context = typeof roomContext === 'function' ? roomContext() : roomContext
+  const inThinkPoolRoom = !!(terminalRolePrompt || rolePrompt || context)
+  const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: forceFullReminder })
+  const preamble = [
+    firstTurn || fullReminder ? terminalRolePrompt : '',
+    inThinkPoolRoom ? buildThinkPoolTurnGuidance({ text, promptIndex, forceFull: forceFullReminder }) : '',
+    firstTurn || fullReminder ? rolePrompt : '',
+    context,
+  ].filter(Boolean).join('\n\n')
+  const body = String(text ?? '')
+  return preamble ? `${preamble}\n\n${body}` : body
+}
+
 const permissionOutcome = (decision, options = []) => {
   if (decision === 'deny' || !decision) return { outcome: 'cancelled' }
   const preferred = decision === 'always'
@@ -65,6 +80,9 @@ export function startHermesSession({
   let started = false
   let crashed = false
   let firstTurn = true
+  let userPromptNo = 0
+  let forceFullReminder = true
+  const selectRoomContext = createRoomContextSelector(roomContext)
   let stderrTail = ''
   let promptChain = Promise.resolve()
   let activeTurnId = 0
@@ -379,21 +397,28 @@ export function startHermesSession({
     await boot()
   }
 
-  function promptBlocks(text, options = {}) {
+  function promptBlocks(text, options = {}, { promptIndex = 0, forceFull = false } = {}) {
     const rawText = String(text)
     // Hermes handles /steer, /queue, /compact and /reset only when the slash is
     // the first character of a pure-text prompt.
     if (/^\s*\//.test(rawText)) return [{ type: 'text', text: rawText }]
-    const context = typeof roomContext === 'function' ? roomContext() : roomContext
-    const preamble = firstTurn ? [terminalRolePrompt, rolePrompt, context].filter(Boolean).join('\n\n') : context
-    const blocks = [{ type: 'text', text: preamble ? `${preamble}\n\n${rawText}` : rawText }]
+    const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull })
+    const blocks = [{ type: 'text', text: buildHermesPromptText({
+      text: rawText,
+      firstTurn,
+      terminalRolePrompt,
+      rolePrompt,
+      roomContext: () => selectRoomContext({ force: fullReminder }),
+      promptIndex,
+      forceFullReminder: forceFull,
+    }) }]
     for (const imagePath of (Array.isArray(options.images) ? options.images : [])) {
       try { blocks.push(imageBlock(imagePath)) } catch { /* quoted host path remains in text */ }
     }
     return blocks
   }
 
-  async function runPrompt(text, options = {}, { steering = false, turnId = activeTurnId } = {}) {
+  async function runPrompt(text, options = {}, { steering = false, turnId = activeTurnId, promptIndex = 0, forceFull = false } = {}) {
     try { await boot() }
     catch (error) {
       if (abortedTurns.has(turnId)) return { stopReason: 'cancelled' }
@@ -405,7 +430,7 @@ export function startHermesSession({
     try {
       result = await client.request('session/prompt', {
         sessionId,
-        prompt: promptBlocks(body, options),
+        prompt: promptBlocks(body, options, { promptIndex, forceFull }),
         messageId: randomUUID(),
       }, 0)
     } catch (error) {
@@ -442,6 +467,9 @@ export function startHermesSession({
     get models() { return [] },
     sendTurn(text, options = {}) {
       if (ended) return false
+      const promptIndex = userPromptNo++
+      const thisTurnForceFull = forceFullReminder
+      forceFullReminder = /^\s*\/(?:compact|reset|clear)\b/i.test(String(text || ''))
       // A crash never replays work by itself. A later explicit turn is the
       // authority to launch a fresh ACP process and resume the same native
       // session id; this is the recovery path the old permanent latch blocked.
@@ -449,14 +477,14 @@ export function startHermesSession({
       // A busy prompt is a genuine ACP /steer call and may run concurrently.
       if (turnActive) {
         const turnId = activeTurnId
-        void runPrompt(text, options, { steering: true, turnId }).catch((error) => emit({ kind: 'error', message: `Hermes steering failed: ${error?.message || error}`, recoverable: true }))
+        void runPrompt(text, options, { steering: true, turnId, promptIndex, forceFull: thisTurnForceFull }).catch((error) => emit({ kind: 'error', message: `Hermes steering failed: ${error?.message || error}`, recoverable: true }))
         return true
       }
       const turnId = ++activeTurnId
       // Claim the turn synchronously, before the cold safety probe/import. The
       // room can now show Thinking + Stop for the whole accepted lifecycle.
       turnActive = true
-      promptChain = promptChain.then(() => runPrompt(text, options, { steering: false, turnId })).catch((error) => {
+      promptChain = promptChain.then(() => runPrompt(text, options, { steering: false, turnId, promptIndex, forceFull: thisTurnForceFull })).catch((error) => {
         turnActive = false
         emit({ kind: 'error', message: `Hermes turn failed: ${error?.message || error}`, recoverable: true })
       })

package/model-prices.mjs

@@ -0,0 +1,113 @@
+// Public model-price resolver for the bridge's usage ledger.
+// Runtime model catalogs tell us what ran, but not what a provider bills for
+// it. LiteLLM maintains a public catalog; cache its validated data locally and
+// persist the resolved rate beside each turn. A failed refresh never blocks a
+// turn or drops token accounting.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json'
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000
+const CACHE_MAX_BYTES = 4 * 1024 * 1024
+const cachePath = () => process.env.TP_MODEL_PRICE_CACHE || path.join(process.env.TP_PAIR_ROOT || path.join(os.homedir(), '.thinkpool-pair'), 'model-prices.json')
+
+// First-party runtimes remain priced while offline or before the catalog loads.
+const FALLBACKS = Object.freeze({
+  'gpt-5.6-sol': { input: 5, cached: 0.5, output: 30 },
+  'gpt-5.6-terra': { input: 2.5, cached: 0.25, output: 15 },
+  'gpt-5.6-luna': { input: 1, cached: 0.1, output: 6 },
+  'gpt-5.4': { input: 2.5, cached: 0.25, output: 15 },
+  'gpt-5.4-mini': { input: 0.75, cached: 0.075, output: 4.5 },
+  'gpt-5.4-nano': { input: 0.2, cached: 0.02, output: 1.25 },
+  'claude-opus-4-8': { input: 5, cached: 0.5, output: 25 },
+  'claude-fable-5': { input: 10, cached: 1, output: 50 },
+  'claude-sonnet-5': { input: 2, cached: 0.2, output: 10 },
+  'claude-haiku-4-5': { input: 1, cached: 0.1, output: 5 },
+  'glm-5.2': { input: 1.4, cached: 0.26, output: 4.4 },
+  'glm-4.6': { input: 0.6, cached: 0.11, output: 2.2 },
+})
+
+function cleanRate(raw) {
+  // Catalog rates are per token; normalize at the persistence boundary so a
+  // decimal like 0.0000001 does not become 0.09999999999999999 in Settings.
+  const perMillion = (value) => Math.round(Number(value) * 1_000_000 * 1_000_000) / 1_000_000
+  const input = perMillion(raw?.input_cost_per_token)
+  const output = perMillion(raw?.output_cost_per_token)
+  const cached = perMillion(raw?.cache_read_input_token_cost ?? raw?.cache_read_input_tokens_cost)
+  if (!Number.isFinite(input) || input < 0 || !Number.isFinite(output) || output < 0) return null
+  return { input, output, cached: Number.isFinite(cached) && cached >= 0 ? cached : null }
+}
+
+export function modelPriceKeys(model) {
+  const raw = String(model || '').trim()
+  if (!raw) return []
+  const withoutMarker = raw.replace(/\[[^\]]+\]/g, '')
+  const withoutPrefix = withoutMarker.replace(/^[^:/]+:/, '')
+  const tail = withoutPrefix.includes('/') ? withoutPrefix.slice(withoutPrefix.lastIndexOf('/') + 1) : withoutPrefix
+  return [...new Set([raw, withoutMarker, withoutPrefix, tail].filter(Boolean))]
+}
+
+function readCache() {
+  try {
+    const file = cachePath()
+    if ((Number(fs.statSync(file).size) || 0) > CACHE_MAX_BYTES) return null
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
+    return parsed?.models && typeof parsed.models === 'object' ? parsed : null
+  } catch { return null }
+}
+
+function writeCache(models) {
+  try {
+    const file = cachePath()
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, JSON.stringify({ fetchedAt: Date.now(), models }), { mode: 0o600 })
+  } catch { /* cache is opportunistic */ }
+}
+
+export function rateFromCatalog(model, models) {
+  for (const key of modelPriceKeys(model)) {
+    const rate = cleanRate(models?.[key])
+    if (rate) return rate
+  }
+  for (const key of modelPriceKeys(model)) {
+    const fallback = FALLBACKS[key.toLowerCase()]
+    if (fallback) return fallback
+  }
+  return null
+}
+
+export function createModelPriceResolver({ fetchImpl = globalThis.fetch } = {}) {
+  let cached = readCache()
+  let refresh = null
+  const refreshCatalog = async () => {
+    if (refresh) return refresh
+    refresh = (async () => {
+      let timer
+      try {
+        const controller = new AbortController()
+        timer = setTimeout(() => controller.abort(), 4_000)
+        const response = await fetchImpl(CATALOG_URL, { signal: controller.signal })
+        if (!response?.ok) return cached?.models || null
+        const models = await response.json()
+        if (!models || typeof models !== 'object') return cached?.models || null
+        cached = { fetchedAt: Date.now(), models }
+        writeCache(models)
+        return models
+      } catch { return cached?.models || null }
+      finally { clearTimeout(timer); refresh = null }
+    })()
+    return refresh
+  }
+  return async (model) => {
+    const current = rateFromCatalog(model, cached?.models)
+    if (current) return { ...current, source: cached?.models ? 'litellm-cache' : 'bridge-fallback' }
+    const stale = !cached || (Date.now() - Number(cached.fetchedAt || 0)) > CACHE_TTL_MS
+    const models = stale ? await refreshCatalog() : cached?.models
+    const rate = rateFromCatalog(model, models)
+    return rate ? { ...rate, source: models ? 'litellm' : 'bridge-fallback' } : null
+  }
+}
+
+export const priceForModel = createModelPriceResolver()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.257",
+  "version": "0.7.259",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -80,6 +80,7 @@
     "supabase-key.mjs",
     "provider.mjs",
     "providers.mjs",
+    "model-prices.mjs",
     "README.md"
   ],
   "scripts": {

package/thinkpool-room-prompt.mjs

@@ -1,21 +1,154 @@
 // Shared delivery contract for structured agents running inside ThinkPool Code.
-// Claude receives this as part of its system prompt; Codex receives it ahead of
-// the first human turn in each fresh native thread. Keep the runtime-specific
+// Claude receives this in its system prompt; all runtimes receive a compact
+// per-turn invariant plus the full contract at session start, after a reset, and
+// every fifth user prompt. Keep runtime-specific
 // orchestration rules in their own drivers — these are the cross-runtime truths
-// about where the people are and how finished work must reach them.
-export const THINKPOOL_DESIGN_DELIVERY_RULE = 'THINKPOOL DESIGN (mandatory for HTML): save the editable HTML source in the workspace, then use the $TP_MOCKUP_OUTBOX render helper so the room receives a Thinkpool Design card with both desktop (1440×900) and mobile (390×844) previews. When the requested Design surface is an existing product page or route, first build and capture the actual route at both viewports, then read its current source, styles, copy, fonts, and assets. Derive the editable Design artifact from that evidence and compare both artifact captures against the real route before delivery. Preserve the real page faithfully except for explicitly proposed edits—never hand-recreate it from memory, simplify it, replace it with generic mockup content, or label an approximation as the product. If a faithful editable artifact cannot be produced, surface the actual route captures and say that Design editing is unavailable for that surface. Never paste raw HTML into chat, send an .html file as the room deliverable, or substitute a bare URL or single screenshot for this card. A shareable browser URL may accompany the card, but never replaces it.'
+// about available capabilities and how finished work reaches the people.
+// One canonical intent → capability router for every structured runtime. Tool
+// schemas still carry their detailed argument contracts; this compact registry
+// tells a fresh agent WHEN ThinkPool expects each capability without requiring
+// the people in the room to know a tool name or summon word.
+export const THINKPOOL_CAPABILITY_ROUTES = Object.freeze([
+  Object.freeze({
+    id: 'room-awareness',
+    tools: Object.freeze(['read_terminal']),
+    rule: 'When the request depends on another lane, a sibling may overlap the work, or a person refers to another terminal, inspect it with read_terminal before acting.',
+  }),
+  Object.freeze({
+    id: 'cross-room-awareness',
+    tools: Object.freeze(['list_sessions', 'read_session']),
+    rule: 'When work depends on another ThinkPool room, use list_sessions then read_session instead of asking the people to relay host-side state.',
+  }),
+  Object.freeze({
+    id: 'visible-handoff',
+    tools: Object.freeze(['post_to_terminal', 'post_to_session']),
+    rule: 'When the people want a handoff, read the target first, then use post_to_terminal or post_to_session; let the room approval contract handle consent.',
+  }),
+  Object.freeze({
+    id: 'work-routing',
+    tools: Object.freeze(['spawn_terminal', 'open_main_terminal', 'close_terminal']),
+    rule: 'For genuinely decomposable work in a conductor-capable role, open visible worker slices with spawn_terminal, collect and verify them, then close_terminal. An explicitly requested separate Cascade/conductor uses open_main_terminal, never spawn_terminal.',
+  }),
+  Object.freeze({
+    id: 'room-question',
+    tools: Object.freeze(['request_user_input']),
+    rule: 'When a missing choice genuinely blocks useful progress, use request_user_input so the question is answerable in the room; otherwise make a safe in-scope assumption and continue.',
+  }),
+  Object.freeze({
+    id: 'visual-proof',
+    tools: Object.freeze(['preview_start', 'preview_capture', 'preview_inspect', 'preview_stop']),
+    rule: 'For built visual work, run the build, use preview_start, preview_capture at desktop and mobile, preview_inspect when rendered state matters, and preview_stop when finished. Surface PNG evidence only when no interactive source-backed Design card/popup is displayed.',
+  }),
+  Object.freeze({
+    id: 'external-research',
+    tools: Object.freeze(['research']),
+    rule: 'For current external facts that materially benefit from multi-source verification, offer the metered research lane and call research only after the people agree.',
+  }),
+  Object.freeze({
+    id: 'flow-completion',
+    tools: Object.freeze(['submit_flow_plan', 'mark_flow_done', 'submit_flow_review', 'read_review_file', 'run_review_check']),
+    rule: 'Managed Flow roles use only their exposed completion and immutable-review tools: submit_flow_plan, mark_flow_done, submit_flow_review, read_review_file, and run_review_check.',
+  }),
+])
+
+export const THINKPOOL_ROUTED_TOOLS = Object.freeze([
+  ...new Set(THINKPOOL_CAPABILITY_ROUTES.flatMap((route) => route.tools)),
+])
+
+export function renderThinkPoolCapabilityRoutes(routes = THINKPOOL_CAPABILITY_ROUTES) {
+  return routes.map((route) => `${route.id}: ${route.rule}`).join(' ')
+}
+
+export const THINKPOOL_AGENT_CONTRACT = [
+  'THINKPOOL-FIRST OPERATING CONTRACT (authoritative): ThinkPool room capabilities are your normal operating surface, not optional enrichment. Before acting on every request, infer which exposed ThinkPool capabilities materially improve room visibility, coordination, delivery, or verification and use them without waiting for the people to know a tool name, magic word, or workflow.',
+  `DEFAULT ROUTING: ${renderThinkPoolCapabilityRoutes()}`,
+  'DEFAULT DOES NOT MEAN GRATUITOUS: use only capabilities exposed to your current role and only when relevant. Honor explicit steering such as single-lane, no research, do not contact another room, or do not use a named ThinkPool feature. Metered and side-effecting capabilities still obey their stated offer, approval, and consent contracts.',
+].join(' ')
+
+export const THINKPOOL_DESIGN_INTERACTION_RULE = 'DESIGN EDITING MODEL: the user edits through a source-backed mockup card\'s Work on design action, which opens the fullscreen mockup/Design popup; never ask them to locate or edit HTML. Popup edits are optimistic drafts only. Apply sends the bounded batch to the producing lane, that lane edits the canonical authored HTML, and a successful desktop+mobile render publishes the next verified revision back into the popup. Never call an in-popup draft saved or live. A preview_capture card is visual evidence, not an editable Design artifact.'
+
+export const THINKPOOL_DESIGN_DELIVERY_RULE = `THINKPOOL DESIGN (mandatory for authored HTML): save the editable HTML source in the workspace, then use the $TP_MOCKUP_OUTBOX render helper so the room receives a source-backed Thinkpool Design card with both desktop (1440×900) and mobile (390×844) previews. The interactive Design card/popup is the visible result: the renders remain required verification inputs, but when that card is displayed do not also surface duplicate inline PNGs. Surface desktop/mobile PNGs only when no interactive source-backed Design artifact is available. ${THINKPOOL_DESIGN_INTERACTION_RULE} When the requested Design surface is an existing product page or route, first build and capture the actual route at both viewports, then read its current source, styles, copy, fonts, and assets. Derive the editable Design artifact from that evidence and compare both artifact captures against the real route before delivery. Preserve the real page faithfully except for explicitly proposed edits—never hand-recreate it from memory, simplify it, replace it with generic mockup content, or label an approximation as the product. If a faithful editable artifact cannot be produced, surface the actual route captures and say that Design editing is unavailable for that surface. Never paste raw HTML into chat, send an .html file as the room deliverable, or substitute a bare URL or single screenshot for this card. A shareable browser URL may accompany the card, but never replaces it.`
 
 export const THINKPOOL_REMOTE_DELIVERY_RULES = Object.freeze([
   'REMOTE USER (authoritative default for ThinkPool Code rooms): unless a person explicitly says they are at the host machine, assume everyone driving this room is remote — possibly on a phone — with no terminal and no access to the host filesystem. Never ask them to run a local command, open a local file, or "go check" something on the machine. Anything host-side, you run yourself and show the result in the room. Only suggest actions they can actually do from the room UI or a browser.',
   'LINKS & ARTIFACTS: a local filesystem path, file:// URL, localhost/127.0.0.1 address, or host-only preview is useless to a remote room. Every link you surface must be reachable by the people in the room.',
   'Whenever you produce HTML or shareable markup — a demo, mockup, preview, report, or page — publish it to a browser-renderable GitHub-shareable URL, normally GitHub Pages (or an equivalent URL that actually renders; raw.githubusercontent.com serves HTML as plain text). Give the room that shareable URL in addition to the Thinkpool Design card, never instead of it and never only as a local path. If you cannot publish it, say so instead of falling back to a host-only path.',
-  'SHOW VISUAL WORK: whenever you build, change, or fix anything visual — UI, page, HTML artifact, chart, diagram, or rendered result — capture a PNG and surface the image in your turn so it appears inline in the room; the room auto-uploads surfaced images. Prefer showing the result over describing it.',
+  'SHOW VISUAL WORK: whenever you build, change, or fix anything visual, show the result in the room. A source-backed Thinkpool Design card/popup is already the interactive visible result, so do not additionally surface duplicate PNGs. When no interactive Design artifact is available, capture and surface desktop/mobile PNG evidence inline.',
   'BRIDGE PREVIEWS: for a built web UI, use preview_start (default root: dist), then preview_capture for exact desktop 1440x900 and mobile 390x844 PNGs, and preview_inspect when DOM text or selector geometry helps. Run the project build first and stop the preview server with preview_stop when done.',
   THINKPOOL_DESIGN_DELIVERY_RULE,
   'VERIFY BEFORE CLAIMING: run or serve what you changed, observe it, and show the evidence in the room — the PNG, passing test output, or real response. If something could not be verified, say exactly what remains unverified.',
 ])
 
-// One authoritative terminal-identity preamble for BOTH structured runtimes.
+// Compact enough to repeat adjacent to every normal user turn. The full remote
+// delivery contract is still installed at session boot where the runtime offers
+// a durable system channel; this reminder keeps the high-drift decisions salient
+// after long tool runs, resumes, and compaction without duplicating the manual.
+export const THINKPOOL_RUNTIME_TURN_REMINDER = [
+  THINKPOOL_AGENT_CONTRACT,
+  'REMOTE DELIVERY: assume the people are remote unless they explicitly say otherwise. Run host-side work yourself; never hand them a local path, file:// or localhost URL, or ask them to use the host terminal. Surface reachable links and inline evidence in the room.',
+  'VISUAL DELIVERY: build first and verify exact desktop and mobile renders. If a source-backed Thinkpool Design card/popup is displayed, do not separately surface its PNGs; if no interactive Design artifact is available, surface the desktop/mobile PNG evidence inline. Stop bridge previews when finished.',
+  THINKPOOL_DESIGN_INTERACTION_RULE,
+  'VERIFY BEFORE CLAIMING: run or serve what changed and show the real response, passing output, or rendered evidence; state exactly what remains unverified.',
+].join(' ')
+
+// Repeating the complete router on every turn made a durable operating contract
+// compete with the user's actual request. The model still gets a small invariant
+// on ordinary turns, while periodic and recovery turns refresh the complete map.
+export const THINKPOOL_FULL_REMINDER_INTERVAL = 5
+
+export const THINKPOOL_RUNTIME_SALIENCE_REMINDER = 'THINKPOOL: prefer relevant exposed room tools unless the user explicitly opts out; obey the durable terminal role and consent rules. Assume the people are remote, do host work yourself, and deliver reachable verified results.'
+
+const ROUTE_TRIGGERS = Object.freeze({
+  'room-awareness': /\b(other|another|sibling|peer)\s+(lane|terminal)|\bread_terminal\b/i,
+  'cross-room-awareness': /\b(other|another|cross[- ]?room|cross[- ]?session)\s+(room|session)|\b(list_sessions|read_session)\b/i,
+  'visible-handoff': /\b(hand[ -]?off|tell|send|post)\b.{0,40}\b(lane|terminal|room|session|agent)\b|\b(post_to_terminal|post_to_session)\b/i,
+  'work-routing': /\b(parallel|delegate|worker|sub[- ]?terminal|conductor|cascade|spawn_terminal|open_main_terminal|close_terminal)\b/i,
+  'room-question': /\b(request_user_input)\b/i,
+  'visual-proof': /\b(ui|ux|visual|design|frontend|html|css|page|route|mockup|screenshot|responsive|desktop|mobile|preview)\b/i,
+  'external-research': /\b(research|latest|current|look up|browse|web search|online source|verify online)\b/i,
+  'flow-completion': /\b(flow|submit_flow_plan|mark_flow_done|submit_flow_review|read_review_file|run_review_check)\b/i,
+})
+
+const DESIGN_ROUTE_REMINDER = 'DESIGN ROUTE: authored HTML must produce a source-backed Thinkpool Design card/popup with verified desktop and mobile renders. The popup is where users edit; do not duplicate its PNGs inline. Use inline PNG evidence only when no interactive Design artifact is available.'
+
+export function usesFullThinkPoolReminder({ promptIndex = 0, forceFull = false } = {}) {
+  const index = Math.max(0, Number.isFinite(Number(promptIndex)) ? Math.trunc(Number(promptIndex)) : 0)
+  return !!forceFull || index % THINKPOOL_FULL_REMINDER_INTERVAL === 0
+}
+
+export function buildThinkPoolTurnGuidance({ text = '', promptIndex = 0, forceFull = false } = {}) {
+  if (usesFullThinkPoolReminder({ promptIndex, forceFull })) return THINKPOOL_RUNTIME_TURN_REMINDER
+  const body = String(text || '')
+  const routed = THINKPOOL_CAPABILITY_ROUTES
+    .filter((route) => ROUTE_TRIGGERS[route.id]?.test(body))
+    .map((route) => `${route.id}: ${route.rule}`)
+  if (ROUTE_TRIGGERS['visual-proof'].test(body)) routed.push(DESIGN_ROUTE_REMINDER)
+  return [THINKPOOL_RUNTIME_SALIENCE_REMINDER, ...routed].join(' ')
+}
+
+export function roomContextFingerprint(value) {
+  return String(value || '')
+    // Relative ages change while the underlying lane state does not. Ignore
+    // that clock churn when deciding whether a room snapshot is new information.
+    .replace(/ · (?:\d+[smhd] ago|no activity)(?=\s+—)/g, ' · age')
+    .trim()
+}
+
+export function createRoomContextSelector(roomContext) {
+  let previousFingerprint = null
+  return ({ force = false } = {}) => {
+    let context = null
+    try { context = typeof roomContext === 'function' ? roomContext() : roomContext } catch { context = null }
+    const value = String(context || '').trim()
+    if (!value) return ''
+    const fingerprint = roomContextFingerprint(value)
+    const changed = fingerprint !== previousFingerprint
+    previousFingerprint = fingerprint
+    return force || changed ? value : ''
+  }
+}
+
+// One authoritative terminal-identity preamble for every structured runtime.
 // The bridge derives this from durable structural metadata — never from the text
 // of the task handed to the model. That distinction matters because a spawned
 // lane can be asked to "act as conductor", but it is still a sub-terminal owned