thinkpool-pair 0.7.258 → 0.7.259

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_REMOTE_DELIVERY_RULES, THINKPOOL_RUNTIME_TURN_REMINDER } 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,18 +183,19 @@ 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. The shared capability router deliberately
-// costs ~900 tokens/turn so a fresh user never needs to know the room's tool names.
-// A live "ROOM NOW" tail (sibling lanes + active worktrees) is appended per turn by
-// the bridge's roomContext callback — see roomReminder() inside startClaudeSession.
+// 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.',
   THINKPOOL_RUNTIME_TURN_REMINDER,
@@ -210,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
@@ -226,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
@@ -849,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
@@ -970,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
             }
@@ -1144,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' })
     }
   }
@@ -1155,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
@@ -1168,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, THINKPOOL_RUNTIME_TURN_REMINDER } 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,13 +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,
-    THINKPOOL_RUNTIME_TURN_REMINDER,
-    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 ?? '')
@@ -396,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
@@ -689,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++
@@ -705,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 : [] }))
@@ -718,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 */ }
@@ -726,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,7 +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 { THINKPOOL_RUNTIME_TURN_REMINDER } from './thinkpool-room-prompt.mjs'
+import { buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
 
 export const HERMES_COMMAND = 'thinkpool'
 export const HERMES_ACP_PROTOCOL_VERSION = 1
@@ -35,13 +35,14 @@ 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 } = {}) {
+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 ? terminalRolePrompt : '',
-    inThinkPoolRoom ? THINKPOOL_RUNTIME_TURN_REMINDER : '',
-    firstTurn ? rolePrompt : '',
+    firstTurn || fullReminder ? terminalRolePrompt : '',
+    inThinkPoolRoom ? buildThinkPoolTurnGuidance({ text, promptIndex, forceFull: forceFullReminder }) : '',
+    firstTurn || fullReminder ? rolePrompt : '',
     context,
   ].filter(Boolean).join('\n\n')
   const body = String(text ?? '')
@@ -79,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
@@ -393,19 +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 blocks = [{ type: 'text', text: buildHermesPromptText({ text: rawText, firstTurn, terminalRolePrompt, rolePrompt, roomContext }) }]
+    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' }
@@ -417,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) {
@@ -454,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.
@@ -461,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.258",
+  "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": {

package/thinkpool-room-prompt.mjs

@@ -1,6 +1,7 @@
 // Shared delivery contract for structured agents running inside ThinkPool Code.
-// Claude receives this in its system prompt plus a per-turn reminder; Codex and
-// Hermes receive it adjacent to normal room turns. Keep 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 available capabilities and how finished work reaches the people.
 // One canonical intent → capability router for every structured runtime. Tool
@@ -90,6 +91,63 @@ export const THINKPOOL_RUNTIME_TURN_REMINDER = [
   '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