thinkpool-pair 0.7.203 → 0.7.205

package/bridge.mjs

@@ -1044,7 +1044,7 @@ const announce = () => {
       // turnActive). Authoritative — the bridge owns the turn — so the /code
       // dashboard reads "N agents working" off the roster instead of sniffing
       // the live code-event stream (which a passive dashboard channel misses).
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, busy: s.session?.turnActive ?? false, hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [] } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
         // provider: the registered LLM-provider this lane runs on, NAME-ONLY {id,name}
         // (NEVER the key or baseUrl). Additive; older clients ignore it. Omitted for the
         // built-in/default Claude path (no badge). Makes the lane's provider badge +
@@ -1759,7 +1759,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // restart. Without this, sessionData omitted it → on restart the resumed session
   // re-launched on the host default (Opus) regardless of the last switch, and the
   // switch looked like it "never changed the model" (Max 2026-07-02). Restored below.
-  const sessionData = () => ({ sessionId: entry.session?.sessionId || resume || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, provider: entry.provider || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null })
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, provider: entry.provider || null, spawnedBy: entry.spawnedBy, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null })
   const persist = () => saveSession(room, id, sessionData())
   // Synchronous flush of this session's record. Used on open (so a brand-new session
   // has a file under its id BEFORE its first event — surviving a restart inside the
@@ -2098,7 +2098,8 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // Context-carry (2026-07-08): a non-resumable re-open (provider switch / non-resumable
   // restart) hands the FRESH session a plain-text recap of the visible log as its first
   // input, so the agent picks up the work instead of starting blank mid-conversation. Held
-  // here (transient — NOT in sessionData, a re-restart re-derives it from the log) and fired
+  // here and persist it until consumed, so a restart between /compact and the next
+  // human turn cannot strand a fresh Codex thread without its recap. It is fired
   // on the init `system` event (see onEvent) — a sendTurn before the input stream is consumed
   // is silently lost (the 2026-07-02 auto-resume bug). Empty string → nothing to carry.
   entry.pendingRecap = (typeof carryRecap === 'string' && carryRecap.trim()) ? carryRecap : null
@@ -2286,6 +2287,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
       if (evt.kind === 'system' && entry.pendingRecap) {
         const recap = entry.pendingRecap
         entry.pendingRecap = null
+        entry.flush?.()
         try { entry.session?.sendTurn(recap) } catch { /* not live — stays idle, user can continue manually */ }
         process.stderr.write(`\n  ◆ carried ${recap.length}c context recap into fresh session (${id.slice(0, 8)}) after provider/restore switch.\n`)
       }
@@ -2733,8 +2735,18 @@ channel
     // (legacy/pre-C1 logs) ride along always; the client cid-dedups those and
     // additionally drops ≤ seqHi, so an over-send is harmless. A fresh joiner (no
     // cursor) still gets the full log.
