thinkpool-pair 0.7.337 → 0.7.339

package/bridge.mjs

@@ -58,6 +58,7 @@ import { startStructuredSession } from './runtime-session.mjs'
 import { fallbackTerminalName } from './terminal-name.mjs'
 import { defaultStructuredMode, normalizeStructuredEffort, shouldDeferStructuredRuntime, structuredModeForSlice, structuredModeLocked, structuredModesForLane, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { commandCatalogForRuntime, commandHelpLine, reconcileCommandCatalog } from './command-catalog.mjs'
+import { gitDiffReport } from './git-diff-report.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
 import { hermesRequiredMcpTools, hermesRoleFor } from './hermes-policy.mjs'
 import { canonicalRoomFilePath, waitForNativeImages } from './codex-images.mjs'
@@ -2780,11 +2781,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'),
@@ -4365,8 +4366,7 @@ channel
     if (/^\/diff\s*$/.test(text)) {
       try {
         const cwd = s.cwd || process.cwd()
-        const summary = execFileSync('git', ['-C', cwd, 'status', '--short'], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).trim()
-        ctlLine(summary ? `Working tree changes\n${summary.slice(0, 1600)}` : 'Working tree clean')
+        ctlLine(gitDiffReport({ cwd }))
       } catch { ctlLine('Working-tree diff unavailable outside a readable Git checkout') }
       return
     }
@@ -4445,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
@@ -4471,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/command-catalog.mjs

@@ -19,7 +19,7 @@ export const CODE_ROOM_COMMANDS = Object.freeze([
   command('/status', 'runtime, model, permissions, and busy state', 'control'),
   command('/usage', 'session usage and provider limits', 'control'),
   command('/context', 'current context-window usage', 'control'),
-  command('/diff', 'working-tree change summary', 'control'),
+  command('/diff', 'Git changes and branch status', 'control'),
   command('/compact', 'compact context', 'runtime'),
   command('/clear', 'clear context · confirms', 'clear'),
   command('/model', 'pick model — opens selector', 'model'),

package/git-diff-report.mjs

@@ -0,0 +1,118 @@
+import { execFileSync } from 'node:child_process'
+
+const DEFAULT_MAX_FILES = 24
+const DEFAULT_MAX_COMMITS = 5
+const DEFAULT_MAX_CHARS = 1800
+
+const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`
+
+function defaultRunGit(args, cwd) {
+  return execFileSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 3000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
+function cleanLine(value, max = 240) {
+  return String(value || '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max)
+}
+
+function gitText(runGit, cwd, args) {
+  return String(runGit(args, cwd) || '').trim()
+}
+
+function tryGit(runGit, cwd, args) {
+  try { return gitText(runGit, cwd, args) } catch { return '' }
+}
+
+function resolveComparisonRef(runGit, cwd) {
+  const remoteHead = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])
+  if (remoteHead && tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', remoteHead])) return remoteHead
+  for (const candidate of ['origin/main', 'origin/master', 'main', 'master']) {
+    if (tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', candidate])) return candidate
+  }
+  return ''
+}
+
+function boundedReport(lines, maxChars) {
+  const kept = []
+  let length = 0
+  for (const raw of lines) {
+    const line = cleanLine(raw)
+    if (!line) continue
+    const nextLength = length + (kept.length ? 1 : 0) + line.length
+    if (nextLength > maxChars) {
+      const suffix = '… output shortened'
+      if (length + (kept.length ? 1 : 0) + suffix.length <= maxChars) kept.push(suffix)
+      break
+    }
+    kept.push(line)
+    length = nextLength
+  }
+  return kept.join('\n')
+}
+
+export function gitDiffReport({
+  cwd = process.cwd(),
+  runGit = defaultRunGit,
+  maxFiles = DEFAULT_MAX_FILES,
+  maxCommits = DEFAULT_MAX_COMMITS,
+  maxChars = DEFAULT_MAX_CHARS,
+} = {}) {
+  gitText(runGit, cwd, ['rev-parse', '--show-toplevel'])
+
+  const status = tryGit(runGit, cwd, ['status', '--porcelain=v1', '--untracked-files=normal'])
+  const statusLines = status ? status.split(/\r?\n/).filter(Boolean) : []
+  const branch = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD']) || 'detached HEAD'
+  const head = tryGit(runGit, cwd, ['rev-parse', '--short=8', 'HEAD']) || 'unknown'
+  const subject = cleanLine(tryGit(runGit, cwd, ['log', '-1', '--pretty=%s']), 160)
+  const comparisonRef = resolveComparisonRef(runGit, cwd)
+  const lines = []
+
+  if (statusLines.length) {
+    lines.push(`${plural(statusLines.length, 'uncommitted file')}`)
+    for (const line of statusLines.slice(0, Math.max(0, maxFiles))) lines.push(line)
+    if (statusLines.length > maxFiles) lines.push(`… ${plural(statusLines.length - maxFiles, 'more file')}`)
+  } else {
+    lines.push('No uncommitted changes')
+  }
+
+  lines.push(`Branch · ${branch} · ${head}`)
+
+  if (!comparisonRef) {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
+    return boundedReport(lines, maxChars)
+  }
+
+  const counts = tryGit(runGit, cwd, ['rev-list', '--left-right', '--count', `${comparisonRef}...HEAD`])
+    .split(/\s+/)
+    .map((value) => Number(value))
+  const behind = Number.isFinite(counts[0]) ? counts[0] : 0
+  const ahead = Number.isFinite(counts[1]) ? counts[1] : 0
+
+  if (ahead > 0) {
+    lines.push(`${plural(ahead, 'commit')} ahead of ${comparisonRef}${behind ? ` · ${plural(behind, 'commit')} behind` : ''}`)
+    const commitLines = tryGit(runGit, cwd, ['log', `--max-count=${Math.max(0, maxCommits)}`, '--pretty=%h %s', `${comparisonRef}..HEAD`])
+      .split(/\r?\n/)
+      .filter(Boolean)
+    if (commitLines.length) {
+      lines.push(`Commits not in ${comparisonRef}`)
+      lines.push(...commitLines)
+      if (ahead > commitLines.length) lines.push(`… ${plural(ahead - commitLines.length, 'more commit')}`)
+    }
+  } else if (behind > 0) {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject} · already in ${comparisonRef}`)
+    lines.push(`${plural(behind, 'commit')} behind ${comparisonRef}`)
+  } else {
+    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
+    lines.push(`Up to date with ${comparisonRef}`)
+  }
+
+  return boundedReport(lines, maxChars)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.337",
+  "version": "0.7.339",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
@@ -47,6 +47,7 @@
     "hermes-delegation-guard.mjs",
     "runtime-registry.mjs",
     "command-catalog.mjs",
+    "git-diff-report.mjs",
     "runtime-session.mjs",
     "turn-stall.mjs",
     "update-gate.mjs",

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.`