handmux 0.22.0 → 0.23.0

package/src/routes/transcript.js

@@ -1,14 +1,16 @@
-// Read a pane's Claude Code jsonl session and return it as normalized chat messages (the "对话" lens's
-// read-projection). Pane → cwd (tmux) → the session file under ~/.claude/projects/<encoded-cwd>/.
+// Read a pane's agent session as normalized chat messages. Claude reads its Hook-bound jsonl and keeps its
+// established cwd fallback. Managed Codex gets its exact thread id from App Server, then reads that
+// thread's durable rollout; App Server's history snapshot does not contain every completed tool.
 // Server-side paginated — the phone must never receive the whole transcript:
 //   - Recent window (default + polling): ?pane=&limit=10&since=<hash> — the last `limit` messages, with
 //     the same content-hash `since`省流 as /history (unchanged window → 204). `hasMore`/`firstSeq` tell the
 //     client whether/where an older page starts.
 //   - History page (scroll-up, not polled): ?pane=&before=<k>&limit=10 — the last `limit` messages with
 //     `k < before`, no hash.
-// `k` = each message's global ordinal in the parsed transcript — stable because the jsonl is append-only,
-// so it doubles as the client's dedup key. Only the requested page is copied and decorated with `k`; the
-// full parsed transcript is never mapped/filtered on every poll. The underlying reader asynchronously scans once,
+// `k` = each message's current global ordinal and pagination cursor. It is stable because both Claude and
+// Codex transcripts come from their append-only durable logs.
+// Only the requested page is copied and decorated with `k`; the full parsed transcript is never mapped/filtered
+// on every poll. The underlying reader asynchronously scans once,
 // then parses only appended complete lines; replacement/truncation resets it. `limit` clamps to [1,100],
 // default 10. Mounted under /api.
 import express from 'express';
@@ -16,10 +18,13 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { isPaneId } from '../tmux/commands.js';
 import { projectsDir } from '../agents/claude.js';
+import { AGENTS } from '../agents/index.js';
 import { resolveEncodedDirSession, encodeProjectDir } from '../agents/scanUtils.js';
 import { transcriptReader } from '../transcriptReader.js';
 import { parsePendingPrompt } from '../pendingPrompt.js';
 import { readClaudeContext } from '../usage.js';
+import { resolveCodexRollout, sessionsDir as codexSessionsDir } from '../agents/codex.js';
+import { enrichCodexFileDiffs } from '../codexDiff.js';
 
 // Pure index-based projection: O(page size), not O(transcript size). `before` stays exclusive, including
 // for unusual fractional cursors (the old `k < before` filter included indices through ceil(before) - 1).
@@ -36,20 +41,39 @@ export function pageTranscript(parsed, before, limit) {
   };
 }
 