-    for (const [id, s] of sessions) {
-      if (!s.log.length) continue
+    // Hydrate the viewed lane first. Other terminals still warm in the background,
+    // but cannot queue ahead of the transcript the person is waiting to see.
+    const replaySessions = [...sessions.entries()].sort(([a], [b]) =>
+      a === payload?.priority ? -1 : b === payload?.priority ? 1 : 0)
+    for (const [id, s] of replaySessions) {
+      // An explicit empty replay is an acknowledgement, not data. It lets mixed
+      // clients clear their loading cover even if they missed the announce's
+      // hasTranscript:false state.
+      if (!s.log.length) {
+        bcast('code-replay', { to: payload?.to ?? null, term: id, events: [], empty: true })
+        continue
+      }
       const from = Number(payload?.cursors?.[id]) || 0
       const mx = maxSeq(s.log)
       // Cursor-sanity (B-safety): if the client's cursor is AHEAD of our highest seq, the
@@ -2869,11 +2881,11 @@ channel
       pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
-    // Session controls (/model, /clear) are NOT agent turns — they change the
+    // Session controls (/model, /clear, /usage, and Codex /compact) are NOT agent turns — they change the
     // shared session config. Emitting a `you` line for them strands the reader's
     // inferred "working…" state (no turn → no result to clear it; the old bug).
-    // Instead announce a ◆ control line both readers see. /compact + any other
-    // slash still flow through as a real, self-terminating turn.
+    // Instead announce a ◆ control line both readers see. Claude /compact + any
+    // other slash still flow through as a real, self-terminating turn.
     const ctlLine = (ctlText) => {
       const evt = { kind: 'control', text: ctlText, by: payload.by, cid: payload.cid }
       pushLog(s, evt)
@@ -2926,7 +2938,33 @@ channel
     // No persisted ctl line — the live indicator + the CompactionCard are the record.
     if (/^\/compact\b/.test(text)) {
       if (s.runtime === 'codex') {
-        ctlLine('Codex manages context compaction automatically')
+        if (s.session.turnActive) {
+          ctlLine('finish or stop the current Codex turn before compacting context')
+          return
+        }
+        const recap = buildRecapFromLog(s.log, RECAP_CAP, { reason: 'compact' })
+        if (!recap) {
+          ctlLine('nothing to compact — context unchanged')
+          return
+        }
+        if (s.session.clearContext?.() === false) {
+          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 }
+        pushLog(s, ce)
+        bcast('code-event', { term: payload.term, evt: ce })
+        // The new native thread has only the bounded recap queued for the next
+        // human turn. Reset the visible meter to that conservative text estimate.
+        if (s.lastUsage?.ctx?.max) {
+          const used = Math.ceil(recap.length / 4)
+          const max = s.lastUsage.ctx.max
+          const usage = { kind: 'usage', ctx: { ...s.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
+          s.lastUsage = usage
+          bcast('code-event', { term: payload.term, evt: usage })
+        }
+        s.flush?.()
         return
       }
       s.compacting = true
@@ -2946,7 +2984,7 @@ channel
     // it degrades to "plan meters unavailable" rather than printing an inferred reset.
     if (/^\/usage\s*$/.test(text)) {
       ctlLine(usageReportLine(s.model, s.log))
-      planMeterLine().then((l) => { if (l) ctlLine(l) }).catch(() => { /* meters are never load-bearing */ })
+      if (s.runtime !== 'codex') planMeterLine().then((l) => { if (l) ctlLine(l) }).catch(() => { /* meters are never load-bearing */ })
       return
     }
     // Context-carry (2026-07-08) point 4: a real human turn arrived BEFORE the post-switch/
@@ -2954,7 +2992,7 @@ channel
     // — a separate recap turn would race + double-fire) and clear the flag so the init handler
     // no-ops. The visible `you` echo is unchanged; the recap is context for the agent only.
     let sendText = text
-    if (s.pendingRecap) { sendText = `${s.pendingRecap}\n\n--- the person's next message ---\n${text}`; s.pendingRecap = null }
+    if (s.pendingRecap) { sendText = `${s.pendingRecap}\n\n--- the person's next message ---\n${text}`; s.pendingRecap = null; s.flush?.() }
     s.session.sendTurn(sendText)
     echoYou()
     // Pool-order fix (2026-07-02): emit the "dispatched to agent" marker HERE, right after
@@ -3183,7 +3221,7 @@ channel
             // FL-M6 — restore the flow context (id/role/cwd) so an in-flight flow survives a
             // bridge restart: the conductor keeps its subagent-block + plan interception, and
             // lanes keep their worktree cwd + the ability to mark done.
-            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage,
+            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, effort: rec.effort, provider: rec.runtime === 'codex' ? undefined : rec.provider || undefined, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, carryRecap: rec.carryRecap,
               // Lazy-boot restored terminals that were IDLE + not part of a flow: their transcript
               // shows immediately; the query boots on first turn. Mid-turn + flow terminals boot now
               // (mid-turn needs auto-resume; flow needs its lane live).

package/codex-event-mapper.mjs

@@ -42,7 +42,7 @@ export class CodexEventMapper {
   /**
    * @param {{onEvent:(evt)=>void, model?:string|null, sessionId?:string|null}} opts
    */
-  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs }) {
+  constructor({ onEvent, model = null, sessionId = null, fsImpl = fs, contextWindowForModel = () => null }) {
     this._onEvent = onEvent
     this._model = model || null
     this._sessionId = sessionId || null
@@ -50,6 +50,7 @@ export class CodexEventMapper {
     this._fileBefore = new Map() // item.id → [{ path, kind, content }]
     this._fs = fsImpl
     this._systemSent = false
+    this._contextWindowForModel = contextWindowForModel
   }
 
   /** Emit a room-event; never let a consumer throw into the stream. */
@@ -143,7 +144,15 @@ export class CodexEventMapper {
         const u = ev.usage || {}
         // Map Codex usage → Claude-shape usage (what event-id.mjs folds into cost).
         // reasoning_output_tokens are billed as output → fold in (conservative).
-        const out = (u.output_tokens || 0) + (u.reasoning_output_tokens || 0)
+        const out = (Number(u.output_tokens) || 0) + (Number(u.reasoning_output_tokens) || 0)
+        const totalInput = Number(u.input_tokens) || 0
+        const cachedInput = Math.min(totalInput, Number(u.cached_input_tokens) || 0)
+        let max = null
+        try { max = Number(this._contextWindowForModel(this._model)) } catch { /* unknown catalog → omit meter */ }
+        if (Number.isFinite(max) && max > 0) {
+          const used = totalInput + out
+          this._emit({ kind: 'usage', ctx: { used, max, pct: Math.min(100, Math.max(0, Math.round((used / max) * 100))), over: used > max, model: this._model } })
+        }
         this._emit({
           kind: 'result',
           subtype: 'success',
@@ -151,8 +160,11 @@ export class CodexEventMapper {
           model: this._model,
           costUsd: null,
           usage: {
-            input_tokens: u.input_tokens || 0,
-            cache_read_input_tokens: u.cached_input_tokens || 0,
+            // Claude-shape fields are mutually exclusive buckets. Codex reports
+            // cached_input_tokens as a subset of input_tokens, so subtract it here;
+            // usageReportLine adds the buckets and must not double-count cache hits.
+            input_tokens: totalInput - cachedInput,
+            cache_read_input_tokens: cachedInput,
             cache_creation_input_tokens: 0,
             output_tokens: out,
           },

package/codex-session.mjs

@@ -65,6 +65,19 @@ export function readCodexModels({ home = process.env.CODEX_HOME || path.join(os.
   } catch { return [] }
 }
 
+// The CLI's current model catalog is the authority for the runtime's usable model
+// window. Keep this separate from readCodexModels so the public announce shape stays
+// stable while the driver can emit a truthful context meter for every Codex model.
+export function readCodexContextWindow(model, { home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), fsImpl = fs } = {}) {
+  if (!model) return null
+  try {
+    const data = JSON.parse(fsImpl.readFileSync(path.join(home, 'models_cache.json'), 'utf8'))
+    const hit = (Array.isArray(data?.models) ? data.models : []).find((m) => m?.slug === model)
+    const max = Number(hit?.context_window)
+    return Number.isFinite(max) && max > 0 ? Math.floor(max) : null
+  } catch { return null }
+}
+
 export function normalizeCodexSandbox(value) {
   return SAFE_SANDBOXES.has(value) ? value : DEFAULT_SANDBOX
 }
@@ -150,7 +163,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let chain = Promise.resolve()
   const queue = []
 
-  const mapper = new CodexEventMapper({ onEvent, model: model || null })
+  const mapper = new CodexEventMapper({
+    onEvent,
+    model: model || null,
+    contextWindowForModel: (id) => readCodexContextWindow(id),
+  })
 
   const note = (text) => { try { onEvent?.({ kind: 'note', text }) } catch { /* noop */ } }
 

package/event-bounds.mjs

@@ -0,0 +1,96 @@
+/* Browser-safe structured-event bounding shared by the bridge broadcast path and
+   the web client's persisted reload snapshot. Large Codex/Claude tool payloads
+   must remain recognisable (tool name + a useful preview), but must never turn a
+   replay frame or tx: seed row into a multi-megabyte hydration dependency. */
+
+export const STRUCTURED_EVENT_CAP = 80000
+
+const sizeOf = (value) => {
+  try { return JSON.stringify(value).length } catch { return Infinity }
+}
+
+const clipString = (value, limit) => {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n…[truncated ${value.length - limit} bytes]`
+}
+
+function compactValue(value, budget, depth = 0) {
+  if (sizeOf(value) <= budget) return value
+  if (typeof value === 'string') return clipString(value, Math.max(80, budget - 80))
+  if (value == null || typeof value !== 'object') return value
+  if (depth >= 4) return '[nested value omitted — too large]'
+
+  if (Array.isArray(value)) {
+    const out = []
+    const limit = Math.min(value.length, 8)
+    const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
+    for (let i = 0; i < limit; i++) out.push(compactValue(value[i], per, depth + 1))
+    if (value.length > limit) out.push(`…[${value.length - limit} more items omitted]`)
+    return out
+  }
+
+  const entries = Object.entries(value)
+  const out = {}
+  const limit = Math.min(entries.length, 16)
+  const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
+  for (let i = 0; i < limit; i++) {
+    const [key, nested] = entries[i]
+    out[key] = compactValue(nested, per, depth + 1)
+  }
+  if (entries.length > limit) out._omitted = `${entries.length - limit} more fields`
+  return out
+}
+
+function compactBlock(block, budget) {
+  if (!block || typeof block !== 'object') return compactValue(block, budget)
+  if (sizeOf(block) <= budget) return block
+  if (block.type === 'image') {
+    return { type: 'text', text: '[image omitted from replay — open the live session to view]' }
+  }
+  const out = {}
+  for (const key of ['type', 'id', 'name', 'tool_use_id']) if (block[key] != null) out[key] = block[key]
+  // A replay needs the tool identity and a useful preview, not a second full copy
+  // of a giant patch/result that already lives in the durable archive.
+  const payloadBudget = Math.min(block.type === 'tool_use' ? 12000 : 20000, Math.max(500, budget - 600))
+  if (typeof block.text === 'string') out.text = clipString(block.text, payloadBudget)
+  if (block.input != null) out.input = compactValue(block.input, payloadBudget, 1)
+  if (block.content != null) out.content = compactValue(block.content, payloadBudget, 1)
+  if (!('text' in out) && !('input' in out) && !('content' in out)) out.text = `[${block.type || 'content'} omitted — too large]`
+  return out
+}
+
+export function boundStructuredEvent(event, cap = STRUCTURED_EVENT_CAP) {
+  if (!event || typeof event !== 'object' || sizeOf(event) <= cap) return event
+
+  const out = { ...event, _bounded: true }
+  const stringBudget = Math.min(12000, Math.max(1000, Math.floor(cap / 4)))
+  for (const key of ['text', 'output', 'stdout', 'stderr', 'input']) {
+    if (typeof out[key] === 'string') out[key] = clipString(out[key], stringBudget)
+  }
+  if (typeof out.content === 'string') out.content = clipString(out.content, stringBudget)
+  else if (Array.isArray(out.content)) {
+    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.content.length, 8))))
+    out.content = out.content.slice(0, 8).map(block => compactBlock(block, per))
+    if (event.content.length > 8) out.content.push({ type: 'text', text: `…[${event.content.length - 8} more blocks omitted]` })
+  }
+  if (Array.isArray(out.blocks)) {
+    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.blocks.length, 8))))
+    out.blocks = out.blocks.slice(0, 8).map(block => compactBlock(block, per))
+    if (event.blocks.length > 8) out.blocks.push({ type: 'text', text: `…[${event.blocks.length - 8} more blocks omitted]` })
+  }
+
+  if (sizeOf(out) <= cap) return out
+
+  // Hard fallback: retain ordering/dedup identity and recognisable tool blocks.
+  const identity = {}
+  for (const key of ['kind', 'seq', 'cid', 'ts', 'term', 'toolUseId', 'isError']) {
+    if (out[key] != null) identity[key] = out[key]
+  }
+  if (Array.isArray(out.blocks)) identity.blocks = out.blocks.slice(0, 4).map(block => compactBlock(block, 6000))
+  else if (Array.isArray(out.content)) identity.content = out.content.slice(0, 4).map(block => compactBlock(block, 6000))
+  else if (typeof out.content === 'string') identity.content = clipString(out.content, 12000)
+  else if (typeof out.text === 'string') identity.text = clipString(out.text, 12000)
+  identity._bounded = true
+  identity._notice = 'Large tool payload truncated for fast transcript hydration'
+  return identity
+}

package/event-id.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto'
+import { boundStructuredEvent, STRUCTURED_EVENT_CAP } from './event-bounds.mjs'
 
 /* event-id.mjs — stamp a structured event with a stable identity + timestamp
    BEFORE it is logged + broadcast.
@@ -180,29 +181,9 @@ export function firstSeq(events) {
 // so dedup, ordering, seqHi, and turn structure stay intact. Returns the event UNCHANGED
 // (no clone) when it's already small; clones before mutating so the persisted log is never
 // touched. (Proper fix for inline images = upload to storage + broadcast a URL — separate.)
-export const PER_EVENT_CAP = 180000
-const truncStr = (s) => s.slice(0, 20000) + `\n…[truncated ${s.length - 20000} bytes — too large to broadcast]`
+export const PER_EVENT_CAP = STRUCTURED_EVENT_CAP
 export function boundEventForBroadcast(evt, cap = PER_EVENT_CAP) {
-  if (!evt || typeof evt !== 'object') return evt
-  let json
-  try { json = JSON.stringify(evt) } catch { return evt }
-  if (json.length <= cap) return evt
-  const out = { ...evt }
-  for (const k of ['text', 'output', 'stdout', 'stderr', 'input']) {
-    if (typeof out[k] === 'string' && out[k].length > 20000) out[k] = truncStr(out[k])
-  }
-  if (typeof out.content === 'string' && out.content.length > 20000) out.content = truncStr(out.content)
-  else if (Array.isArray(out.content)) {
-    out.content = out.content.map((b) => {
-      if (!b || typeof b !== 'object') return b
-      if (JSON.stringify(b).length <= 20000) return b
-      if (b.type === 'image') return { type: 'text', text: '[image omitted from replay — too large to broadcast; open the live session to view]' }
-      if (typeof b.text === 'string') return { ...b, text: truncStr(b.text) }
-      return { type: 'text', text: `[${b.type || 'content'} omitted — too large to broadcast]` }
-    })
-  }
-  out._bounded = true
-  return out
+  return boundStructuredEvent(evt, cap)
 }
 
 // Detect inline base64 IMAGE blocks on a tool_result event (a screenshot the agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.203",
+  "version": "0.7.205",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "agent-notify.mjs",
     "agent-detect.mjs",
     "event-id.mjs",
+    "event-bounds.mjs",
     "plan-meters.mjs",
     "recap.mjs",
     "transcript-sanitize.mjs",

package/recap.mjs

@@ -42,6 +42,10 @@ const FRAMING = {
     header: '[CONTEXT CARRY — this lane kept talking while your machine was asleep]',
     body: "Your bridge was offline. The lane stayed open and the people in this room kept planning here with Pool — a chat-only assistant with no file access and no tools. Everything below already happened and they have all seen it. NOTHING WAS RUN ON YOUR BEHALF: no commands were executed, no files were changed, and no plan below has been carried out. Do NOT re-greet and do NOT re-answer what is already answered. Read the recap, then wait for the people to tell you what to do with it — the plan below is a plan, not an instruction you have already been given.",
   },
+  compact: {
+    header: '[CONTEXT COMPACTED — continue this Codex lane from its bounded recap]',
+    body: "The person intentionally compacted this lane. Your prior native thread was closed and the visible conversation below is its bounded continuation context. Do NOT re-greet, do NOT re-answer completed work, and do NOT repeat tool calls that already succeeded. Continue from the person's next message using this recap as memory.",
+  },
 }
 
 /* Context-carry recap for a lane whose SDK memory CAN'T be resumed — a cross-provider