@idl3/claude-control 1.3.0 → 1.4.5

package/server.js

@@ -21,19 +21,23 @@ import * as tmux from './lib/tmux.js';
 import * as terminal from './lib/terminal.js';
 import * as shell from './lib/shell.js';
 import { TranscriptTailer } from './lib/transcript.js';
-import { SubAgentsWatcher, listAgents } from './lib/subagents.js';
+import { SubAgentsWatcher, CodexSubAgentsWatcher, listAgents } from './lib/subagents.js';
 import { parsePanePrompt } from './lib/prompt.js';
 import { SessionRegistry, listRecentTranscripts } from './lib/sessions.js';
 import { loadPins, savePins, validateTranscriptPath, pinKey } from './lib/pins.js';
+import { writePaneRegistryRecord } from './lib/pane-registry.js';
 import { ResourceMonitor, listProcesses, killProcess } from './lib/resources.js';
 import { buildAnswerProgram, parsePicker, planStep } from './lib/answer.js';
 import { sweepUploads, resolveUploadPath } from './lib/uploads.js';
 import { getVersionInfo, currentVersion } from './lib/version.js';
 import * as push from './lib/push.js';
 import { readConfig, writeConfig } from './lib/config.js';
-import { parseCodexRecord, parseCodexPrompt, buildSpawnCommand } from './lib/codex.js';
+import { parseCodexRecord, parseCodexPrompt, parseCodexSubagentNotificationRecord, buildSpawnCommand, buildAppServerCommand } from './lib/codex.js';
+import { CodexRpcManager, isCodexActiveStatus, isCodexAppServerCapture, parseCodexAppServerEndpoint } from './lib/codex-rpc.js';
+import { ClaudePrintManager, buildBridgeCommand } from './lib/claude-print.js';
 import { optimizePrompt, rulesOptimize } from './lib/optimize.js';
 import * as mlx from './lib/mlx.js';