-export function transcriptRoutes({ commands, claudeEvents, reader = transcriptReader }) {
+export function transcriptRoutes({
+  commands, claudeEvents, reader = transcriptReader, codexApp,
+  findCodexRollout = resolveCodexRollout, codexSessions = codexSessionsDir(),
+}) {
   const r = express.Router();
 
-  // These three endpoints are one Claude-specific lens surface. Gate them together so a future endpoint
-  // cannot accidentally skip the invariant: explicit non-Claude requests and panes already bound to a
-  // non-Claude hook record are rejected before any cwd→newest-Claude-session fallback or screen scraping.
+  // Bind every request to the pane's actual agent before touching a session file. A caller cannot claim
+  // Claude for a Codex pane (or vice versa) and make cwd fallback expose a different agent's conversation.
   r.use(['/pending-prompt', '/context', '/transcript'], (req, res, next) => {
     const pane = req.query.pane;
     if (!isPaneId(pane)) return res.status(400).json({ error: 'bad pane id' });
-    const requested = req.query.agent;
-    const bound = claudeEvents && claudeEvents.paneAgent ? claudeEvents.paneAgent(pane) : null;
-    if ((requested != null && requested !== '' && requested !== 'claude') || (bound && bound !== 'claude')) {
+    const requested = typeof req.query.agent === 'string' && req.query.agent ? req.query.agent : null;
+    const hooked = claudeEvents?.paneSession ? claudeEvents.paneSession(pane) : null;
+    const bound = (claudeEvents?.paneAgent ? claudeEvents.paneAgent(pane) : null) || hooked?.agent || null;
+    // Managed Codex is verified again through its pane-owned App Server and exact thread id below. Claude
+    // still fails closed against any conflicting Hook identity before cwd fallback.
+    if (requested && bound && requested !== bound && requested !== 'codex') {
+      return res.status(409).json({ error: 'pane agent mismatch' });
+    }
+    const id = requested === 'codex' ? 'codex' : (bound || requested || 'claude');
+    const agent = AGENTS.find((candidate) => candidate.id === id);
+    if (!agent || (agent.id !== 'codex' && !agent.transcript?.createParser)) {
       return res.status(409).json({ error: 'chat lens unsupported for this agent' });
     }
+    req.chatAgent = agent;
+    req.chatSession = hooked;
+    next();
+  });
+
+  // Claude's pending menus and context meter come from its TUI. Codex exposes both through App Server and
+  // therefore never calls these terminal-specific endpoints.
+  r.use(['/pending-prompt', '/context'], (req, res, next) => {
+    if (req.chatAgent.id !== 'claude') return res.status(409).json({ error: 'interactive chat controls unsupported for this agent' });
     next();
   });
 
@@ -69,7 +93,7 @@ export function transcriptRoutes({ commands, claudeEvents, reader = transcriptRe
   // The 对话 composer polls this to show a small "模型 · 24%" chip. Best-effort: never 500 on a missing file.
   r.get('/context', (req, res, next) => {
     try {
-      const hooked = claudeEvents && claudeEvents.paneSession ? claudeEvents.paneSession(req.query.pane) : null;
+      const hooked = req.chatSession;
       const sid = hooked && (hooked.sessionId || (hooked.transcriptPath ? path.basename(hooked.transcriptPath).replace(/\.jsonl$/, '') : null));
       const ctx = sid ? readClaudeContext(sid) : null;
       return res.json({ model: (ctx && ctx.model) || null, usedPercent: (ctx && typeof ctx.usedPercent === 'number') ? ctx.usedPercent : null });
@@ -80,16 +104,49 @@ export function transcriptRoutes({ commands, claudeEvents, reader = transcriptRe
     const limit = Math.min(Math.max(Number(req.query.limit) || 10, 1), 100);
     const before = req.query.before != null && req.query.before !== '' ? Number(req.query.before) : null;
     try {
-      // Bind pane→session via the hook state's per-pane transcript_path (authoritative — see claudeEvents
-      // .paneSession) when available; only a pane with no hook state (hooks off / not a Claude pane) falls
-      // back to cwd→newest-jsonl, which can't tell apart two sessions that share a cwd.
+      if (req.chatAgent.id === 'codex') {
+        const empty = { messages: [], hash: '', session: null, hasMore: false, firstSeq: null };
+        try {
+          const discovered = await codexApp?.discover?.(req.query.pane);
+          if (!discovered?.managed) return res.json({ ...empty, unavailable: 'session-unmanaged' });
+          const sessionId = discovered?.threadId || null;
+          if (!sessionId) return res.json({ ...empty, unavailable: 'session-unbound' });
+          const file = await findCodexRollout(codexSessions, sessionId);
+          // A newly started thread has no rollout until its first turn. Keep the exact session binding and
+          // show an empty conversation; the next poll will discover the file once Codex creates it.
+          if (!file) return res.json({ ...empty, session: sessionId });
+          const parsed = await reader.read(file, req.chatAgent.transcript.createParser);
+          const page = pageTranscript(parsed, before, limit);
+          let { messages } = page;
+          const { firstSeq, hasMore } = page;
+          const needsFileLines = messages.some((message) => message.tool?.name === 'apply_patch'
+            && message.tool.diff && !message.tool.diff.hunks?.length);
+          if (needsFileLines && codexApp?.read) {
+            try {
+              const opened = await codexApp.read(req.query.pane, sessionId);
+              messages = enrichCodexFileDiffs(messages, opened?.thread);
+            } catch { /* The rollout remains readable; an unavailable App Server must not fabricate lines. */ }
+          }
+          if (before == null) {
+            const hash = createHash('sha1').update(JSON.stringify(messages)).digest('hex').slice(0, 16);
+            if (req.query.since === hash) return res.status(204).end();
+            return res.json({ messages, hash, session: sessionId, hasMore, firstSeq });
+          }
+          return res.json({ messages, session: sessionId, hasMore, firstSeq });
+        } catch (error) {
+          return res.json({ ...empty, unavailable: 'app-server-unavailable', detail: error?.message || String(error) });
+        }
+      }
+
+      // Claude binds pane→session via Hook transcript_path, with its established cwd fallback.
       let file = null;
       let sessionId = null;
       const hooked = claudeEvents && claudeEvents.paneSession ? claudeEvents.paneSession(req.query.pane) : null;
-      if (hooked && hooked.transcriptPath) {
+      if (hooked?.transcriptPath) {
         file = hooked.transcriptPath;
         sessionId = hooked.sessionId || path.basename(file).replace(/\.jsonl$/, '');
       }
+      const empty = { messages: [], hash: '', session: sessionId || null, hasMore: false, firstSeq: null };
       if (!file) {
         const cwd = await commands.paneCurrentPath(req.query.pane);
         const dir = projectsDir();
@@ -99,9 +156,8 @@ export function transcriptRoutes({ commands, claudeEvents, reader = transcriptRe
           sessionId = resolved.sessionId;
         }
       }
-      const empty = { messages: [], hash: '', session: sessionId || null, hasMore: false, firstSeq: null };
       if (!file) return res.json(empty);
-      const parsed = await reader.read(file);
+      const parsed = await reader.read(file, req.chatAgent.transcript.createParser);
       const { messages, firstSeq, hasMore } = pageTranscript(parsed, before, limit);
       if (before == null) {
         const hash = createHash('sha1').update(JSON.stringify(messages)).digest('hex').slice(0, 16);

package/src/server.js

@@ -8,7 +8,7 @@ import { createApiRouter } from './httpApi.js';
 import { loadUploadExts } from './uploadTypes.js';
 import { createClaudeEvents } from './claudeEvents.js';
 import { syncHooks } from './cli/claudeHooks.js';
-import { syncCodexHooks } from './cli/codexHooks.js';
+import { removeLegacyCodexHooks } from './cli/legacyCodexHooks.js';
 import { claudeStatePath } from './cli/state.js';
 import * as commands from './tmux/commands.js';
 import * as push from './push.js';
@@ -26,6 +26,7 @@ import { createGracefulShutdown, createWorkspaceBackground } from './workspace/c
 import { createWorkspaceRuntime } from './workspace/runtime.js';
 import { createBrowserWorkerClient } from './browser/workerClient.js';
 import { createTerminalStream } from './terminalStream.js';
+import { createCodexAppServer } from './codexAppServer.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 
@@ -52,12 +53,14 @@ const observeEnvironment = createEnvironmentProvider({
   },
 });
 const stateFile = process.env.CLAUDE_STATE_FILE || claudeStatePath(home);
+let codexApp = null;
 const workspaceBackground = createWorkspaceBackground({
   store: workspaceStore,
   tmux: workspaceTmux,
   observeEnvironment,
   lock: workspaceLock,
   stateFile,
+  getCodexApp: () => codexApp,
 });
 const workspace = createWorkspaceRuntime({
   store: workspaceStore,
@@ -67,11 +70,19 @@ const workspace = createWorkspaceRuntime({
   home,
 });
 
-// The inbox is driven by a JSON state file the Claude hooks maintain (server/hooks/handmux-notify.sh →
-// handmux-write.js). We only READ it. start() watches it so idle/permission push fires even when no
-// client is polling; getStates reads it fresh on each /states.
-const events = createClaudeEvents({ commands, push, file: stateFile, onStateChange: workspace.requestReconcile });
+// Claude states come from Hooks; Codex states come only from App Server. Both feed the same inbox and
+// workspace checkpointer, but no Codex Hook state is accepted as a fallback.
+let events = null;
+codexApp = createCodexAppServer({
+  home,
+  onStateChange: () => {
+    if (!events) return;
+    events.getStates().then(() => workspace.requestReconcile()).catch(() => {});
+  },
+});
+events = createClaudeEvents({ commands, push, codexApp, file: stateFile, onStateChange: workspace.requestReconcile });
 events.start();
+codexApp.start();
 workspace.start().catch(() => {});
 
 // Keep an already-opted-in user's Claude hooks in step with this handmux version on restart: newly-added
@@ -84,12 +95,9 @@ try {
     stateFile,
   });
 } catch { /* best effort — hook sync never fails startup */ }
-try {
-  syncCodexHooks(home, {
-    srcDir: path.resolve(here, '../hooks'),
-    stateFile,
-  });
-} catch { /* best effort — hook sync never fails startup */ }
+// Versions before App Server support installed a marked Handmux block under ~/.codex. Remove only that
+// exact legacy block and Handmux-owned files; all user Codex configuration and third-party hooks remain.
+try { removeLegacyCodexHooks(home); } catch { /* best effort — migration never fails startup */ }
 
 // Static directory preview remains for folders without a web server. Arbitrary sites and local ports
 // use the built-in browser below; previewDomain may provide its dedicated public origin.
@@ -104,14 +112,13 @@ const handmuxOrigin = (() => {
   }
 })();
 const browserWorker = createBrowserWorkerClient({ appToken: token, previewDomain, handmuxOrigin });
-
 const app = express();
 // Browser proxy leases stay behind normal Handmux auth. Client-owned direct tabs never enter
 // server state; proxy operations and all claimed Hammerhead paths use the isolated worker.
 app.use(browserWorker.publicHandler);
 app.use('/api/browser-proxy', expressAuth(token), express.json(), browserWorker.apiHandler);
 app.use('/api', createApiRouter({
-  token, events, uploadExts, previews, shortcuts: cfg.shortcuts, workspace, previewDomain,
+  token, events, uploadExts, previews, shortcuts: cfg.shortcuts, workspace, previewDomain, codexApp,
 }));
 app.use('/preview', preview.router);
 app.use(preview.refererFallback);
@@ -172,6 +179,7 @@ server.on('upgrade', (req, socket, head) => {
 const shutdown = createGracefulShutdown({ events, workspace, browser: browserWorker, server });
 const handleSignal = () => {
   terminalStream.close();
+  codexApp.close();
   shutdown().catch(() => {});
 };
 process.on('SIGINT', handleSignal);

package/src/tmux/commands.js

@@ -53,9 +53,9 @@ export async function listWindows(sessionId) {
 }
 
 export async function listPanes(windowId) {
-  const out = await runTmux(['list-panes', '-t', windowId, '-F', tmuxFormat(['pane_id', 'pane_active', 'pane_width', 'pane_height', 'pane_current_command', 'pane_current_path', 'pane_left', 'pane_top'])]);
-  return parseTmuxRows(out, 8, 'pane').map(([id, active, width, height, command, cwd, left, top]) => {
-    return { id, active: active === '1', width: Number(width), height: Number(height), command, cwd, left: Number(left), top: Number(top) };
+  const out = await runTmux(['list-panes', '-t', windowId, '-F', tmuxFormat(['pane_id', 'pane_active', 'pane_width', 'pane_height', 'pane_current_command', 'pane_current_path', 'pane_left', 'pane_top', 'pane_tty'])]);
+  return parseTmuxRows(out, 9, 'pane').map(([id, active, width, height, command, cwd, left, top, tty]) => {
+    return { id, active: active === '1', width: Number(width), height: Number(height), command, cwd, left: Number(left), top: Number(top), tty };
   });
 }
 
@@ -250,6 +250,14 @@ async function runStartupCmd(target, cmd) {
   await sendEnter(target);
 }
 
+// Type a validated single-line command into an existing pane after its foreground TUI has returned to
+// the shell. This does not kill or replace anything; callers must first prove the previous process exited.
+export async function runPaneCommand(paneId, cmd) {
+  if (!isPaneId(paneId)) throw new Error(`invalid pane id: ${JSON.stringify(paneId)}`);
+  if (!isValidStartupCmd(cmd)) throw new Error('invalid startup command');
+  await runStartupCmd(paneId, cmd);
+}
+
 // Read a pane's working directory, so a new window can open in the dir you're working in.
 export async function paneCurrentPath(paneId) {
   const out = await runTmux(['display-message', '-p', '-t', paneId, '#{pane_current_path}']);

package/src/transcriptReader.js

@@ -47,13 +47,13 @@ export function createTranscriptReader({ maxEntries = 8, yieldEvery = 500 } = {}
     }
   }
 
-  async function load(file) {
+  async function load(file, createParser) {
     let st;
     try { st = await fsp.stat(file); } catch { cache.delete(file); return []; }
     if (!st.isFile()) { cache.delete(file); return []; }
 
     let entry = cache.get(file);
-    const sameFile = entry && entry.dev === st.dev && entry.ino === st.ino;
+    const sameFile = entry && entry.createParser === createParser && entry.dev === st.dev && entry.ino === st.ino;
     if (sameFile && entry.size === st.size && entry.mtimeMs === st.mtimeMs) {
       entry.usedAt = Date.now();
       return entry.parser.messages;
@@ -64,7 +64,7 @@ export function createTranscriptReader({ maxEntries = 8, yieldEvery = 500 } = {}
     // leak across /clear or log rotation.
     const append = sameFile && st.size > entry.size;
     if (!append) {
-      entry = { parser: createTranscriptParser(), offset: 0, dev: st.dev, ino: st.ino, size: 0, mtimeMs: 0, usedAt: 0 };
+      entry = { parser: createParser(), createParser, offset: 0, dev: st.dev, ino: st.ino, size: 0, mtimeMs: 0, usedAt: 0 };
     }
 
     const { lines, offset, size } = await readCompleteLines(file, entry.offset);
@@ -88,9 +88,9 @@ export function createTranscriptReader({ maxEntries = 8, yieldEvery = 500 } = {}
     return entry.parser.messages;
   }
 
-  async function read(file) {
+  async function read(file, createParser = createTranscriptParser) {
     if (inflight.has(file)) return inflight.get(file);
-    const run = load(file).finally(() => inflight.delete(file));
+    const run = load(file, createParser).finally(() => inflight.delete(file));
     inflight.set(file, run);
     return run;
   }

package/src/usage.js

@@ -14,7 +14,7 @@ import { pocketHome } from './cli/state.js';
 const require = createRequire(import.meta.url);
 const {
   readLatestUsage, readSnapshot, writeSnapshot,
-} = require('../hooks/handmux-codex-usage.cjs');
+} = require('./codexUsageSnapshot.cjs');
 
 export function claudeUsagePath(home = homedir()) { return path.join(pocketHome(home), 'claude-usage.json'); }
 export function claudeContextDir(home = homedir()) { return path.join(pocketHome(home), 'context'); }
@@ -63,8 +63,7 @@ function rolloutFilesByMtime(dir) {
   return files.sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 
-// Full reconciliation fallback. It remains zero-config, but now runs at most once per calibration interval;
-// the normal path reads the persistent snapshot written by Codex hooks.
+// Zero-config reconciliation runs at most once per calibration interval and updates a persistent cache.
 function scanCodexUsage(home) {
   let latest = null;
   for (const { file, mtimeMs } of rolloutFilesByMtime(codexSessionsDir(home))) {
@@ -75,8 +74,8 @@ function scanCodexUsage(home) {
   return latest;
 }
 
-// Prefer the machine-wide snapshot. A full rollout scan seeds it and calibrates it once per minute for
-// users without hooks; hook updates between calibrations are never rolled back by an older scan result.
+// Prefer the machine-wide cache. A bounded rollout scan refreshes it at most once per minute; App Server
+// supplies live account rate limits separately below.
 export function readCodexUsage(
   home = homedir(),
   { now = Date.now(), calibrationMs = 60_000 } = {},

package/src/workspace/agentRunner.js

@@ -8,6 +8,7 @@ import { ensurePrivateDir, writeJsonAtomic } from './atomicJson.js';
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const PANE_RE = /^%\d+$/;
 const RUNNER_FILE = fileURLToPath(import.meta.url);
+const HANDMUX_BIN = fileURLToPath(new URL('../../bin/handmux.js', import.meta.url));
 
 function errorText(error) {
   return error instanceof Error ? error.message : String(error);
@@ -55,7 +56,9 @@ export function launchAgentRequest(requestInput, {
     settleReady({ status: 'failed', error: earlyFailure(request, error, code) });
   };
   try {
-    child = spawn(request.cmd, request.args, { stdio: 'inherit', shell: false });
+    const command = request.cmd === 'codex' ? process.execPath : request.cmd;
+    const args = request.cmd === 'codex' ? [HANDMUX_BIN, 'codex', ...request.args] : request.args;
+    child = spawn(command, args, { stdio: 'inherit', shell: false });
   } catch (error) {
     failReady(error);
     finishCompletion({ code: null, signal: null, error: errorText(error) });

package/src/workspace/capture.js

@@ -1,6 +1,7 @@
 import fsp from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { AGENTS } from '../agents/index.js';
+import { resolveCodexRollout, sessionsDir as codexSessionsDir } from '../agents/codex.js';
 import { canonicalizeSnapshot, WORKSPACE_SCHEMA_VERSION } from './schema.js';
 
 function agentMap(agents) {
@@ -20,8 +21,11 @@ export async function readAgentBindings(stateFile, agents = AGENTS, readFile = f
   const bindings = new Map();
   for (const [paneRuntimeId, record] of Object.entries(state)) {
     if (!record || typeof record !== 'object' || Array.isArray(record)) continue;
-    const id = record.agent === undefined ? 'claude' : record.agent;
-    if (typeof id !== 'string' || !known.has(id)) continue;
+    // This is the Claude Hook state file. Legacy Codex-tagged rows are deliberately ignored; managed
+    // Codex identity belongs to App Server and must not be reconstructed from the removed Hook path.
+    if (record.agent !== undefined && record.agent !== 'claude') continue;
+    const id = 'claude';
+    if (!known.has(id)) continue;
     const payload = record.payload;
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) continue;
     const sessionId = payload.session_id;
@@ -37,6 +41,47 @@ export async function readAgentBindings(stateFile, agents = AGENTS, readFile = f
   return bindings;
 }
 
+function topologyPanes(topology) {
+  return topology.windows.flatMap((window) => window.panes);
+}
+
+export async function readManagedCodexBindings(topology, {
+  codexApp,
+  codexSessions = codexSessionsDir(),
+  agents = AGENTS,
+  findRollout = resolveCodexRollout,
+  access = fsp.access,
+  stat = fsp.stat,
+} = {}) {
+  if (typeof codexApp?.discover !== 'function') return new Map();
+  const panes = topologyPanes(topology);
+  const discovered = new Map(await Promise.all(panes.map(async (pane) => {
+    try {
+      const state = await codexApp.discover(pane.runtimeId);
+      return [pane.runtimeId, state?.managed ? state.threadId : null];
+    } catch {
+      return [pane.runtimeId, null];
+    }
+  })));
+
+  const driver = agents.find((agent) => agent.id === 'codex');
+  if (!driver) return new Map();
+  const bindings = new Map();
+  for (const pane of panes) {
+    const sessionId = discovered.get(pane.runtimeId);
+    if (!driver.sessions?.isId(sessionId)) continue;
+    let transcriptPath;
+    try {
+      transcriptPath = await findRollout(codexSessions, sessionId);
+      if (typeof transcriptPath !== 'string' || !transcriptPath) continue;
+      await access(transcriptPath, constants.R_OK);
+      if (!(await stat(transcriptPath)).isFile()) continue;
+    } catch { continue; }
+    bindings.set(pane.runtimeId, { id: 'codex', sessionId, transcriptPath });
+  }
+  return bindings;
+}
+
 export function attachBindings(topology, bindings) {
   return {
     ...topology,
@@ -59,6 +104,9 @@ export async function captureWorkspace({
   readFile = fsp.readFile,
   access = fsp.access,
   stat = fsp.stat,
+  codexApp,
+  codexSessions = codexSessionsDir(),
+  findCodexRollout = resolveCodexRollout,
   now = Date.now,
 }) {
   try {
@@ -67,6 +115,10 @@ export async function captureWorkspace({
     const topology = await tmux.captureTopology();
     if (!topology || topology.status === 'unknown') return { status: 'unknown' };
     const bindings = await readAgentBindings(stateFile, agents, readFile, access, stat);
+    const managedCodex = await readManagedCodexBindings(topology, {
+      codexApp, codexSessions, agents, findRollout: findCodexRollout, access, stat,
+    });
+    for (const [pane, binding] of managedCodex) bindings.set(pane, binding);
     const after = await tmux.topologyFingerprint();
     if (isUnknownFingerprint(after)) return { status: 'unknown' };
     if (before !== after) return { status: 'changed-during-capture' };

package/src/workspace/checkpointer.js

@@ -152,13 +152,17 @@ export function createCheckpointer({
   };
 }
 
-export function createWorkspaceBackground({ store, tmux, observeEnvironment, lock, stateFile, now = Date.now } = {}) {
+export function createWorkspaceBackground({
+  store, tmux, observeEnvironment, lock, stateFile, getCodexApp = () => null, codexSessions, now = Date.now,
+} = {}) {
   return createCheckpointer({
     store,
     observeEnvironment,
     lock,
     now,
-    capture: (environment) => captureWorkspace({ tmux, stateFile, environment, now }),
+    capture: (environment) => captureWorkspace({
+      tmux, stateFile, environment, codexApp: getCodexApp(), codexSessions, now,
+    }),
   });
 }