create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/chat-driver.mjs

@@ -0,0 +1,220 @@
+import { appendChatEnvelope } from './chat-store.mjs';
+
+// ── Chat driver factory + live registry ──
+// One structured-stdio driver per chat session. Driver MODULES are built by
+// parallel workers and resolved lazily via dynamic import here; this module
+// owns the seams: the canonical onEvent pipeline (seq assignment + persistence
+// + broadcast), turn-state tracking for steering, and the live registry that
+// sendTo/interrupt/approve/dispose operate on.
+export class ChatDriverError extends Error {
+  constructor(message, code = 'CHAT_DRIVER_ERROR', details = null) {
+    super(message);
+    this.name = 'ChatDriverError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+const CHAT_DRIVER_MODULES = {
+  claude: () => import('./drivers/claude-stream-json.mjs'),
+  cc: () => import('./drivers/claude-stream-json.mjs'),
+  codex: () => import('./drivers/codex-appserver.mjs'),
+  opencode: () => import('./drivers/opencode-server.mjs'),
+};
+
+/** sessionId -> { sessionId, runtime, driver, midTurn, providerSessionId, projectRoot, session, onSessionReady, onEnded, createdAt } */
+const liveDrivers = new Map();
+
+let chatEventBroadcaster = null;
+
+/**
+ * Register the sink that receives every persisted envelope for live broadcast
+ * (ws-chat.mjs attaches its broadcastToSession here at server start).
+ */
+export function setChatEventBroadcaster(fn) {
+  chatEventBroadcaster = typeof fn === 'function' ? fn : null;
+}
+
+export function hasLiveChatDriver(sessionId) {
+  return liveDrivers.has(String(sessionId || ''));
+}
+
+export function getLiveChatDriverMeta(sessionId) {
+  const entry = liveDrivers.get(String(sessionId || ''));
+  if (!entry) return null;
+  return {
+    sessionId: entry.sessionId,
+    runtime: entry.runtime,
+    midTurn: entry.midTurn,
+    providerSessionId: entry.providerSessionId,
+  };
+}
+
+export function listLiveChatDriverSessionIds() {
+  return [...liveDrivers.keys()];
+}
+
+/**
+ * Register an already-constructed driver for a session. Also the injection
+ * seam for tests (fake drivers). Enforces one driver per session.
+ */
+export function registerLiveChatDriver(sessionId, driver, meta = {}) {
+  const id = String(sessionId || '');
+  if (!id) throw new ChatDriverError('registerLiveChatDriver requires a sessionId', 'CHAT_DRIVER_INVALID_SESSION');
+  if (!driver || typeof driver.send !== 'function') {
+    throw new ChatDriverError('chat driver must expose at least send(text)', 'CHAT_DRIVER_SHAPE_INVALID');
+  }
+  if (liveDrivers.has(id)) {
+    throw new ChatDriverError(`Chat driver already registered for session ${id}`, 'CHAT_DRIVER_EXISTS');
+  }
+  const entry = {
+    sessionId: id,
+    runtime: String(meta.runtime || ''),
+    driver,
+    midTurn: false,
+    providerSessionId: meta.providerSessionId ? String(meta.providerSessionId) : '',
+    projectRoot: meta.projectRoot || null,
+    session: meta.session || { sessionId: id, taskId: null, runtime: String(meta.runtime || '') },
+    onSessionReady: typeof meta.onSessionReady === 'function' ? meta.onSessionReady : null,
+    onEnded: typeof meta.onEnded === 'function' ? meta.onEnded : null,
+    createdAt: new Date().toISOString(),
+  };
+  liveDrivers.set(id, entry);
+  return entry;
+}
+
+// ── Canonical event pipeline ──
+// Drivers emit through onEvent; the pipeline normalizes to the frozen envelope
+// shape, tracks turn state, persists via the chat store, and broadcasts.
+function handleDriverEvent(sessionId, event) {
+  const entry = liveDrivers.get(sessionId);
+  if (!entry) return null; // events before registration/start are dropped
+  let type = 'raw';
+  let payload = {};
+  if (event && typeof event === 'object') {
+    if (event.type !== undefined && event.type !== null) type = String(event.type);
+    if (event.payload !== undefined) payload = event.payload;
+    else if (event.data !== undefined) payload = { data: event.data };
+  } else {
+    payload = { data: event === null || event === undefined ? '' : String(event) };
+  }
+  if (type === 'turn_started') entry.midTurn = true;
+  if (type === 'turn_ended' || type === 'done' || type === 'error') entry.midTurn = false;
+  if (type === 'session_ready' && payload && payload.providerSessionId) {
+    entry.providerSessionId = String(payload.providerSessionId);
+  }
+  const envelope = appendChatEnvelope(entry.projectRoot, entry.session, { type, payload });
+  if (type === 'session_ready' && entry.onSessionReady) {
+    try { entry.onSessionReady(envelope.payload.providerSessionId || ''); } catch { /* handler must not break the stream */ }
+  }
+  if ((type === 'done' || type === 'error') && entry.onEnded) {
+    try { entry.onEnded({ type, payload }); } catch { /* handler must not break the stream */ }
+  }
+  try { chatEventBroadcaster?.(sessionId, envelope); } catch { /* disconnected clients are ignored */ }
+  return envelope;
+}
+
+/**
+ * Create (and register) the chat driver for a runtime. The driver module is
+ * resolved lazily; tests inject fake modules via opts.driverModule
+ * ({ default: factory }). The returned driver still needs start().
+ */
+export async function createChatDriver(runtime, opts = {}) {
+  const loader = CHAT_DRIVER_MODULES[String(runtime)];
+  if (!loader) {
+    throw new ChatDriverError(
+      `No chat driver for runtime '${runtime}'. Supported: ${Object.keys(CHAT_DRIVER_MODULES).join(', ')}`,
+      'CHAT_DRIVER_UNSUPPORTED_RUNTIME',
+      { runtime },
+    );
+  }
+  const sessionId = String(opts.sessionId || opts.session?.sessionId || '');
+  if (!sessionId) throw new ChatDriverError('createChatDriver requires a sessionId', 'CHAT_DRIVER_INVALID_SESSION');
+  if (liveDrivers.has(sessionId)) {
+    throw new ChatDriverError(`Chat driver already registered for session ${sessionId}`, 'CHAT_DRIVER_EXISTS');
+  }
+  const mod = opts.driverModule || await loader();
+  const factory = mod?.default;
+  if (typeof factory !== 'function') {
+    throw new ChatDriverError(`Chat driver module for '${runtime}' has no default factory`, 'CHAT_DRIVER_MODULE_INVALID');
+  }
+  const driver = factory({
+    runtime: String(runtime),
+    command: String(opts.command || ''),
+    args: Array.isArray(opts.args) ? [...opts.args] : [],
+    cwd: String(opts.cwd || ''),
+    env: opts.env && typeof opts.env === 'object' ? opts.env : {},
+    model: String(opts.model || ''),
+    effort: String(opts.effort || ''),
+    effortVariant: String(opts.effortVariant || ''),
+    providerSessionId: opts.providerSessionId ? String(opts.providerSessionId) : '',
+    onEvent: (event) => handleDriverEvent(sessionId, event),
+  });
+  registerLiveChatDriver(sessionId, driver, {
+    runtime: String(runtime),
+    providerSessionId: opts.providerSessionId,
+    projectRoot: opts.projectRoot,
+    session: opts.session,
+    onSessionReady: opts.onSessionReady,
+    onEnded: opts.onEnded,
+  });
+  return driver;
+}
+
+/**
+ * Send text into a session's driver. steer=true means "use the steering
+ * channel when a turn is active"; without an active turn it falls back to a
+ * plain send so callers never need to track turn state themselves.
+ * @returns {boolean} false when no live driver exists
+ */
+export function sendTo(sessionId, text, { steer = false } = {}) {
+  const entry = liveDrivers.get(String(sessionId || ''));
+  if (!entry) return false;
+  const value = String(text ?? '');
+  if (!value) return false;
+  if (steer && entry.midTurn && typeof entry.driver.steer === 'function') {
+    entry.driver.steer(value);
+  } else {
+    entry.driver.send(value);
+  }
+  return true;
+}
+
+export async function interrupt(sessionId) {
+  const entry = liveDrivers.get(String(sessionId || ''));
+  if (!entry || typeof entry.driver.interrupt !== 'function') return false;
+  try {
+    await entry.driver.interrupt();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function approve(sessionId, requestId, result) {
+  const entry = liveDrivers.get(String(sessionId || ''));
+  if (!entry || typeof entry.driver.approve !== 'function') return false;
+  try {
+    entry.driver.approve(String(requestId || ''), result);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function dispose(sessionId, opts = {}) {
+  const id = String(sessionId || '');
+  const entry = liveDrivers.get(id);
+  if (!entry) return false;
+  liveDrivers.delete(id);
+  try {
+    await entry.driver.dispose?.(opts);
+  } catch { /* dispose must never throw through stop paths */ }
+  return true;
+}
+
+/** Test-only: drop every live driver and the broadcaster. */
+export function __resetChatDriversForTests() {
+  liveDrivers.clear();
+  setChatEventBroadcaster(null);
+}

package/src/wf-ui-server/chat-store.mjs

@@ -0,0 +1,109 @@
+import {
+  appendTerminalData,
+  readTerminalRange,
+} from './terminal-store.mjs';
+
+// ── Chat envelope store ──
+// Canonical event envelopes ({seq, ts, type, payload}) for chat-mode sessions.
+// Every envelope is mirrored into the terminal persist machinery as ONE stdout
+// JSON line via appendTerminalData (so readTerminalRange keeps working and the
+// transcript stays in one place); structured copies are also kept in a bounded
+// in-memory ring as the fast path for WS replay/backfill, with the disk lines
+// as the durable fallback after a server restart. seq comes from
+// appendTerminalData itself, so envelope seq and terminal seq never diverge.
+const ENVELOPE_MARKER = 'chat-envelope';
+const MAX_MEMORY_ENVELOPES = 2000;
+const MAX_READ_LIMIT = 2000;
+
+/** sessionId -> envelope[] */
+const memoryEnvelopes = new Map();
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeEnvelopeBody({ type, payload, ts } = {}) {
+  const at = typeof ts === 'number' && Number.isFinite(ts)
+    ? new Date(ts).toISOString()
+    : new Date().toISOString();
+  return {
+    kind: ENVELOPE_MARKER,
+    ts: typeof ts === 'string' && ts ? ts : at,
+    type: String(type || 'raw'),
+    payload: isPlainObject(payload) ? payload : {},
+  };
+}
+
+/**
+ * Append one canonical envelope for a chat session. The terminal-store entry
+ * carries the serialized body; the returned envelope pairs the assigned seq
+ * with the body fields.
+ * @returns {{seq:number, ts:string, type:string, payload:object}}
+ */
+export function appendChatEnvelope(projectRoot, session, event = {}) {
+  const body = normalizeEnvelopeBody(event);
+  const entry = appendTerminalData(projectRoot, session, JSON.stringify(body), 'stdout');
+  const envelope = { seq: entry.seq, ts: body.ts, type: body.type, payload: body.payload };
+  const ring = memoryEnvelopes.get(session.sessionId) || [];
+  ring.push(envelope);
+  if (ring.length > MAX_MEMORY_ENVELOPES) ring.splice(0, ring.length - MAX_MEMORY_ENVELOPES);
+  memoryEnvelopes.set(session.sessionId, ring);
+  return envelope;
+}
+
+function parseEnvelopeEntry(entry) {
+  try {
+    const parsed = JSON.parse(entry.data);
+    if (parsed && parsed.kind === ENVELOPE_MARKER && parsed.type !== undefined) {
+      return {
+        seq: entry.seq,
+        ts: String(parsed.ts || entry.ts),
+        type: String(parsed.type),
+        payload: isPlainObject(parsed.payload) ? parsed.payload : {},
+      };
+    }
+  } catch { /* stdin mirrors and raw text lines are not envelopes */ }
+  return null;
+}
+
+function readDiskEnvelopes(projectRoot, sessionId) {
+  const { entries } = readTerminalRange(projectRoot, { sessionId });
+  const envelopes = [];
+  for (const entry of entries) {
+    const envelope = parseEnvelopeEntry(entry);
+    if (envelope) envelopes.push(envelope);
+  }
+  return envelopes;
+}
+
+/**
+ * Stored envelopes for a chat session — the same store WS replay and the REST
+ * range route both serve from. Memory ring first (covers live sessions), disk
+ * fallback when the session is unknown to this server lifetime or the window
+ * starts before the ring's oldest entry.
+ */
+export function readStoredEnvelopes(projectRoot, { sessionId } = {}) {
+  if (!sessionId) return [];
+  const ring = memoryEnvelopes.get(sessionId);
+  if (Array.isArray(ring) && ring.length > 0) return [...ring];
+  return readDiskEnvelopes(projectRoot, sessionId);
+}
+
+export function readChatEnvelopes(projectRoot, { sessionId, fromSeq, limit } = {}) {
+  let envelopes = readStoredEnvelopes(projectRoot, { sessionId });
+  const minMemorySeq = (() => {
+    const ring = memoryEnvelopes.get(sessionId);
+    return Array.isArray(ring) && ring.length > 0 ? ring[0].seq : null;
+  })();
+  if (Number.isFinite(fromSeq) && minMemorySeq !== null && fromSeq < minMemorySeq) {
+    envelopes = readDiskEnvelopes(projectRoot, sessionId);
+  }
+  if (Number.isFinite(fromSeq)) envelopes = envelopes.filter((envelope) => envelope.seq >= fromSeq);
+  const max = Math.min(Math.max(Number(limit) || MAX_READ_LIMIT, 1), MAX_READ_LIMIT);
+  envelopes = envelopes.slice(-max);
+  return { sessionId, envelopes };
+}
+
+export function clearChatEnvelopes(sessionId) {
+  memoryEnvelopes.delete(sessionId);
+}

package/src/wf-ui-server/claude-transcript-materializer.mjs

@@ -0,0 +1,235 @@
+// claude-transcript-materializer.mjs
+//
+// Rebuilds a claude-code conversation transcript (jsonl) from the harness terminal
+// ring, so `claude --resume <agentSessionId>` can restore PTY-spawned sessions that
+// claude-code 2.x itself never persists (proven in RESUME-E2E-EVIDENCE.md PASS 2-6:
+// no conversation jsonl is ever written for node-pty sessions, with or without
+// --session-id, graceful or hard stop).
+//
+// Pure hard-coded extraction: stdin entries give the exact typed prompts; the
+// assistant reply is the TUI-rendered "●" answer bullet from stdout. No LLM call,
+// no summarization, millisecond cost.
+//
+// Schema mirrors a real 2.1.215 transcript (per-turn group: last-prompt, mode,
+// permission-mode, user, assistant; final last-prompt with lastPrompt text).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+const ESC = '\x1b';
+
+export function stripAnsi(text) {
+  return String(text ?? '')
+    .replace(new RegExp(`${ESC}\\[[0-9;?]*[a-zA-Z]`, 'g'), '')
+    .replace(new RegExp(`${ESC}\\][^${ESC}\\x07]*(${ESC}\\\\|\\x07)`, 'g'), '')
+    .replace(new RegExp(`${ESC}[()][0-9A-Z]`, 'g'), '')
+    .replace(new RegExp(`${ESC}[=>#78]`, 'g'), '')
+    .replace(/\r/g, '');
+}
+
+// Spinner/progress glyphs the claude TUI renders while a turn runs.
+const SPINNER_GLYPHS = /[✶✢✻✽·…]/g;
+// "✻Baked for 9s"-style verb tail that follows the answer bullet.
+const VERB_TAIL = /✻\s*[A-Za-z]+ for \d+s/g;
+// The turn-over signature: verb tail immediately followed by the prompt-ready
+// "❯". A lone "❯" elsewhere is ANSWER content (e.g. a quoted shell prompt) and
+// must not close the turn.
+const TURN_OVER = /✻\s*[A-Za-z]+ for \d+s\s*❯/;
+
+function cleanAnswer(segment) {
+  let text = segment;
+  // Strip only a TRAILING prompt-ready marker ("❯" + optional whitespace at the
+  // buffer end). "❯" elsewhere is answer content (quoted shell prompt etc.) and
+  // must survive. The turn-over detection already ended the capture at the ready
+  // marker, so mid-buffer ready markers do not occur here.
+  text = text.replace(/❯\s*$/, '').replace(VERB_TAIL, '').replace(SPINNER_GLYPHS, '');
+  // Drop claude's thinking preview lines ("⎿ …") — they are not the answer.
+  text = text
+    .split('\n')
+    .filter((line) => !line.trim().startsWith('⎿'))
+    .join('\n');
+  return text.replace(/[ \t]+\n/g, '\n').trim();
+}
+
+// State machine over seq-ordered terminal.jsonl entries. Turn boundaries are the
+// TUI's answer bracket (first "●" opens capture, the following "❯" ready marker
+// closes the turn), NOT the CR: in the promptSubmit path the enter key is a raw
+// PTY write and never appears in the ring (stdin holds one full-prompt entry),
+// while CLI char-by-char typing records per-char stdin plus a literal "\r".
+// Both shapes resolve to the same bracket-delimited turn extraction.
+export function extractConversationTurns(entries) {
+  const turns = [];
+  let promptBuf = '';
+  let openPrompt = null;
+  let capturing = false;
+  let answerBuf = '';
+  let sawReady = false;
+
+  const closeTurn = () => {
+    if (openPrompt) {
+      const user = stripAnsi(openPrompt)
+        .replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '')
+        .trim();
+      // Slash commands (/model, /exit, …) are control input, not conversation turns.
+      if (user && !user.startsWith('/')) turns.push({ user, assistant: cleanAnswer(answerBuf) });
+    }
+    openPrompt = null;
+    promptBuf = '';
+    capturing = false;
+    answerBuf = '';
+    sawReady = false;
+  };
+
+  for (const entry of entries) {
+    if (entry.stream === 'stdin') {
+      // New prompt input while a turn is still open: the previous turn is over
+      // (covers ready markers that arrive without the verb tail). Close BEFORE
+      // accumulating so the new prompt survives.
+      if (capturing && sawReady && String(entry.data ?? '').trim()) closeTurn();
+      const parts = String(entry.data ?? '').split('\r');
+      for (let i = 0; i < parts.length; i++) {
+        promptBuf += parts[i];
+        // A CR finalizes the current prompt text; the turn itself closes on the
+        // turn-over signature below.
+        if (i < parts.length - 1) {
+          openPrompt = promptBuf;
+          promptBuf = '';
+        }
+      }
+      continue;
+    }
+    const clean = stripAnsi(entry.data);
+    if (!capturing) {
+      const bullet = clean.indexOf('●');
+      if (bullet !== -1) {
+        capturing = true;
+        openPrompt = openPrompt || promptBuf;
+        answerBuf = clean.slice(bullet + 1);
+      }
+    } else {
+      answerBuf += clean;
+    }
+    // Test AFTER every buffer mutation, including the capture-start entry: a
+    // single chunk can hold the complete "●answer✻Verb for Xs❯ " sequence.
+    if (capturing && TURN_OVER.test(answerBuf)) {
+      closeTurn();
+    } else if (capturing && answerBuf.includes('❯')) {
+      sawReady = true;
+    }
+  }
+  closeTurn();
+  return turns;
+}
+
+// claude's on-disk project dir encoding: "D:\a\b" -> "D--a-b".
+export function encodeClaudeProjectDir(cwd) {
+  return String(cwd)
+    .replace(/[\\/:]/g, '-')
+    .replace(/[^a-zA-Z0-9_-]/g, '-');
+}
+
+// Builds a schema-faithful transcript jsonl (every line a standalone JSON object).
+export function buildClaudeTranscript({
+  sessionId,
+  cwd,
+  turns,
+  version = '2.1.215',
+  model = 'default',
+  gitBranch = '',
+  timestamp = new Date().toISOString(),
+}) {
+  const uuid = () => crypto.randomUUID();
+  const lines = [];
+  let leaf = uuid();
+  const checkpoint = () => {
+    lines.push({ type: 'last-prompt', leafUuid: leaf, sessionId });
+    lines.push({ type: 'mode', mode: 'normal', sessionId });
+    lines.push({ type: 'permission-mode', permissionMode: 'bypassPermissions', sessionId });
+  };
+  checkpoint();
+  for (const turn of turns) {
+    const userUuid = uuid();
+    lines.push({
+      parentUuid: leaf,
+      isSidechain: false,
+      promptId: uuid(),
+      type: 'user',
+      message: { role: 'user', content: turn.user },
+      uuid: userUuid,
+      timestamp,
+      permissionMode: 'bypassPermissions',
+      origin: { kind: 'human' },
+      promptSource: 'typed',
+      userType: 'external',
+      entrypoint: 'cli',
+      cwd,
+      sessionId,
+      version,
+      gitBranch,
+    });
+    const assistantUuid = uuid();
+    lines.push({
+      parentUuid: userUuid,
+      isSidechain: false,
+      message: {
+        id: uuid(),
+        type: 'message',
+        role: 'assistant',
+        model,
+        content: [{ type: 'text', text: turn.assistant }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0, output_tokens: 0 },
+        stop_details: null,
+      },
+      type: 'assistant',
+      uuid: assistantUuid,
+      timestamp,
+      effort: 'max',
+      session_id: sessionId,
+      userType: 'external',
+      entrypoint: 'cli',
+      cwd,
+      sessionId,
+      version,
+      gitBranch,
+    });
+    leaf = assistantUuid;
+    checkpoint();
+  }
+  lines.push({
+    type: 'last-prompt',
+    lastPrompt: turns.length ? turns[turns.length - 1].user : '',
+    leafUuid: leaf,
+    sessionId,
+  });
+  return `${lines.map((line) => JSON.stringify(line)).join('\n')}\n`;
+}
+
+// Materializes the transcript for sessionId into claude's project transcript dir.
+// Returns null (and writes nothing) when the session has no conversation turns.
+export function materializeClaudeTranscript({
+  home,
+  cwd,
+  sessionId,
+  entries,
+  version,
+  model,
+  gitBranch,
+}) {
+  const turns = extractConversationTurns(entries);
+  if (!turns.length) return null;
+  const content = buildClaudeTranscript({
+    sessionId,
+    cwd,
+    turns,
+    version,
+    model: model || 'default',
+    gitBranch,
+  });
+  const filePath = path.join(home, '.claude', 'projects', encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, 'utf8');
+  return { path: filePath, bytes: Buffer.byteLength(content), turns: turns.length };
+}

package/src/wf-ui-server/codex-update-prompt.mjs

@@ -0,0 +1,53 @@
+export const CODEX_UPDATE_SKIP_SESSION_KEYS = '\x1b[B\r';
+export const CODEX_UPDATE_SKIP_UNTIL_NEXT_VERSION_KEYS = '\x1b[B\x1b[B\r';
+
+const ANSI_PATTERN = /\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g;
+const MAX_BUFFER_CHARS = 6000;
+
+export function stripTerminalControls(value) {
+  return String(value || '')
+    .replace(ANSI_PATTERN, '')
+    .replace(/\r/g, '\n');
+}
+
+export function isCodexUpdatePrompt(value) {
+  const normalized = stripTerminalControls(value)
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+  return normalized.includes('update available')
+    && normalized.includes('release notes:')
+    && normalized.includes('skip until next version')
+    && normalized.includes('press enter to continue');
+}
+
+export function codexUpdatePromptControlEnabled(env = process.env) {
+  return env.HARNESS_CODEX_UPDATE_PROMPT !== 'passthrough'
+    && env.HARNESS_CODEX_UPDATE_PROMPT !== 'manual';
+}
+
+export function createCodexUpdatePromptDetector({ enabled = true } = {}) {
+  let buffer = '';
+  let detected = false;
+
+  return {
+    observe(chunk) {
+      if (!enabled || detected) return null;
+      buffer = stripTerminalControls(`${buffer}${chunk || ''}`).slice(-MAX_BUFFER_CHARS);
+      if (!isCodexUpdatePrompt(buffer)) return null;
+      detected = true;
+      return {
+        reason: 'codex-update-prompt',
+        type: 'codex:update-prompt',
+      };
+    },
+    get detected() {
+      return detected;
+    },
+  };
+}
+
+export function codexUpdatePromptInputForChoice(choice) {
+  if (choice === 'skip-session') return CODEX_UPDATE_SKIP_SESSION_KEYS;
+  if (choice === 'skip-until-next-version') return CODEX_UPDATE_SKIP_UNTIL_NEXT_VERSION_KEYS;
+  return null;
+}