thinkpool-pair 0.7.336 → 0.7.338

package/README.md

@@ -17,6 +17,11 @@ not require an inbound port, tunnel, or public IP.
   - Hermes
 - The provider login or API credentials required by that runtime
 
+**The bridge does not include a coding agent.** Claude Code, Codex, or Hermes
+must already be installed and runnable on the bridge machine. BYOK only supplies
+model-provider credentials to an installed runtime; a provider key does not
+install or replace the agent itself.
+
 ## Start the bridge
 
 Run the launcher from the project directory the agents should use:
@@ -60,6 +65,35 @@ when that trade-off is intentional:
 npx thinkpool-pair@latest install-service --auto-update
 ```
 
+### Optional: keep the bridge computer awake
+
+The launcher’s **Settings → Keep computer awake** option prevents system sleep
+while the bridge is running. The same choice is available from the CLI:
+
+```bash
+# Foreground, for this run only
+npx thinkpool-pair@latest --keep-awake
+
+# Persist the choice and install the background service
+npx thinkpool-pair@latest install-service --keep-awake
+
+# Persistently turn it back off while reinstalling/updating the service
+npx thinkpool-pair@latest install-service --no-keep-awake
+```
+
+**Important:** keep-awake can substantially increase battery use. It prevents
+the computer from sleeping; it does **not** keep the display illuminated.
+Display dimming, screen locking, and display sleep continue normally. Closing a
+laptop lid may still put it to sleep depending on the operating system and its
+power settings. On some Linux systems the sleep inhibitor can also block an
+explicit suspend request while the bridge runs.
+
+The implementation is process-bound and releases automatically when the bridge
+stops: macOS uses `caffeinate -i`, Linux uses `systemd-inhibit --what=sleep`,
+and Windows uses a system-only power request without `ES_DISPLAY_REQUIRED`.
+If the platform helper is unavailable, the bridge warns and continues without
+keep-awake rather than failing startup.
+
 Service implementation by platform:
 
 - macOS: LaunchAgent
@@ -231,9 +265,10 @@ log before reinstalling; repeated installation can hide the original failure.
 
 ### No runtimes are available
 
-Install/sign in to Claude, Codex, or Hermes on the host, then restart the
-launcher. Runtime availability is detected from the host; the web room cannot
-install a missing CLI for you.
+Install and configure Claude Code, Codex, or Hermes on the host, then restart
+the launcher. Runtime availability is detected from the host; the web room
+cannot install a missing CLI. BYOK configures provider credentials only and
+does not replace the local agent runtime.
 
 ### A custom model fails immediately
 

package/bridge.mjs

@@ -68,6 +68,7 @@ import { hermesUserInputResponse } from './question-response.mjs'
 import { hostMemoryAdmission } from './host-memory.mjs'
 import { queueAbortBarrier, waitForAbortBarrier } from './abort-turn-barrier.mjs'
 import { PAIR_CLI, pairCli } from './command-guidance.mjs'
+import { explicitKeepAwakeChoice, keepAwakeEnabled, saveKeepAwakePreference, startKeepAwake } from './keep-awake.mjs'
 
 const STRUCTURED_MODES = new Set(['default', 'acceptEdits', 'plan', 'review', 'bypassPermissions'])
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, FLOW_CODEX_CONDUCTOR_PROMPT, FLOW_CODEX_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
@@ -236,6 +237,17 @@ const pickAgent = (installed) => new Promise((resolve) => {
 
 const argv = process.argv.slice(2)
 
+// CLI service flags also set the durable machine preference. Service updates read
+// the same preference, so a later pinned-runtime update cannot silently turn the
+// requested power behavior off. Foreground `--keep-awake` remains a one-run override.
+if (argv[0] === 'install-service' || argv[0] === 'restart-service') {
+  const choice = explicitKeepAwakeChoice(argv)
+  if (choice !== null && !saveKeepAwakePreference(choice)) {
+    process.stderr.write('  ⚠ could not save the keep-awake setting; service left unchanged.\n')
+    process.exit(1)
+  }
+}
+
 if (argv[0] === 'privacy-report') {
   const { runPrivacyReport } = await import('./privacy-report.mjs')
   runPrivacyReport()
@@ -362,7 +374,10 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
       const child = spawn(process.execPath, args, { stdio: 'inherit' })
       child.on('exit', (code) => process.exit(code == null ? 0 : code))
     }),
-    serveAccountForeground: async () => { const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON) },
+    serveAccountForeground: async () => {
+      startKeepAwake({ enabled: keepAwakeEnabled([]) })
+      const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON)
+    },
     // Confirmed installs/updates continue in the exact runtime just proven live. This
     // keeps the person inside the npx menu without letting the stale installer claim
     // its in-memory VERSION matches the newly installed managed service.
@@ -407,6 +422,17 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
         : ['anthropic']
       await runProvider(args)
     },
+    setKeepAwake: async ({ enabled }) => {
+      if (!saveKeepAwakePreference(enabled)) {
+        io.print('\n  ⚠ could not save the keep-awake setting; nothing was changed.')
+        return false
+      }
+      // A managed Unix service must restart to acquire/release its process-bound
+      // inhibitor. Windows' Startup entry has no daemon control; restartService
+      // prints the honest close-and-relaunch instruction instead.
+      if (svc.isServiceInstalled(null)) svc.restartService(null)
+      return true
+    },
     setupHermes: async ({ mode }) => {
       const { setupHermesRuntime } = await import('./hermes-setup.mjs')
       const result = setupHermesRuntime({ mode })
@@ -461,7 +487,10 @@ function checkSdkCompat() {
   }
 }
 
-if (!argv[0] || argv[0].startsWith('-')) { const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON) }
+if (!argv[0] || argv[0].startsWith('-')) {
+  startKeepAwake({ enabled: keepAwakeEnabled(argv) })
+  const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON)
+}
 
 const room = (argv[0] || '').toUpperCase().trim()
 if (!room) { console.error(`usage: ${pairCli('<ROOM>', '[--headless]', '[--continue|--fresh]', '[-- <command…>]')}   |   ${PAIR_CLI}  (account mode)`); process.exit(1) }
@@ -533,6 +562,11 @@ if (_superOwn.includes('--supervise') || _superOwn.includes('--keep-alive')) {
   if (shouldHoldMachineLock(process.env)) process.on('exit', () => { try { releaseMachineLock() } catch { /* noop */ } })
 }
 
+// Direct single-room mode owns one inhibitor in its actual serving process. Account
+// supervisor children deliberately skip this (the account parent already owns it),
+// and the --supervise wrapper above never reaches this line—only its child does.
+startKeepAwake({ enabled: keepAwakeEnabled(argv) })
+
 const headless = argv.includes('--headless')
 // Account-mode children pass --auto=<agent> so a served session opens a live
 // terminal automatically (headless, no TTY/picker) instead of an empty room.
@@ -2746,11 +2780,11 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       // conductor mains, spawned workers, Side lanes, and Flow lanes cannot use it.
       ...(canOpenMainConductor ? [tool(
         'open_main_terminal',
-        'Open a separate independent MAIN terminal to conduct a Cascade on any supported runtime: Claude (including a connected Anthropic-compatible BYOK provider), Codex, or Hermes. Use this whenever a person explicitly asks to open, launch, start, or spawn a new Cascade/conductor terminal. This is the top-level room lifecycle, NOT Ensemble dispatch: the new terminal has no spawnedBy owner and appears as a main terminal. Never substitute spawn_terminal, which creates worker sub-terminals only. Give the conductor its full initial task; it will use spawn_terminal for its workers.',
+        'Open a separate independent MAIN terminal on any supported runtime: Claude (including a connected Anthropic-compatible BYOK provider), Codex, or Hermes. Use this whenever a person asks to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal—even for ordinary work or a handoff and even without the words Cascade or conductor. If the wording includes new or separate terminal, main-terminal routing wins. This is the top-level room lifecycle, NOT Ensemble dispatch: the new terminal has no spawnedBy owner and appears as a main terminal. Never substitute spawn_terminal, which creates worker sub-terminals only. Give the main terminal its full initial task; it can use spawn_terminal for bounded workers.',
         {
           name: z.string().max(80).optional().describe('short label for the main conductor, e.g. "Cascade · Multi-device chaos"'),
-          task: z.string().min(1).describe('complete initial Cascade brief for the conductor'),
-          model: z.string().optional().describe('optional conductor model, e.g. opus / gpt-5.6-sol / nous:z-ai/glm-5.2'),
+          task: z.string().min(1).describe('complete initial brief for the independent main terminal'),
+          model: z.string().optional().describe('optional main-terminal model, e.g. opus / gpt-5.6-sol / nous:z-ai/glm-5.2'),
           runtime: z.enum(['claude', 'codex', 'hermes']).optional().describe('agent runtime; every top-level terminal can open every supported runtime, defaulting to its own'),
           provider: z.string().optional().describe(`optional registered Claude-compatible provider name or id; omit for built-in Anthropic${registeredProviderChoices() ? `. Available now: ${registeredProviderChoices()}` : ''}`),
           mode: z.enum(['default', 'acceptEdits', 'bypassPermissions', 'plan']).optional().describe('permission mode; defaults to inheriting this main terminal, except plan falls back to default'),
@@ -4411,21 +4445,24 @@ channel
           ctlLine('nothing to compact — context unchanged')
           return
         }
+        const preTokens = s.lastUsage?.ctx?.used || null
+        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
         const nativeCompacted = await s.session.compactContext?.()
         if (nativeCompacted) {
-          const ce = { kind: 'compaction', trigger: 'manual', preTokens: s.lastUsage?.ctx?.used || null, by: payload.by, native: true }
+          const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by, native: true }
           pushLog(s, ce)
           bcast('code-event', { term: payload.term, evt: ce })
-          s.lastUsage = null
+          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
           s.flush?.()
           return
         }
         if (s.session.clearContext?.() === false) {
+          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
           ctlLine('Codex context compaction unavailable right now')
           return
         }
         s.pendingRecap = recap
-        const ce = { kind: 'compaction', trigger: 'manual', preTokens: s.lastUsage?.ctx?.used || null, by: payload.by }
+        const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by }
         pushLog(s, ce)
         bcast('code-event', { term: payload.term, evt: ce })
         // The new native thread has only the bounded recap queued for the next
@@ -4437,6 +4474,7 @@ channel
           s.lastUsage = usage
           bcast('code-event', { term: payload.term, evt: usage })
         }
+        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
         s.flush?.()
         return
       }

package/claude-session.mjs

@@ -239,9 +239,9 @@ const MODES = new Set(['default', 'acceptEdits', 'plan', 'bypassPermissions'])
 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,
-  '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.',
+  'TERMINAL HIERARCHY: obey your authoritative TERMINAL ROLE. A person-authored request to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal uses open_main_terminal — NEVER spawn_terminal — even for ordinary work or a handoff. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. If open_main_terminal is unavailable, say so; never substitute an Ensemble child. Leaf, worker, Side, and managed Flow lanes work directly. Never use built-in invisible Task/Agent subagents or hijack a busy sibling.',
   '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.',
+  '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 person-requested new or separate terminal uses open_main_terminal. Never plan-mode/ExitPlanMode; plans live in chat and lanes in the existing list.',
 ].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, admitStart = null }) {
@@ -749,10 +749,10 @@ export function startClaudeSession({ cwd, model, effort: initialEffort = 'high',
       ...THINKPOOL_REMOTE_DELIVERY_RULES,
       'CROSS-TERMINAL AWARENESS: ROOM NOW is the default roster and already satisfies the room check when it has enough detail. Do not repeat it with a no-argument read_terminal call unless it is missing or truncated. Use a targeted read_terminal call only when the current task depends on a specific lane’s detailed activity; never poll. Identify a terminal by its NAME or stable ref/id, never by an on-screen number like "Terminal 2" — positional labels renumber when a terminal is closed. The tool is read-only and its optional roster lookup is budgeted separately from bounded targeted transcript reads.',
       'CROSS-TERMINAL HAND-OFF: you also have post_to_terminal(terminal, text) to send a message or task to ANOTHER AGENT terminal in this room (not a plain shell). Use it sparingly and only when the people clearly want the lanes to coordinate — e.g. "tell the backend terminal the API is ready", or to hand a sibling agent a concrete task. Every post requires a person in the room to approve a card before it is delivered, and an agent that was itself reached via a cross-post cannot post onward — so do not rely on it for chit-chat or loops. Prefer read_terminal to understand a sibling before you ever post to it.',
-      'TERMINAL CREATION CONTRACT: conductors and workers use different tools. When a person explicitly asks to open, launch, start, or spawn a separate Cascade/conductor terminal, use open_main_terminal(name?, task?, model?) — it creates an independent MAIN terminal with no Ensemble owner. Never use spawn_terminal for that request, and if open_main_terminal is unavailable say so instead of substituting. Use spawn_terminal(name?, task?, model?, sliceType?) only for bounded WORKER SUB-TERMINALS when your authoritative role permits delegation. Workers never receive the creation tools and never conduct. Do not dump work into busy siblings. Spawned workers are always autonomous in bypassPermissions and never ask the room for an approval card; the bridge still enforces room caps, hop limits, the kill-switch, and isolated linked worktrees. Wait for ROOM NOW or a completion signal instead of polling; after a worker finishes, collect it with one targeted read_terminal call and close_terminal immediately. Main conductors are independent terminals, keep their requested permission mode, and are not owned/closed through Ensemble.',
+      'TERMINAL CREATION CONTRACT: main terminals and workers use different tools. A person-authored request to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal uses open_main_terminal(name?, task?, model?) — even for ordinary work or a handoff and even without the words Cascade or conductor. If the wording includes new or separate terminal, main-terminal routing wins. Never use spawn_terminal for that request, and if open_main_terminal is unavailable say so instead of substituting. Use spawn_terminal(name?, task?, model?, sliceType?) only for agent-decided bounded WORKER SUB-TERMINALS or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. Workers never receive the creation tools and never conduct. Do not dump work into busy siblings. Spawned workers are always autonomous in bypassPermissions and never ask the room for an approval card; the bridge still enforces room caps, hop limits, the kill-switch, and isolated linked worktrees. Wait for ROOM NOW or a completion signal instead of polling; after a worker finishes, collect it with one targeted read_terminal call and close_terminal immediately. Main terminals are independent, keep their requested permission mode, and are not owned/closed through Ensemble.',
       'CROSS-SESSION AWARENESS: the Ensemble reaches across your SESSIONS, not just the terminals in this room. list_sessions() lists your OTHER ThinkPool Code rooms — both your own rooms running on this machine AND your partner\'s rooms in the same pair, reachable over the per-pair bus (a room on the partner\'s machine shows its host). read_session(session, terminal?) reads recent activity inside one (omit `terminal` to list that room\'s terminals, or pass a ref/name to read that lane). Both are READ-ONLY — they never change another session, and they reach ONLY your own rooms and rooms you share with your partner, never a stranger\'s. Reach for them when work spans rooms — "what\'s the other project up to", "pick up where the other session left off", or to check a long-running task elsewhere before you act here.',
       'CROSS-SESSION HAND-OFF: post_to_session(session, text, terminal?) sends a task or message to an agent in ANOTHER of your rooms — your own, or your partner\'s over the pair bus. Use it sparingly and only when the people clearly want the rooms to coordinate — e.g. hand the API room\'s agent a concrete follow-up once the frontend is ready. It is dual-consent: a person in YOUR room approves sending, and a person in the TARGET room approves receiving, before anything is delivered — so never rely on it for chit-chat or loops, and an agent that was itself reached via a cross-room post cannot post onward to a third room. It spends real model tokens in the other room (maybe on the other person\'s machine), so prefer read_session to understand a room before you ever post into it, and only post one concrete hand-off at a time. Outbound list/read/post tools need the ThinkPool account bridge; a standalone owner room can still receive a paired hand-off directly and will always raise its own approval card before delivery.',
-      'SUBAGENT POLICY: in this room, a main conductor delegates worker slices through visible spawn_terminal Ensemble lanes. A requested separate conductor is created with open_main_terminal, never Ensemble. Worker, leaf, Side, and managed Flow lanes do their assigned work directly. Do NOT reach for built-in Task/Agent subagents: an in-process subagent is invisible to the room, cannot be peered at or steered, and its work is lost to the Ensemble.',
+      'SUBAGENT POLICY: in this room, a main terminal delegates worker slices through visible spawn_terminal Ensemble lanes. A person-requested new or separate terminal is created with open_main_terminal, never Ensemble. Worker, leaf, Side, and managed Flow lanes do their assigned work directly. Do NOT reach for built-in Task/Agent subagents: an in-process subagent is invisible to the room, cannot be peered at or steered, and its work is lost to the Ensemble.',
       'RESEARCH LANE: you have a `research` tool that runs a REAL multi-source web search + adversarial verification and returns each claim marked HELD or REJECTED with citations. Reach for it when the people would genuinely benefit from looking something external up or settling a question of current fact — pricing, "is X still maintained / deprecated", "is that benchmark real", a debate over facts you are not sure of. Do NOT run it unprompted or for things you already know: first OFFER in plain language ("want me to spawn a research lane on that and check it?"), and only call `research(question)` once they agree — it spends real budget (plan-gated Free 5 / Plus 100 runs a month) and takes ~a minute. When it returns, present the held/rejected findings clearly and invite both people to weigh the sources, flagging any held claim that rests on a source they might not trust — that shared scrutiny is the point.',
       'WORKTREES: parallel lanes share one machine and usually one repo. Run `git worktree list` before your first code edit; if linked worktrees exist, the shared main checkout is contended (and may be guard-blocked) — do your work in your OWN worktree on your OWN branch (`git worktree add <dir> -b <branch>`), and never edit a checkout or ride a branch another lane is using.',
       'WRITE PLANS INTO THE CHAT: whenever you form or revise a plan — because the room is in Plan mode, or because someone asked you to plan, design, or think it through first — write the actual plan out as a normal message in the room as you develop it: the approach, the concrete steps, the files you will touch, the open questions. The room does NOT surface plan files at all, and the plan-approval card does not reliably carry the plan text, so a plan that lives only in a plan file or only inside ExitPlanMode is INVISIBLE to the people you are working with — they just see "plan ready" with no content. The chat is the canonical place your plan lives; put it there so the room can read and react to it before you proceed.',

package/codex-session.mjs

@@ -192,6 +192,25 @@ export function readCodexThreadUsage(sessionId, {
   return null
 }
 
+// App Server publishes the authoritative current-window count during native
+// compaction (and while turns run). Its field names differ from the rollout
+// token_count rows, so normalize both sources to the one snapshot shape used by
+// CodexEventMapper and the bridge context meter.
+export function codexUsageSnapshotFromAppServer(tokenUsage) {
+  const used = Number(tokenUsage?.last?.totalTokens)
+  const max = Number(tokenUsage?.modelContextWindow)
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(max) || max <= 0) return null
+  const total = tokenUsage?.total || {}
+  return {
+    context: { used: Math.floor(used), max: Math.floor(max) },
+    total: {
+      input_tokens: Math.max(0, Number(total.inputTokens) || 0),
+      cached_input_tokens: Math.max(0, Number(total.cachedInputTokens) || 0),
+      output_tokens: Math.max(0, Number(total.outputTokens) || 0),
+    },
+  }
+}
+
 export function normalizeCodexSandbox(value) {
   return SAFE_SANDBOXES.has(value) ? value : DEFAULT_SANDBOX
 }
@@ -218,7 +237,7 @@ export function codexPublishAccess({ cwd, env = process.env, tmpdir = os.tmpdir(
 }
 
 export const CODEX_ROOM_CASCADE_REMINDER = [
-  '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.',
+  'THINKPOOL ROOM ROLE ENFORCEMENT: obey the authoritative TERMINAL ROLE above. A person-authored request for a new, separate, independent, top-level, or main terminal uses open_main_terminal — NEVER spawn_terminal — even for ordinary work or a handoff. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. 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, promptIndex = 0, forceFullReminder = false }) {
@@ -415,6 +434,8 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let appServer = null
   let appServerThreadReady = false
   let activeTurnId = null
+  let compactStartWaiter = null
+  let compactActive = false
   // App Server notifications are asynchronous to turn/completed. In production a
   // stopped turn emitted its durable `aborted` boundary, then delivered a queued
   // item/started 89ms later and a Bash result 159.9s after that. Without a native
@@ -442,7 +463,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     usageSnapshotForSession: (id) => {
       const snapshot = readCodexThreadUsage(id)
       if (snapshot) latestUsageSnapshot = snapshot
-      return snapshot
+      return snapshot || latestUsageSnapshot
     },
   })
 
@@ -499,9 +520,29 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   function appServerNotification(method, params = {}) {
+    if (method === 'thread/tokenUsage/updated') {
+      if (params.threadId && sessionId && String(params.threadId) !== String(sessionId)) return
+      const snapshot = codexUsageSnapshotFromAppServer(params.tokenUsage)
+      if (!snapshot) return
+      latestUsageSnapshot = snapshot
+      // Ordinary turns publish one settled meter at turn/completed. Native
+      // compaction is not an ordinary sendTurn, so this notification is its only
+      // immediate post-summary meter and must reach every connected room client.
+      if (compactActive) {
+        const { used, max } = snapshot.context
+        relayEvent({ kind: 'usage', ctx: { used, max, pct: Math.min(100, Math.max(0, Math.round((used / max) * 100))), over: used > max, model: activeModel } })
+      }
+      return
+    }
     if (method === 'turn/started' && params.turn?.id) {
       const turnId = String(params.turn.id)
       if (ended || aborted) { closeAppServerTurn(turnId); return }
+      if (compactStartWaiter) {
+        const waiter = compactStartWaiter
+        compactStartWaiter = null
+        waiter.resolve(turnId)
+        return
+      }
       if (!activeTurnId) activeTurnId = turnId
       touchActivity()
       return
@@ -996,7 +1037,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   return {
     get sessionId() { return sessionId },
     get usageSnapshot() { return latestUsageSnapshot },
-    get turnActive() { return turnActive },
+    get turnActive() { return turnActive || compactActive },
     get canSteer() { return !!(appServer && appServer.alive !== false && appServerThreadReady && !appServerDisabled) },
     get started() { return turnNo > 0 || turnActive },
     sendTurn(text, options = {}) {
@@ -1128,13 +1169,32 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       return true
     },
     async compactContext() {
-      if (turnActive || !await ensureAppServer()) return false
+      if (turnActive || compactActive || !await ensureAppServer()) return false
+      compactActive = true
+      let startTimer = null
       try {
+        const compactTurn = new Promise((resolve, reject) => {
+          startTimer = setTimeout(() => {
+            compactStartWaiter = null
+            reject(new Error('Codex did not start the compaction turn'))
+          }, 5000)
+          compactStartWaiter = { resolve, reject }
+        })
         await appServer.compact({ threadId: sessionId })
-        return true
+        const turnId = await compactTurn
+        if (startTimer) clearTimeout(startTimer)
+        const completed = await appServer.waitForTurn(turnId)
+        closeAppServerTurn(completed?.turn?.id || turnId)
+        const status = completed?.turn?.status
+        if (status === 'completed') return true
+        throw new Error(completed?.turn?.error?.message || `compaction ${status || 'failed'}`)
       } catch (error) {
         note(`Native Codex compaction unavailable; using bounded recap fallback: ${error?.message || error}`)
         return false
+      } finally {
+        if (startTimer) clearTimeout(startTimer)
+        compactStartWaiter = null
+        compactActive = false
       }
     },
     async accountUsage() {

package/keep-awake.mjs

@@ -0,0 +1,148 @@
+/* keep-awake.mjs — one explicit, machine-wide bridge preference with a
+   platform-native implementation. The assertion is SYSTEM-only: it never asks
+   any platform to keep the display lit, so normal dimming, display sleep, and
+   screen locking remain available.
+
+   The helper is deliberately tied to the bridge PID. A crash, Ctrl-C, update,
+   or service-manager replacement therefore releases the assertion without a
+   sticky machine-level power-policy change. */
+
+import os from 'node:os'
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const SETTINGS_FILE = 'settings.json'
+
+function settingsPath(home = os.homedir()) {
+  return path.join(home, '.thinkpool-pair', SETTINGS_FILE)
+}
+
+export function loadKeepAwakePreference({ home = os.homedir(), fsImpl = fs } = {}) {
+  try { return JSON.parse(fsImpl.readFileSync(settingsPath(home), 'utf8')).keepAwake === true }
+  catch { return false }
+}
+
+export function saveKeepAwakePreference(enabled, { home = os.homedir(), fsImpl = fs } = {}) {
+  const file = settingsPath(home)
+  const dir = path.dirname(file)
+  let current = {}
+  try { current = JSON.parse(fsImpl.readFileSync(file, 'utf8')) || {} } catch { /* first setting */ }
+  const next = { ...current, keepAwake: enabled === true }
+  const tmp = `${file}.tmp.${process.pid}.${Date.now()}`
+  try {
+    fsImpl.mkdirSync(dir, { recursive: true })
+    fsImpl.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 })
+    fsImpl.renameSync(tmp, file)
+    return true
+  } catch {
+    try { fsImpl.rmSync(tmp, { force: true }) } catch { /* noop */ }
+    return false
+  }
+}
+
+export function explicitKeepAwakeChoice(argv = []) {
+  const dash = argv.indexOf('--')
+  const own = dash >= 0 ? argv.slice(0, dash) : argv
+  if (own.includes('--no-keep-awake')) return false
+  if (own.includes('--keep-awake')) return true
+  return null
+}
+
+export function keepAwakeEnabled(argv = [], { env = process.env, loadPreference = loadKeepAwakePreference } = {}) {
+  const explicit = explicitKeepAwakeChoice(argv)
+  if (explicit !== null) return explicit
+  if (env.THINKPOOL_PAIR_KEEP_AWAKE === '1') return true
+  if (env.THINKPOOL_PAIR_KEEP_AWAKE === '0') return false
+  return loadPreference() === true
+}
+
+const WINDOWS_HELPER = (parentPid) => [
+  '$ErrorActionPreference = "Stop"',
+  'Add-Type -TypeDefinition \'using System; using System.Runtime.InteropServices; public static class ThinkpoolPower { [DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint flags); }\'',
+  // ES_CONTINUOUS | ES_SYSTEM_REQUIRED. ES_DISPLAY_REQUIRED (0x2) is intentionally absent.
+  '[ThinkpoolPower]::SetThreadExecutionState([uint32]0x80000001) | Out-Null',
+  `try { while (Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue) { Start-Sleep -Seconds 5 } }`,
+  'finally { [ThinkpoolPower]::SetThreadExecutionState([uint32]0x80000000) | Out-Null }',
+].join('; ')
+
+// Pure command construction keeps the display-sleep contract testable on any host.
+export function keepAwakeCommand(platform, parentPid, { node = process.execPath, modulePath = fileURLToPath(import.meta.url) } = {}) {
+  if (!Number.isInteger(parentPid) || parentPid <= 0) throw new Error('keep-awake requires a live bridge pid')
+  if (platform === 'darwin') {
+    // -i is the idle SYSTEM-sleep assertion. Do not add -d (display).
+    // -w makes caffeinate release automatically when the bridge PID exits.
+    return { command: '/usr/bin/caffeinate', args: ['-i', '-w', String(parentPid)], adapter: 'caffeinate' }
+  }
+  if (platform === 'linux') {
+    // Inhibit the sleep operation, not desktop "idle" handling: an idle inhibitor
+    // can also suppress screen blanking in some desktop environments. The tiny Node
+    // waiter exits with the parent, releasing systemd-logind's inhibitor lock.
+    return {
+      command: 'systemd-inhibit',
+      args: ['--what=sleep', '--mode=block', '--who=Thinkpool', '--why=Keep the Thinkpool bridge reachable', '--', node, modulePath, '--wait-for', String(parentPid)],
+      adapter: 'systemd-inhibit',
+    }
+  }
+  if (platform === 'win32') {
+    return {
+      command: 'powershell.exe',
+      args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', WINDOWS_HELPER(parentPid)],
+      adapter: 'Windows power request',
+    }
+  }
+  return null
+}
+
+export function startKeepAwake({
+  enabled,
+  platform = process.platform,
+  parentPid = process.pid,
+  spawnImpl = spawn,
+  stderr = process.stderr,
+  accountChild = process.env.THINKPOOL_PAIR_ACCOUNT_CHILD === '1',
+} = {}) {
+  if (!enabled || accountChild) return null
+  let spec
+  try { spec = keepAwakeCommand(platform, parentPid) }
+  catch (error) { stderr.write(`  ⚠ keep-awake unavailable: ${error?.message || error}\n`); return null }
+  if (!spec) {
+    stderr.write(`  ⚠ keep-awake is not supported on ${platform}; bridge startup will continue normally.\n`)
+    return null
+  }
+
+  let child
+  const startedAt = Date.now()
+  try {
+    child = spawnImpl(spec.command, spec.args, { stdio: 'ignore', windowsHide: true })
+    child.once?.('spawn', () => {
+      stderr.write(`  ◆ keep-awake ON via ${spec.adapter}: system sleep is inhibited while this bridge runs.\n    Your screen can still dim, lock, and turn off normally.\n`)
+    })
+    child.once?.('error', (error) => {
+      stderr.write(`  ⚠ keep-awake could not start (${spec.adapter}: ${error?.message || error}); bridge startup will continue normally.\n`)
+    })
+    child.once?.('exit', (code) => {
+      if (code && Date.now() - startedAt < 30_000) stderr.write(`  ⚠ keep-awake helper exited early (${spec.adapter}, code ${code}); the computer may sleep normally.\n`)
+    })
+    child.unref?.()
+    return child
+  } catch (error) {
+    stderr.write(`  ⚠ keep-awake could not start (${spec.adapter}: ${error?.message || error}); bridge startup will continue normally.\n`)
+    return null
+  }
+}
+
+async function waitForProcess(pid) {
+  for (;;) {
+    try { process.kill(pid, 0) } catch { return }
+    await new Promise((resolve) => setTimeout(resolve, 5_000))
+  }
+}
+
+// Linux systemd-inhibit owns this helper as its COMMAND. It holds no power
+// assertion itself; its lifetime simply matches the bridge process.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url) && process.argv[2] === '--wait-for') {
+  const pid = Number(process.argv[3])
+  if (Number.isInteger(pid) && pid > 0) await waitForProcess(pid)
+}

package/launcher.mjs

@@ -17,6 +17,7 @@ import { execSync } from 'node:child_process'
 import { detectProvider, fetchModels, ANTHROPIC_COMPATIBLE, gatewayHint } from './byok-detect.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
 import { darwinServiceRunning, serviceRuntimeVersion } from './service.mjs'
+import { loadKeepAwakePreference } from './keep-awake.mjs'
 
 const HOME = os.homedir()
 const CFG_DIR = path.join(HOME, '.thinkpool-pair')
@@ -86,6 +87,7 @@ export function detectState() {
     hermesInstalled,
     hermesReady,
     accountSvc,
+    keepAwake: loadKeepAwakePreference(),
     serviceVersion: accountSvc ? serviceRuntimeVersion(null) : null,
     platform: process.platform,
     cwd: process.cwd(),
@@ -110,6 +112,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     loggedIn: !!next?.loggedIn,
     reconnectRequired: !!next?.reconnectRequired,
     accountSvc: !!next?.accountSvc,
+    keepAwake: next?.keepAwake === true,
     serviceVersion: typeof next?.serviceVersion === 'string' && next.serviceVersion ? next.serviceVersion : null,
     platform: next?.platform || process.platform,
     provider: next?.provider || 'Anthropic (default)',
@@ -134,7 +137,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     io.print('  ' + C.dim('┌ ') + C.bold('thinkpool-pair') + C.dim(' ' + '─'.repeat(40)))
     io.print(`  ${C.dim('│ launcher ')} ${state.version ? `v${state.version}` : 'version unavailable'}`)
     io.print(`  ${C.dim('│ account  ')} ${state.reconnectRequired ? C.yellow('reconnect required') : state.loggedIn ? C.green((state.email || 'linked') + ' ✓') : C.yellow('not linked')}`)
-    io.print(`  ${C.dim('│ agents   ')} ${state.agents.length ? state.agents.map(a => a.label).join(', ') : C.yellow('none ready')}`)
+    io.print(`  ${C.dim('│ agents   ')} ${state.agents.length ? state.agents.map(a => a.label).join(', ') : C.yellow('none ready: install Claude Code, Codex, or Hermes')}`)
     io.print(`  ${C.dim('│ directory')} ${C.dim(state.cwd)}`)
     const bridgeStatus = !state.accountSvc
       ? 'not installed'
@@ -142,6 +145,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
         ? C.green('startup entry installed')
         : C.green(`running${state.serviceVersion ? ` v${state.serviceVersion}` : ' (version unavailable)'}`)
     io.print(`  ${C.dim('│ bridge   ')} ${bridgeStatus}`)
+    io.print(`  ${C.dim('│ keep awake')} ${state.keepAwake ? C.green('on') + C.dim(', display may still dim') : 'off'}`)
     io.print('  ' + C.dim('└' + '─'.repeat(54)) + '\n')
   }
 
@@ -176,8 +180,25 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     return true
   }
 
+  // A provider key is credentials, not an executable agent. Stop new installs
+  // before they create an apparently healthy but unusable background bridge.
+  const ensureAgentReady = async () => {
+    if (state.agents.length) return true
+    io.print('\n  ' + C.yellow('No coding agent is ready on this computer'))
+    io.print('  Thinkpool connects an agent already installed on this machine. It does not')
+    io.print('  include one. Install and configure at least one of:')
+    io.print(`\n    ${C.cyan('Claude Code')}   command: claude`)
+    io.print(`    ${C.cyan('Codex')}         command: codex`)
+    io.print(`    ${C.cyan('Hermes')}        command: hermes, then set up its Thinkpool profile here`)
+    io.print('\n  ' + C.bold('BYOK does not replace the agent. It only gives an installed agent'))
+    io.print('  credentials for a model provider.')
+    io.print('\n  Install one, then reopen this launcher.')
+    return false
+  }
+
   const providerMenu = async () => {
     const cur = state.provider + (state.providerModel ? `, model ${state.providerModel}` : '')
+    io.print('\n  ' + C.dim('Provider settings supply model credentials. Claude Code, Codex, or Hermes must still be installed locally.'))
     const p = await askChoice('\n  provider', [
       { label: 'Anthropic (default)', hint: 'regular Claude login' },
       { label: 'Paste a key, pick a model', hint: 'auto-detects the provider · OpenRouter = any model' },
@@ -236,6 +257,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
       const options = [
         { key: 'provider', label: 'Provider', hint: `current: ${state.provider}` },
         { key: 'account', label: 'Account', hint: state.reconnectRequired ? 'reconnect required' : state.loggedIn ? `linked: ${state.email || 'yes'}` : 'not linked' },
+        { key: 'awake', label: 'Keep computer awake', hint: `${state.keepAwake ? 'ON' : 'off'} · the screen can still dim, lock, and turn off` },
       ]
       if (state.hermesInstalled) options.push({ key: 'hermes', label: state.hermesReady ? 'Hermes profile' : 'Set up Hermes', hint: state.hermesReady ? 'isolated profile ready' : 'set up isolated profile + delegation guard' })
       options.push({ key: 'back', label: 'Back to main menu', hint: '' })
@@ -243,6 +265,30 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
       if (picked.key === 'back') return
       if (picked.key === 'provider') await providerMenu()
       else if (picked.key === 'account') { await actions.login(); resync(); return }
+      else if (picked.key === 'awake') {
+        if (state.keepAwake) {
+          const changed = await actions.setKeepAwake({ enabled: false })
+          if (changed === false) continue
+          state = { ...state, keepAwake: false }
+          resync()
+          io.print('\n  ' + C.green('✓ keep-awake is off. The computer may sleep normally.'))
+        } else {
+          io.print('\n  ' + C.yellow('Important: keep-awake changes this computer’s power behavior'))
+          io.print('  While the bridge runs, Thinkpool will prevent the computer itself from')
+          io.print('  automatically sleeping. This can use substantially more battery and may')
+          io.print('  also block suspend requests on some Linux systems.')
+          io.print('\n  ' + C.green('It does NOT keep the screen on. Display dimming, screen locking, and'))
+          io.print('  display sleep continue to work normally. Closing a laptop lid may still')
+          io.print('  sleep it, depending on the operating system and power settings.')
+          if (await askYesNo('\n  Enable keep-awake while the Thinkpool bridge runs?', false)) {
+            const changed = await actions.setKeepAwake({ enabled: true })
+            if (changed === false) continue
+            state = { ...state, keepAwake: true }
+            resync()
+            io.print('\n  ' + C.green('✓ keep-awake is on. Your screen is still free to dim and turn off.'))
+          } else io.print('\n  ' + C.yellow('unchanged: keep-awake remains off.'))
+        }
+      }
       else if (picked.key === 'hermes') {
         const setup = await askChoice('\n  Hermes profile', [
           { label: 'Clone active profile', hint: 'copies provider/config explicitly; fresh ThinkPool session history' },
@@ -277,13 +323,13 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
           { key: 'serve',   label: 'Serve all my sessions', hint: 'runs here, Ctrl-C stops it' },
           { key: 'service', label: 'Always-on background service', hint: 'recommended — survives reboot, restarts on crash' },
         ]
-    items.push({ key: 'settings', label: 'Settings', hint: `provider · account${state.hermesInstalled ? ' · Hermes profile' : ''}` })
+    items.push({ key: 'settings', label: 'Settings', hint: `provider · account · keep-awake ${state.keepAwake ? 'ON' : 'off'}${state.hermesInstalled ? ' · Hermes profile' : ''}` })
     items.push({ key: 'quit', label: 'Quit', hint: '' })
     const pick = items[await askChoice('choose', items)]
     if (pick.key === 'quit') return
-    if (pick.key === 'serve') { if (await ensureLoggedIn()) await actions.serveAccountForeground() }
+    if (pick.key === 'serve') { if (await ensureAgentReady() && await ensureLoggedIn()) await actions.serveAccountForeground() }
     else if (pick.key === 'service') {
-      if (await ensureLoggedIn()) {
+      if (await ensureAgentReady() && await ensureLoggedIn()) {
         const installed = await actions.installService({ room: null })
         if (installed === true) {
           if (!actions.relaunchLauncher || await actions.relaunchLauncher()) return

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.336",
-  "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
+  "version": "0.7.338",
+  "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
     "thinkpool-pair": "bridge.mjs"
@@ -12,6 +12,7 @@
     "command-guidance.mjs",
     "abort-turn-barrier.mjs",
     "host-memory.mjs",
+    "keep-awake.mjs",
     "sdk-smoke.mjs",
     "sdk-admission.mjs",
     "sdk-admission.mjs",

package/service.mjs

@@ -25,6 +25,7 @@ import { execSync } from 'node:child_process'
 import { hostMemoryAdmission } from './host-memory.mjs'
 import { readSupervisorReady, supervisorReadyMatches } from './supervisor-ready.mjs'
 import { pairCli } from './command-guidance.mjs'
+import { loadKeepAwakePreference } from './keep-awake.mjs'
 
 // Service identity. Account mode has no room → a single stable id so there's
 // exactly one account service per machine (a second install replaces it).
@@ -591,7 +592,11 @@ export function installService(room, cmdArgs = [], { autoUpdate = false, version
     : `PINNED to ${version} (stable local runtime; restarts do not depend on npx or the network). To update: use "Restart & update the bridge" (or run ${pairCli('install-service', room || undefined)}). Pass --auto-update to track @latest instead.`
   const removeArg = room ? ` ${room}` : ''
   const what = room ? `room ${room}` : 'your account (auto-serves every session)'
-  process.stderr.write(`  ◆ ${what}\n  ◆ ${process.platform === 'darwin' ? 'Launchd is completing and verifying the reload independently.' : a.note}\n  ◆ ${updateNote}\n  ◆ logs: ${path.join(a.logDir, `${slug(room)}.log`)}\n  ◆ remove with: ${pairCli('uninstall-service')}${removeArg}\n\n`)
+  const awakeNote = loadKeepAwakePreference()
+    ? '  ◆ Keep-awake on: system sleep is inhibited while the bridge runs (higher battery use); the display may still dim, lock, and turn off.\n'
+    : ''
+  const runtimeNote = '  ◆ Prerequisite: Claude Code, Codex, or Hermes must be installed on this machine. BYOK supplies model credentials; it does not install an agent.\n'
+  process.stderr.write(`  ◆ ${what}\n  ◆ ${process.platform === 'darwin' ? 'Launchd is completing and verifying the reload independently.' : a.note}\n${runtimeNote}${awakeNote}  ◆ ${updateNote}\n  ◆ logs: ${path.join(a.logDir, `${slug(room)}.log`)}\n  ◆ remove with: ${pairCli('uninstall-service')}${removeArg}\n\n`)
   return true
 }
 

package/thinkpool-capabilities.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "bundleVersion": 16,
+  "bundleVersion": 17,
   "contracts": [
     {
       "id": "room-coordination",
@@ -41,18 +41,18 @@
     },
     {
       "id": "work-routing",
-      "version": 6,
+      "version": 7,
       "providerRoutingContract": "A Claude lane may select a connected Anthropic-compatible provider by durable id, unique display name, or unique configured model. Unknown or ambiguous references fail closed and must never fall through to built-in Claude.",
       "openerParityContract": "Every top-level terminal may use spawn_terminal or open_main_terminal to open every supported structured runtime: Claude, Codex, or Hermes. Runtime-specific provider/model validation remains authoritative and occurs before inference.",
       "routes": [
         {
           "id": "work-routing",
           "tools": ["spawn_terminal", "open_main_terminal", "close_terminal"],
-          "trigger": "\\b(parallel|delegate|worker|sub[- ]?terminal|conductor|cascade|spawn_terminal|open_main_terminal|close_terminal)\\b",
-          "prompt": "For genuinely decomposable work in a conductor-capable role, open visible worker slices with spawn_terminal, collect and verify each result with one targeted read_terminal call after completion, then close_terminal immediately. Do not poll workers or repeat the ROOM NOW roster. An explicitly requested separate Cascade/conductor uses open_main_terminal, never spawn_terminal. Review slices are structurally read-only and must use the review slice type; they never inherit autonomous bypass authority."
+          "trigger": "\\b(?:open|launch|start|spawn|create)\\b.{0,40}\\b(?:new|separate|independent|main|top[- ]?level)?\\s*terminals?\\b|\\b(?:new|separate|independent|main|top[- ]?level)\\s+terminals?\\b|\\b(parallel|delegate|worker|sub[- ]?terminal|ensemble|conductor|cascade|spawn_terminal|open_main_terminal|close_terminal)\\b",
+          "prompt": "A person-authored request to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal uses open_main_terminal, even for ordinary work or a handoff and even when they do not say Cascade or conductor. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. For genuinely decomposable work in a conductor-capable role, collect and verify each worker result with one targeted read_terminal call after completion, then close_terminal immediately. Do not poll workers or repeat the ROOM NOW roster. Review slices are structurally read-only and must use the review slice type; they never inherit autonomous bypass authority."
         }
       ],
-      "expandedPrompt": "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. Review slices are structurally read-only: they resolve to a native review/Plan mode before launch and can never inherit autonomous bypass authority. 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. ROOM NOW is the default roster and completion signals wake the conductor; do not spend the bounded read allowance polling or repeating a no-argument roster. After dispatch, remain responsible: once an owned worker is finished, make one targeted read_terminal call to collect its result, verify its claim, close_terminal immediately, and dispatch newly unblocked work. Preserve enough targeted reads for every open worker and the final adversarial review; 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.",
+      "expandedPrompt": "MAIN TERMINAL ROUTING (authoritative): a person-authored request to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal uses open_main_terminal, even for ordinary work or a handoff and even when they do not say Cascade or conductor. If the wording includes new or separate terminal, main-terminal routing wins. spawn_terminal is only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. 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. 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. Review slices are structurally read-only: they resolve to a native review/Plan mode before launch and can never inherit autonomous bypass authority. 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. ROOM NOW is the default roster and completion signals wake the conductor; do not spend the bounded read allowance polling or repeating a no-argument roster. After dispatch, remain responsible: once an owned worker is finished, make one targeted read_terminal call to collect its result, verify its claim, close_terminal immediately, and dispatch newly unblocked work. Preserve enough targeted reads for every open worker and the final adversarial review; 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.",
       "impact": [
         {"path": "bridge/bridge.mjs", "diffPattern": "spawn_terminal|open_main_terminal|close_terminal|cascadeRole|spawnDepth"},
         {"path": "bridge/lane-lifecycle.mjs"},

package/thinkpool-room-prompt.mjs

@@ -143,7 +143,7 @@ export function buildTerminalRolePrompt({ spawnedBy = null, spawnDepth = 0, casc
     return `TERMINAL ROLE (authoritative): You are a MISCLASSIFIED ENSEMBLE SUB-TERMINAL at spawn depth ${Math.max(1, depth)}, owned by parent terminal ${parentRef}. A spawned lane can never be a Cascade conductor. Work directly as a worker, do not spawn terminals, and report that the parent must use open_main_terminal for a separate conductor.`
   }
   if (!spawnedBy && depth === 0) {
-    return 'TERMINAL ROLE (authoritative): You are an independent TOP-LEVEL ThinkPool terminal opened directly in the room. You are not a spawned sub-terminal or worker lane. You may conduct the current task here and open worker SUB-TERMINALS with spawn_terminal. When a person explicitly asks you to open, launch, or start a separate Cascade/conductor terminal, use open_main_terminal — never spawn_terminal. Conductors are main terminals; Ensemble-spawned lanes are workers only.'
+    return 'TERMINAL ROLE (authoritative): You are an independent TOP-LEVEL ThinkPool terminal opened directly in the room. You are not a spawned sub-terminal or worker lane. You may conduct the current task here and open worker SUB-TERMINALS with spawn_terminal. A person-authored request to open, launch, start, spawn, or create a new, separate, independent, top-level, or main terminal uses open_main_terminal — never spawn_terminal — even for ordinary work or a handoff. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice.'
   }
   if (depth >= 2) {
     return `TERMINAL ROLE (authoritative): You are a LEAF SUB-TERMINAL at spawn depth ${depth}, owned by parent terminal ${parentRef}. You are not top-level and not a conductor. Complete the assigned slice directly, do not spawn another terminal, and hand evidence/results back to your parent.`