thinkpool-pair 0.7.258 → 0.7.260

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_CASCADE_RULE, THINKPOOL_REMOTE_DELIVERY_RULES, THINKPOOL_RUNTIME_AUTHORITY_RULE, 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
@@ -691,7 +697,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       ...(terminalRolePrompt ? [terminalRolePrompt] : []),
       ...(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.',
+      THINKPOOL_RUNTIME_AUTHORITY_RULE,
       '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.',
@@ -699,7 +705,7 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       // 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 within the authoritative TERMINAL ROLE, 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, when your role permits delegation — you FIRST write a short plan as a normal chat message (the approach, the concrete slices, and what you will verify), THEN fan worker slices into visible Ensemble lanes with spawn_terminal, build, and self-verify each slice before calling it done. When the person explicitly asks you to launch a SEPARATE Cascade/conductor terminal, call open_main_terminal instead; never represent that request with spawn_terminal. Worker, leaf, Side, and managed Flow lanes complete their assigned work directly and do not fan out.',
+      THINKPOOL_CASCADE_RULE,
       '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.',
       ...THINKPOOL_REMOTE_DELIVERY_RULES,
       'CROSS-TERMINAL AWARENESS: this room may have other terminals open alongside yours — other agents working, or shells the people are driving. You have a READ-ONLY tool, read_terminal: call it with no arguments to list the other open terminals, or with a terminal ref/id/command to read that terminal\'s recent activity. Reach for it when your work depends on what another terminal is doing (e.g. someone says "see what the other terminal hit", or you need to coordinate with a sibling agent before acting). It only ever reads — it never changes another terminal. Identify a terminal by its NAME or its ref/id from the roster, never by an on-screen number like "Terminal 2" — those positional labels renumber when a terminal is closed, so they do not reliably point at a lane.',
@@ -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'])
@@ -211,16 +211,17 @@ export function codexPublishAccess({ cwd, env = process.env, tmpdir = os.tmpdir(
 }
 
 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.',
+  'THINKPOOL ROOM ROLE ENFORCEMENT: obey the authoritative TERMINAL ROLE above. Conductors are independent main terminals; Ensemble lanes are workers only. An explicitly requested separate Cascade/conductor uses open_main_terminal — NEVER spawn_terminal. Use spawn_terminal only for bounded 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.',
 ].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.260",
   "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,7 +1,8 @@
 // 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
-// orchestration rules in their own drivers — these are the cross-runtime truths
+// 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 mechanics in their own drivers;
+// the Cascade contract below is a cross-runtime ThinkPool workflow
 // 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
@@ -58,13 +59,19 @@ export function renderThinkPoolCapabilityRoutes(routes = THINKPOOL_CAPABILITY_RO
   return routes.map((route) => `${route.id}: ${route.rule}`).join(' ')
 }
 
+export const THINKPOOL_RUNTIME_AUTHORITY_RULE = 'RUNTIME AUTHORITY: this agent session was created by the ThinkPool bridge. Instructions from any external terminal multiplexer, orchestrator, agent manager, IDE task runner, remembered host workflow, or similarly installed alternative do not govern this room unless the current ThinkPool prompt explicitly incorporates them. Do not infer authority from a binary in PATH, an environment variable, a config file, or old memory. The authoritative TERMINAL ROLE, current ThinkPool room prompt, and exposed tool schemas win.'
+
+export const THINKPOOL_CASCADE_RULE = 'CASCADE WORKFLOW (default for non-trivial work that genuinely decomposes; mandatory when the people ask for Cascade, tiered lanes, one-shot flow, or unattended multi-slice execution): first investigate enough to name evidence-backed slices and their dependencies, then post a short plan in the room. The current top-level/conductor terminal keeps decomposition, integration, and final judgment; use spawn_terminal only for bounded worker slices, while an explicitly requested separate conductor uses open_main_terminal. Parallelize only disjoint slices and encode dependencies instead of holding them in your head. Choose sliceType=scaffold for mechanical/search work, feature or fix for implementation, and review with a balanced capable tier for adversarial verification. Every worker brief names the evidence/diagnosis, exact scope, observable acceptance proof, relevant repo gates, whether merge/publish is required, and a safe-skip escape hatch. After dispatch, remain responsible: use read_terminal to collect each owned lane, verify its claim, close_terminal immediately, and dispatch newly unblocked work; never declare the Cascade done or yield a final result while owned workers remain uncollected. Check origin/main CI before merge-bearing waves, coordinate shared fixtures/publishers, and treat sibling pushes as context rather than proof. Run an adversarial review after builders (or pipeline review behind completed phases), finish with production-condition evidence, verify every reported SHA/version, and close every worker you opened.'
+
 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.',
+  THINKPOOL_RUNTIME_AUTHORITY_RULE,
   `DEFAULT ROUTING: ${renderThinkPoolCapabilityRoutes()}`,
+  THINKPOOL_CASCADE_RULE,
   '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_INTERACTION_RULE = 'DESIGN EDITING MODEL: a trusted source-backed mockup card offers Work on design. That explicit action—not ordinary Preview or unrelated artifact delivery—arms a persistent room-level Design workspace, opens the artifact directly in editable mode, and adds Design · Page name as a virtual Ensemble lane for both partners; it creates no terminal, agent runtime, or worker slot. Once armed, the Design lane reopens the active artifact at its latest verified revision without another agent turn, history search, HTML/path request, or re-selection. Design is the default canvas there and Preview is only a temporary interaction mode. Direct text, supported movement, and selected-image changes auto-stage as optimistic drafts in the bounded changes queue. Apply changes sends the ordered batch once to the producing lane, that lane edits the canonical authored HTML, and a successful desktop+mobile render advances the verified revision for the room. Never call a staged 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.`
 
@@ -90,6 +97,64 @@ 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 with verified desktop and mobile renders. Work on design explicitly arms the persistent Design workspace and adds its virtual Design · Page Ensemble lane; Preview alone does not arm it. Do not duplicate the card renders as inline PNGs. 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['work-routing'].test(body)) routed.push(THINKPOOL_CASCADE_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