+import { resolveClaudeBin } from './lib/claude-cli.js';
 import {
   MLX_MODELS,
   CLAUDE_MODELS,
@@ -83,6 +87,13 @@ const CONFIG = {
     env('PROJECTS') || path.join(os.homedir(), '.claude', 'projects'),
   codexSessionsRoot:
     env('CODEX_SESSIONS') || path.join(os.homedir(), '.codex', 'sessions'),
+  // Experimental Codex app-server transport. New Codex sessions use a tmux
+  // pane as a visible process pin, but replies/approvals move over JSON-RPC.
+  // Set CLAUDE_CONTROL_CODEX_TRANSPORT=tmux to force the legacy TUI-key path.
+  codexTransport: String(env('CODEX_TRANSPORT') || '').toLowerCase() === 'tmux' ? 'tmux' : 'rpc',
+  // Experimental Claude print-mode transport. New Claude sessions default to the
+  // interactive TUI unless CLAUDE_CONTROL_CLAUDE_TRANSPORT=print is set.
+  claudeTransport: String(env('CLAUDE_TRANSPORT') || '').toLowerCase() === 'print' ? 'print' : 'tmux',
   // 768MB: a long-running Node server (WS + transcript tailing + the bundled
   // web app) baselines ~300-450MB of V8 heap + RSS, so the old 350MB budget
   // tripped "over limit" permanently. Override with CLAUDE_CONTROL_RSS_LIMIT_MB.
@@ -95,6 +106,8 @@ const CONFIG = {
   maxUploadMB: Number(env('MAX_UPLOAD_MB')) || 25,
   uploadsDir:
     env('UPLOADS') || path.join(os.homedir(), '.claude-control', 'uploads'),
+  presentDir:
+    env('PRESENT') || path.join(os.homedir(), '.claude-control', 'present'),
   uploadTtlHours: Number(env('UPLOAD_TTL_HOURS')) || 24,
   pinsFile:
     env('PINS') || path.join(os.homedir(), '.claude-control', 'pins.json'),
@@ -113,6 +126,12 @@ const MIME = {
   '.ico': 'image/x-icon',
   '.json': 'application/json; charset=utf-8',
   '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webm': 'video/webm',
+  '.mp4': 'video/mp4',
+  '.txt': 'text/plain; charset=utf-8',
+  '.md': 'text/markdown; charset=utf-8',
   '.webmanifest': 'application/manifest+json; charset=utf-8',
 };
 
@@ -132,6 +151,8 @@ const IMAGE_MIME = {
 // --- shared state -----------------------------------------------------------
 const registry = new SessionRegistry({ projectsRoot: CONFIG.projectsRoot, codexSessionsRoot: CONFIG.codexSessionsRoot, tmux });
 const resources = new ResourceMonitor({ rssLimitMB: CONFIG.rssLimitMB });
+const codexRpc = new CodexRpcManager();
+const claudePrint = new ClaudePrintManager();
 
 // Manual transcript pins (windowId.paneIndex -> transcript path). Loaded at boot,
 // applied to the registry, and editable via /api/pins.
@@ -139,6 +160,8 @@ let pins = loadPins(CONFIG.pinsFile);
 
 /** id -> { tailer, clients:Set<ws>, pending } */
 const subscriptions = new Map();
+const RAW_EVENT_LIMIT = 200;
+const rawEventsById = new Map();
 
 function sessionById(id) {
   return registry.getSessions().find((s) => s.id === id) || null;
@@ -370,11 +393,15 @@ const _handler = (req, res) => {
           {
             id: 'claude',
             available: claudeResult.available,
+            defaultTransport: CONFIG.claudeTransport,
+            transports: ['tmux', 'print'],
             ...(claudeResult.available ? {} : { reason: claudeResult.reason }),
           },
           {
             id: 'codex',
             available: codexResult.available,
+            defaultTransport: CONFIG.codexTransport,
+            transports: ['rpc', 'tmux'],
             ...(codexResult.available ? {} : { reason: codexResult.reason }),
           },
         ],
@@ -424,6 +451,14 @@ const _handler = (req, res) => {
     return proxyTerminalHttp(req, res, u);
   }
 
+  // Public presentation artifacts (screenshots, videos, one-off demos) live
+  // under ~/.claude-control/present and are intentionally iframe-friendly.
+  // This is a confined static surface: no directory listing, no writes, and no
+  // filesystem paths outside presentDir.
+  if (u.pathname === '/present' || u.pathname.startsWith('/present/')) {
+    return servePresent(u.pathname, res);
+  }
+
   // Unknown /api/* path: return JSON 404 instead of falling through to the SPA.
   if (u.pathname.startsWith('/api/')) return endJson(res, 404, { error: 'not found' });
 
@@ -707,19 +742,27 @@ function handleTranscribe(req, res, u) {
 }
 
 // ---------------------------------------------------------------------------
-// resolveBin — async PATH lookup for a binary name or absolute path.
+function commandHead(command) {
+  const text = String(command || '').trim();
+  const m = /^(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(text);
+  return m ? (m[1] || m[2] || m[3] || '') : '';
+}
+
+// resolveBin — async lookup for a configured launch command.
 //
-// If `bin` is an absolute path, checks it is executable directly.
-// Otherwise runs `which <bin>` on PATH.
+// If the first command word is an absolute path, checks it is executable
+// directly. Otherwise resolves it via PATH and then the user's login shell so
+// aliases/functions such as `yodex` are treated the same way as the tmux pane
+// that will receive the typed command.
 //
 // Returns { available: true, path } on success, { available: false, reason }
 // on failure. Never throws.
 // ---------------------------------------------------------------------------
 async function resolveBin(bin) {
-  if (!bin || typeof bin !== 'string' || !bin.trim()) {
+  const b = commandHead(bin);
+  if (!b) {
     return { available: false, reason: 'no binary configured' };
   }
-  const b = bin.trim();
   // Absolute path: check existence + execute permission directly.
   if (b.startsWith('/')) {
     try {
@@ -736,7 +779,33 @@ async function resolveBin(bin) {
     if (resolved) return { available: true, path: resolved };
     return { available: false, reason: `${b} not found on PATH` };
   } catch {
-    return { available: false, reason: `${b} not found on PATH` };
+    // Fall through to the user's login shell; aliases/functions are only visible
+    // there, but the lookup script itself is fixed and receives `b` as argv.
+  }
+  try {
+    const shell = process.env.SHELL || '/bin/zsh';
+    const { stdout } = await _execFile(
+      shell,
+      ['-lic', 'command -v -- "$1"', 'claude-control-resolve', b],
+      { timeout: 5000 },
+    );
+    const resolved = stdout.trim();
+    if (resolved) return { available: true, path: resolved };
+    return { available: false, reason: `${b} not found in login shell` };
+  } catch {
+    return { available: false, reason: `${b} not found in login shell` };
+  }
+}
+
+async function resolvePaneTarget(target) {
+  if (String(target || '').includes('.')) return target;
+  try {
+    const panes = await tmux.listPanes();
+    const pane = panes.find((p) => p.target === target) ||
+      panes.find((p) => p.target.startsWith(`${target}.`));
+    return pane?.target || target;
+  } catch {
+    return target;
   }
 }
 
@@ -758,6 +827,14 @@ async function handleSessionNew(req, res) {
 
   // agent ∈ {'claude','codex'}, default 'claude'.
   const agent = body.agent === 'codex' ? 'codex' : 'claude';
+  const claudeTransport =
+    body.claudeTransport === 'print' || body.claudeTransport === 'tmux'
+      ? body.claudeTransport
+      : CONFIG.claudeTransport;
+  const codexTransport =
+    body.codexTransport === 'tmux' || body.codexTransport === 'rpc'
+      ? body.codexTransport
+      : CONFIG.codexTransport;
 
   // Name is required-with-default: sanitize the requested name, falling back to
   // `session-<short-ts>` so a session is ALWAYS named (the rail reads the tmux
@@ -769,15 +846,17 @@ async function handleSessionNew(req, res) {
   // (i) Resolve the agent binary and return 400 if unavailable.
   const agentBin = agent === 'codex'
     ? (config.codexBin || config.codexLaunchCommand)
-    : (config.claudeBin || config.launchCommand);
+    : (agent === 'claude' && claudeTransport === 'print'
+      ? (resolveClaudeBin() || 'claude')
+      : (config.claudeBin || config.launchCommand));
   const binCheck = await resolveBin(agentBin);
   if (!binCheck.available) {
     return endJson(res, 400, { error: `agent binary unavailable: ${binCheck.reason}` });
   }
 
-  // (ii) For codex: pre-validate cwd exists and is a directory BEFORE createWindow,
-  //      so a bad request creates NO window (400 not 500, window-leak prevention).
-  if (agent === 'codex') {
+  // (ii) For structured transports: pre-validate cwd exists and is a directory
+  //      BEFORE createWindow, so a bad request creates NO window.
+  if (agent === 'codex' || (agent === 'claude' && claudeTransport === 'print')) {
     try {
       const st = await fsp.stat(cwd);
       if (!st.isDirectory()) {
@@ -795,16 +874,42 @@ async function handleSessionNew(req, res) {
     const target = await tmux.createWindow({ cwd, name });
 
     let launch;
+    let codexRpcEndpoint = null;
+    let printPaneTarget = target;
+    let printClient = null;
     if (agent === 'codex') {
-      // Codex path: uses -C <cwd> (its own cwd flag). No --name flag — Codex
-      // has none. The tmux window is still named (above) so the rail shows it.
-      // buildSpawnCommand is the single source of truth for Codex's launch
-      // shape; the cwd arg is shell-quoted since the command is typed into an
-      // interactive shell via sendText. The executed command is
-      // config.codexLaunchCommand (may be a shell alias), validated above via
-      // codexBin||codexLaunchCommand — same pattern as the Claude branch.
-      const { bin, args } = buildSpawnCommand({ cwd, bin: config.codexLaunchCommand });
-      launch = `${bin} ${args.map((a) => (a === cwd ? tmux.shellQuoteName(cwd) : a)).join(' ')}`;
+      const codexCommand = config.codexBin || config.codexLaunchCommand;
+      if (codexTransport === 'rpc') {
+        codexRpcEndpoint = await codexRpc.prepareEndpoint(target);
+        const { bin, args } = buildAppServerCommand({ endpoint: codexRpcEndpoint, bin: codexCommand });
+        launch = `${bin} ${args.map((a) => (a === codexRpcEndpoint ? tmux.shellQuoteName(a) : a)).join(' ')}`;
+      } else {
+        // Legacy Codex path: uses -C <cwd> (its own cwd flag). No --name flag —
+        // Codex has none. The tmux window is still named (above) so the rail
+        // shows it. buildSpawnCommand is the single source of truth for Codex's
+        // launch shape; the cwd arg is shell-quoted since the command is typed
+        // into an interactive shell via sendText.
+        const { bin, args } = buildSpawnCommand({ cwd, bin: codexCommand });
+        launch = `${bin} ${args.map((a) => (a === cwd ? tmux.shellQuoteName(cwd) : a)).join(' ')}`;
+      }
+    } else if (claudeTransport === 'print') {
+      printPaneTarget = await resolvePaneTarget(target);
+      const socketPath = claudePrint.endpointFor(printPaneTarget);
+      printClient = await claudePrint.attach({ target: printPaneTarget, socketPath, cwd });
+      await tmux.setPaneOption(printPaneTarget, '@cc_agent', 'claude');
+      await tmux.setPaneOption(printPaneTarget, '@cc_transport', 'print');
+      await tmux.setPaneOption(printPaneTarget, '@cc_endpoint', socketPath);
+      const bridgePath = path.join(__dirname, 'bin', 'claude-print-bridge.mjs');
+      const claudeBin = binCheck.path || resolveClaudeBin() || commandHead(agentBin);
+      launch = buildBridgeCommand({
+        bridgePath,
+        socketPath,
+        cwd,
+        claudeBin,
+        name,
+        permissionMode: 'acceptEdits',
+        quote: tmux.shellQuoteName,
+      });
     } else {
       // Claude path: BYTE-IDENTICAL to the pre-Phase-D implementation.
       // (2) Claude's own session title: `claude --help` exposes `-n/--name`
@@ -816,8 +921,26 @@ async function handleSessionNew(req, res) {
       launch = `${config.launchCommand} --name ${tmux.shellQuoteName(name)}`;
     }
 
+    if (agent === 'codex') {
+      await tmux.setPaneOption(target, '@cc_agent', 'codex');
+      await tmux.setPaneOption(target, '@cc_transport', codexTransport);
+      if (codexRpcEndpoint) await tmux.setPaneOption(target, '@cc_endpoint', codexRpcEndpoint);
+    }
+
     await tmux.sendText(target, launch);
-    return endJson(res, 200, { ok: true, target, name, agent });
+    if (printClient) {
+      await printClient.waitForBridge();
+    }
+    if (agent === 'codex' && codexRpcEndpoint) {
+      await codexRpc.attach({ target, endpoint: codexRpcEndpoint, cwd });
+    }
+    return endJson(res, 200, {
+      ok: true,
+      target: printPaneTarget,
+      name,
+      agent,
+      transport: agent === 'codex' ? codexTransport : claudeTransport,
+    });
   } catch (err) {
     return endJson(res, 500, { error: String(err?.message || err) });
   }
@@ -1016,6 +1139,21 @@ async function handleSetPin(req, res) {
   } catch (err) {
     return endJson(res, 400, { error: String(err?.message || err) });
   }
+  // Global "re-match all windows": drop every manual pin so every pane falls
+  // back to the SessionStart-hook binding (the accurate, current transcript).
+  // Used by the "Re-match all" command to recover from stale pins in bulk.
+  if (body?.all === true) {
+    pins = {};
+    try {
+      savePins(CONFIG.pinsFile, pins);
+    } catch (err) {
+      return endJson(res, 500, { error: String(err?.message || err) });
+    }
+    registry.setPins(pins);
+    await registry.refresh().catch(() => {});
+    return endJson(res, 200, { ok: true, pins });
+  }
+
   const id = typeof body?.id === 'string' ? body.id : '';
   const session = sessionById(id);
   if (!session) return endJson(res, 404, { error: 'unknown session' });
@@ -1035,6 +1173,9 @@ async function handleSetPin(req, res) {
     return endJson(res, 500, { error: String(err?.message || err) });
   }
   registry.setPins(pins);
+  // Re-run the matcher NOW so clearing/setting a pin re-binds immediately
+  // (otherwise the change only lands on the next 4 s refresh tick).
+  await registry.refresh().catch(() => {});
   return endJson(res, 200, { ok: true, pins });
 }
 
@@ -1066,6 +1207,34 @@ function serveStatic(pathname, res) {
   });
 }
 
+function servePresent(pathname, res) {
+  let rel;
+  try {
+    rel = decodeURIComponent(pathname.replace(/^\/present\/?/, ''));
+  } catch {
+    res.writeHead(400); return res.end('bad request');
+  }
+  if (!rel || rel.endsWith('/')) rel = path.join(rel, 'index.html');
+  const root = path.resolve(CONFIG.presentDir);
+  const full = path.resolve(root, rel);
+  if (full !== root && !full.startsWith(root + path.sep)) {
+    res.writeHead(403); return res.end('forbidden');
+  }
+  fs.readFile(full, (err, data) => {
+    if (err) {
+      res.writeHead(404);
+      return res.end('not found');
+    }
+    const ext = path.extname(full).toLowerCase();
+    res.writeHead(200, {
+      'content-type': MIME[ext] || 'application/octet-stream',
+      'cache-control': 'no-store, must-revalidate',
+      'x-content-type-options': 'nosniff',
+    });
+    res.end(data);
+  });
+}
+
 // Serve the SPA shell (index.html) for client-side routes.
 function serveIndexHtml(res) {
   fs.readFile(path.join(PUBLIC_DIR, 'index.html'), (err, data) => {
@@ -1219,6 +1388,181 @@ function broadcastTo(id, obj) {
   for (const ws of sub.clients) if (ws.readyState === ws.OPEN) ws.send(msg);
 }
 
+function rawSummary(value, max = 240) {
+  const text = typeof value === 'string'
+    ? value
+    : (() => {
+        try { return JSON.stringify(value); } catch { return String(value); }
+      })();
+  const compact = text.replace(/\s+/g, ' ').trim();
+  return compact.length > max ? compact.slice(0, max - 1) + '…' : compact;
+}
+
+function emitRawEvent(id, event) {
+  if (!id) return;
+  const entry = {
+    ts: Date.now(),
+    source: event.source || 'server',
+    kind: event.kind || 'event',
+    summary: rawSummary(event.summary ?? ''),
+    detail: event.detail ?? null,
+  };
+  const prev = rawEventsById.get(id) ?? [];
+  const next = [...prev, entry];
+  rawEventsById.set(id, next.length > RAW_EVENT_LIMIT ? next.slice(next.length - RAW_EVENT_LIMIT) : next);
+  broadcastTo(id, { type: 'raw-event', id, event: entry });
+}
+
+codexRpc.on('thread', (id, opened) => {
+  const thread = opened?.thread || {};
+  const transcriptPath = thread.path ?? null;
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'thread',
+    summary: `thread ${thread.id || '(unknown)'} ${transcriptPath || ''}`,
+    detail: { threadId: thread.id ?? null, transcriptPath },
+  });
+  registry.setTranscriptHint(id, {
+    transcriptPath,
+    sessionId: thread.id ?? null,
+  });
+  if (transcriptPath) {
+    (async () => {
+      const panes = await tmux.listPanes();
+      const pane = panes.find((p) => p.target === id) ||
+        panes.find((p) => p.target.startsWith(`${id}.`));
+      if (!pane?.paneId) return;
+      await writePaneRegistryRecord({
+        paneId: pane.paneId,
+        sessionId: thread.id ?? null,
+        transcriptPath,
+        cwd: pane.cwd ?? null,
+      });
+    })().catch(() => {});
+  }
+});
+codexRpc.on('messages', (id, messages) => {
+  const sub = subscriptions.get(id);
+  if (sub?.tailer) return;
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'messages',
+    summary: `${messages?.length ?? 0} message(s)`,
+    detail: { messages },
+  });
+  broadcastTo(id, { type: 'append', id, messages });
+});
+codexRpc.on('prompt', (id, prompt) => {
+  registry.setPrompt(id, prompt);
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'prompt',
+    summary: prompt ? prompt.question : 'cleared',
+    detail: prompt,
+  });
+  broadcastTo(id, { type: 'prompt', id, prompt });
+});
+codexRpc.on('pending', (id, pending) => {
+  registry.setPending(id, !!pending);
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'pending',
+    summary: pending ? 'pending true' : 'pending false',
+  });
+});
+codexRpc.on('status', (id, status) => {
+  registry.setThinking(id, isCodexActiveStatus(status));
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'status',
+    summary: status ?? 'null',
+    detail: status,
+  });
+});
+codexRpc.on('subagent', (id, update) => {
+  const sub = subscriptions.get(id);
+  sub?.subagents?.ingest?.(update);
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'subagent',
+    summary: `${update.agentId} ${update.state}`,
+    detail: update,
+  });
+});
+codexRpc.on('raw', (id, event) => {
+  emitRawEvent(id, {
+    source: event.source || 'codex-rpc',
+    kind: event.kind || 'rpc',
+    summary: event.summary || event.method || '',
+    detail: event,
+  });
+});
+codexRpc.on('error', (id, err) => {
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'error',
+    summary: String(err?.message || err),
+  });
+  broadcastTo(id, {
+    type: 'ack',
+    op: 'codex-rpc',
+    ok: false,
+    error: String(err?.message || err),
+  });
+});
+codexRpc.on('close', (id) => {
+  registry.setPending(id, false);
+  registry.setPrompt(id, null);
+  registry.setThinking(id, false);
+  emitRawEvent(id, {
+    source: 'codex-rpc',
+    kind: 'close',
+    summary: 'closed',
+  });
+  broadcastTo(id, { type: 'prompt', id, prompt: null });
+});
+
+claudePrint.on('thread', (id, thread) => {
+  const transcriptPath = thread?.transcriptPath ?? null;
+  registry.setTranscriptHint(id, {
+    transcriptPath,
+    sessionId: thread?.sessionId ?? null,
+  });
+  if (transcriptPath) {
+    (async () => {
+      const panes = await tmux.listPanes();
+      const pane = panes.find((p) => p.target === id) ||
+        panes.find((p) => p.target.startsWith(`${id}.`));
+      if (!pane?.paneId) return;
+      await writePaneRegistryRecord({
+        paneId: pane.paneId,
+        sessionId: thread?.sessionId ?? null,
+        transcriptPath,
+        cwd: pane.cwd ?? null,
+      });
+    })().catch(() => {});
+  }
+});
+claudePrint.on('messages', (id, messages) => {
+  const sub = subscriptions.get(id);
+  if (sub?.tailer) return;
+  broadcastTo(id, { type: 'append', id, messages });
+});
+claudePrint.on('status', (id, status) => {
+  registry.setThinking(id, status === 'active');
+});
+claudePrint.on('error', (id, err) => {
+  broadcastTo(id, {
+    type: 'ack',
+    op: 'claude-print',
+    ok: false,
+    error: String(err?.message || err),
+  });
+});
+claudePrint.on('close', (id) => {
+  registry.setThinking(id, false);
+});
+
 function ensureSubscription(id) {
   let sub = subscriptions.get(id);
   if (sub) {
@@ -1243,16 +1587,39 @@ function ensureSubscription(id) {
   // `capture` and accepts `reply`, and a later refresh that matches the
   // transcript upgrades the subscription (see the tailer-null branch above).
   if (!session.transcriptPath) {
-    sub = { tailer: null, clients: new Set(), pending: null, ready: Promise.resolve() };
+    const subagents = session.kind === 'codex' ? new CodexSubAgentsWatcher() : null;
+    sub = { tailer: null, subagents, clients: new Set(), pending: null, ready: Promise.resolve() };
     subscriptions.set(id, sub);
-    startPromptPoller(id, sub);
+    if (subagents) {
+      subagents.on('change', (entry) =>
+        broadcastTo(id, { type: 'subagent', id, subagent: entry }),
+      );
+    }
+    if (!codexRpc.has(id) && session.transport !== 'print') startPromptPoller(id, sub);
     return sub;
   }
 
-  const tailer = new TranscriptTailer(session.transcriptPath, { maxBuffer: CONFIG.maxBuffer, parser: session.kind === 'codex' ? parseCodexRecord : undefined });
   // Watch this session's sub-agent transcripts (Task/Agent). Discovery is polled
   // when the parent transcript grows (when sub-agents spawn) + once at subscribe.
-  const subagents = new SubAgentsWatcher(session.transcriptPath);
+  const subagents = session.kind === 'codex'
+    ? new CodexSubAgentsWatcher()
+    : new SubAgentsWatcher(session.transcriptPath);
+  const parser = session.kind === 'codex'
+    ? (line) => {
+        const update = parseCodexSubagentNotificationRecord(line);
+        if (update) {
+          subagents.ingest(update);
+          emitRawEvent(id, {
+            source: 'codex-transcript',
+            kind: 'subagent',
+            summary: `${update.agentId} ${update.state}`,
+            detail: update,
+          });
+        }
+        return parseCodexRecord(line);
+      }
+    : undefined;
+  const tailer = new TranscriptTailer(session.transcriptPath, { maxBuffer: CONFIG.maxBuffer, parser });
   sub = { tailer, subagents, clients: new Set(), pending: null };
   subscriptions.set(id, sub);
 
@@ -1261,6 +1628,12 @@ function ensureSubscription(id) {
   );
 
   tailer.on('append', (msgs) => {
+    emitRawEvent(id, {
+      source: session.kind === 'codex' ? 'codex-transcript' : 'transcript',
+      kind: 'append',
+      summary: `${msgs.length} message(s)`,
+      detail: { messages: msgs },
+    });
     broadcastTo(id, { type: 'append', id, messages: msgs });
     // A sub-agent may have just spawned (poll for its files) or finished (its
     // Task tool-call produced a tool_result → mark it done).
@@ -1274,6 +1647,12 @@ function ensureSubscription(id) {
   tailer.on('pending', (pending) => {
     sub.pending = pending;
     registry.setPending(id, !!pending);
+    emitRawEvent(id, {
+      source: 'transcript',
+      kind: 'pending',
+      summary: pending ? pending.questions?.[0]?.question || 'pending true' : 'pending false',
+      detail: pending,
+    });
     broadcastTo(id, { type: 'pending', id, pending });
   });
   tailer.on('error', (err) => broadcastTo(id, { type: 'ack', op: 'tail', ok: false, error: String(err?.message || err) }));
@@ -1295,10 +1674,102 @@ function ensureSubscription(id) {
     if (doneIds.size) subagents.markDone(doneIds);
   });
   sub.ready.catch(() => {}); // errors surface via the per-subscribe await below
-  startPromptPoller(id, sub);
+  if (!codexRpc.has(id) && session.transport !== 'print') startPromptPoller(id, sub);
   return sub;
 }
 
+function sendSubscriptionSnapshot(ws, id, sub) {
+  const liveMessages = claudePrint.has(id)
+    ? claudePrint.messages(id)
+    : codexRpc.messages(id);
+  send(ws, {
+    type: 'messages',
+    id,
+    // Tailer-less RPC-backed Codex subscriptions keep an in-memory message
+    // buffer fed by app-server notifications. Claude print mode does the same
+    // through its bridge until a real transcript tailer is available.
+    messages: sub.tailer ? sub.tailer.getMessages() : liveMessages,
+    pending: sub.tailer ? sub.tailer.getPending() : null,
+  });
+  const rpcPrompt = codexRpc.prompt(id);
+  if (rpcPrompt) send(ws, { type: 'prompt', id, prompt: rpcPrompt });
+  // Snapshot any already-running sub-agents for this session.
+  const subs = sub.subagents ? sub.subagents.snapshot() : [];
+  if (subs.length) send(ws, { type: 'subagents', id, subagents: subs });
+  const rawEvents = rawEventsById.get(id) ?? [];
+  if (rawEvents.length) send(ws, { type: 'raw-events', id, events: rawEvents });
+}
+
+function upgradeSubscriptionIfTranscriptReady(id) {
+  const old = subscriptions.get(id);
+  if (!old || old.tailer) return;
+  const session = sessionById(id);
+  if (!session?.transcriptPath) return;
+
+  const clients = new Set(old.clients);
+  if (old.promptTimer) clearInterval(old.promptTimer);
+  subscriptions.delete(id);
+
+  const next = ensureSubscription(id);
+  if (!next) return;
+  for (const ws of clients) next.clients.add(ws);
+
+  next.ready.then(() => {
+    for (const ws of clients) {
+      if (ws.readyState === ws.OPEN && next.clients.has(ws)) {
+        sendSubscriptionSnapshot(ws, id, next);
+      }
+    }
+  }).catch((err) => {
+    for (const ws of clients) {
+      send(ws, { type: 'ack', op: 'subscribe', ok: false, error: String(err?.message || err) });
+    }
+  });
+}
+
+async function ensureCodexRpcForSession(session) {
+  if (session.kind !== 'codex') return null;
+  if (session.transport !== 'rpc') return null;
+  const existing = codexRpc.get(session.target);
+  if (existing) return existing;
+
+  let capture = '';
+  try {
+    capture = await tmux.capturePane(session.target, 200, false, true);
+  } catch {
+    return null;
+  }
+  const endpoint = parseCodexAppServerEndpoint(capture);
+  if (!endpoint) {
+    if (isCodexAppServerCapture(capture)) {
+      throw new Error('Codex RPC app-server endpoint unavailable; refusing to type prompt into tmux pane');
+    }
+    return null;
+  }
+
+  return codexRpc.ensureAttached({
+    target: session.target,
+    endpoint,
+    cwd: session.cwd,
+    resumeThreadId: session.sessionId,
+    transcriptPath: session.transcriptPath,
+  });
+}
+
+async function ensureClaudePrintForSession(session) {
+  if (session.kind !== 'claude' || session.transport !== 'print') return null;
+  const existing = claudePrint.get(session.target);
+  if (existing) return existing;
+  const socketPath = session.endpoint || claudePrint.endpointFor(session.target);
+  const client = await claudePrint.attach({
+    target: session.target,
+    socketPath,
+    cwd: session.cwd,
+  });
+  await client.waitForBridge();
+  return client;
+}
+
 // Poll the live pane for a TUI selection prompt (permission/trust/numbered menu).
 // These never reach the transcript, so without this the cockpit shows a pending
 // tool-call and looks stuck. Broadcasts a `prompt` frame only when it changes.
@@ -1314,7 +1785,9 @@ function startPromptPoller(id, sub) {
       if (!session || !tmux.isValidTarget(session.target)) return;
       let prompt = null;
       try {
-        const cap = await tmux.capturePane(session.target, 40);
+        // 80 lines so a tall AskUserQuestion (question + 5 multi-line options +
+        // footer) fits the parser window (parsePanePrompt BOTTOM_REGION).
+        const cap = await tmux.capturePane(session.target, 80);
         prompt = session.kind === 'codex' ? parseCodexPrompt(cap) : parsePanePrompt(cap);
       } catch {
         return;
@@ -1322,6 +1795,12 @@ function startPromptPoller(id, sub) {
       const json = prompt ? JSON.stringify(prompt) : null;
       if (json !== sub._lastPrompt) {
         sub._lastPrompt = json;
+        emitRawEvent(id, {
+          source: session.kind === 'codex' ? 'codex-tui' : 'tui',
+          kind: 'prompt',
+          summary: prompt ? prompt.question : 'cleared',
+          detail: prompt,
+        });
         broadcastTo(id, { type: 'prompt', id, prompt });
       }
     } finally {
@@ -1386,16 +1865,7 @@ async function handleClientMessage(ws, msg) {
       }
       // Client may have unsubscribed/closed while we awaited.
       if (!sub.clients.has(ws)) return;
-      send(ws, {
-        type: 'messages',
-        id: msg.id,
-        // Tailer-less subscription (no matched transcript): no history to send.
-        messages: sub.tailer ? sub.tailer.getMessages() : [],
-        pending: sub.tailer ? sub.tailer.getPending() : null,
-      });
-      // Snapshot any already-running sub-agents for this session.
-      const subs = sub.subagents ? sub.subagents.snapshot() : [];
-      if (subs.length) send(ws, { type: 'subagents', id: msg.id, subagents: subs });
+      sendSubscriptionSnapshot(ws, msg.id, sub);
       return;
     }
     case 'unsubscribe': {
@@ -1409,6 +1879,35 @@ async function handleClientMessage(ws, msg) {
       if (!tmux.isValidTarget(session.target)) throw new Error('invalid tmux target');
       const replyText = String(msg.text ?? '');
       return runSerial(session.target, async () => {
+        if (session.kind === 'claude' && session.transport === 'print') {
+          await ensureClaudePrintForSession(session);
+          registry.setThinking(session.target, true);
+          try {
+            claudePrint.submit(session.target, replyText);
+          } catch (err) {
+            registry.setThinking(session.target, false);
+            throw err;
+          }
+          send(ws, { type: 'ack', op: 'reply', ok: true, transport: 'claude-print' });
+          return;
+        }
+        if (session.kind === 'codex') {
+          const codexClient = await ensureCodexRpcForSession(session);
+          if (codexClient) {
+            registry.setThinking(session.target, true);
+            try {
+              await codexRpc.submit(session.target, replyText, { cwd: session.cwd });
+            } catch (err) {
+              registry.setThinking(session.target, false);
+              throw err;
+            }
+            send(ws, { type: 'ack', op: 'reply', ok: true, transport: 'codex-rpc' });
+            return;
+          }
+          // Codex TUI compatibility: only non-app-server Codex panes may use
+          // tmux keystrokes. RPC app-server panes must never receive prompt text
+          // in their terminal buffer.
+        }
         await tmux.sendText(session.target, replyText);
         send(ws, { type: 'ack', op: 'reply', ok: true });
       });
@@ -1678,7 +2177,34 @@ async function handleClientMessage(ws, msg) {
       if (!ALLOWED.has(msg.key)) throw new Error('key not allowed');
       const promptKey = msg.key;
       return runSerial(session.target, async () => {
-        await tmux.sendRawKeys(session.target, [promptKey]);
+        if (session.kind === 'claude' && session.transport === 'print') {
+          if (promptKey !== 'Escape') throw new Error('key not allowed for Claude print mode');
+          await ensureClaudePrintForSession(session);
+          claudePrint.cancel(session.target);
+          registry.setThinking(session.target, false);
+          send(ws, { type: 'ack', op: 'promptkey', ok: true, transport: 'claude-print' });
+          return;
+        }
+        if (session.kind === 'codex') {
+          const codexClient = await ensureCodexRpcForSession(session);
+          if (codexClient && codexRpc.prompt(session.target)) {
+            codexRpc.answerPrompt(session.target, promptKey);
+            const sub = subscriptions.get(msg.id);
+            if (sub) sub._lastPrompt = '__force__';
+            send(ws, { type: 'ack', op: 'promptkey', ok: true, transport: 'codex-rpc' });
+            return;
+          }
+          // Codex TUI compatibility only; app-server panes are rejected inside
+          // ensureCodexRpcForSession when an RPC endpoint cannot be attached.
+        }
+        // Codex TUI confirms a numbered choice with <digit> THEN Enter ("Press
+        // enter to confirm"); the digit alone only moves the highlight.
+        const isDigit = /^[1-9]$/.test(promptKey);
+        if (session.kind === 'codex' && isDigit) {
+          await tmux.sendRawKeysSequenced(session.target, [promptKey, 'Enter'], 120);
+        } else {
+          await tmux.sendRawKeys(session.target, [promptKey]);
+        }
         // Force the next poll tick to broadcast (the prompt should now change/clear).
         const sub = subscriptions.get(msg.id);
         if (sub) sub._lastPrompt = '__force__';
@@ -1834,6 +2360,9 @@ function firePushForChange(sessions) {
 }
 
 registry.on('change', (sessions) => {
+  codexRpc.sweep(sessions.map((s) => s.id));
+  claudePrint.sweep(sessions.map((s) => s.id));
+  for (const s of sessions) upgradeSubscriptionIfTranscriptReady(s.id);
   firePushForChange(sessions);
   broadcast({ type: 'sessions', sessions });
 });