@with-logic/elwood 0.1.0

package/dist/codex/session.js

@@ -0,0 +1,61 @@
+/** CodexSessionApi entry points: preflight, record creation, and socket-home-guarded start. Implements PRD §5.5, §5.6, §5.7, §7A, §8, §9. */
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { queuePersonaMessage } from "../core/persona.js";
+import { codexReasoningEfforts, validateReasoningEffort } from "../core/reasoning-effort.js";
+import { withSocketHomeCleanup } from "../runtime/startup-cleanup.js";
+import { codexLaunchPosture, withCodexLaunch } from "../state/launch-posture.js";
+import { sessionRuntime } from "../state/runtime-paths.js";
+import { removeOwnSocketFile } from "../state/socket-home.js";
+import { createSessionRecord, defaultStateDir, prepareStateDir, } from "../state/store.js";
+import * as preflight from "./preflight.js";
+import { buildCodexSession } from "./session-build.js";
+export { resetCodexSessionSeamsForTests, setCodexHookBridgeFactoryForTests, } from "./session-bridge.js";
+/**
+ * @deprecated Prefer the `CodexSession` class (`new CodexSession(options)`), which starts
+ * lazily and exposes both `send`/`stream` and this full control surface. `startCodex`
+ * remains the low-level eager factory and is used internally; it will be removed once the
+ * sole consumer migrates.
+ */
+export function startCodex(rawOptions) {
+    return startCodexWithId(rawOptions, randomUUID());
+}
+/** Internal deterministic-identity start used by owners that must clean failed launch state. */
+export async function startCodexWithId(rawOptions, elwoodSessionId) {
+    // Resolve BOTH cwd and stateDir to ABSOLUTE before the preflight `await`: a relative
+    // path resolved after the await could point elsewhere if the caller's (or preflight's)
+    // process.cwd() changed during it, splitting where state is written from where the CLI
+    // launches (§8.1, §8.2). Thread the resolved cwd everywhere so the record, launch, and
+    // PTY spawn all agree.
+    const options = { ...rawOptions, cwd: resolve(rawOptions.cwd) };
+    const stateDir = resolve(options.stateDir ?? defaultStateDir(options.cwd));
+    const warning = await preflight.preflightCodex(options.strictVersionCheck ?? false, options.autoupdate ?? false);
+    prepareStateDir(stateDir, { gitignore: options.stateDir === undefined });
+    const createdRecord = createSessionRecord({
+        cwd: options.cwd,
+        id: elwoodSessionId,
+        adapter: "codex",
+    });
+    const record = withCodexLaunch(createdRecord, codexLaunchPosture(options));
+    const session = await startCodexFromRecord(record, stateDir, options, false, warning);
+    return queuePersonaMessage(session, options.persona);
+}
+export function startCodexFromRecord(record, stateDir, options, resumed, preflightWarning) {
+    // Validate the effort enum before any spawn (C-CODEX-21): both start and resume funnel
+    // through here. Codex validates server-side (a bad value fails at the first turn), so
+    // this turns a deferred provider error into a fast, clear start-time rejection.
+    validateReasoningEffort(options.reasoningEffort, codexReasoningEfforts, "codex_invalid_reasoning_effort");
+    // `sessionRuntime` ensures the session's STABLE out-of-tree home and reserves a FRESH
+    // per-launch socket PATH inside it; the socket is bound later, by `bridge.start()`
+    // (after the state/runtime files are written). Wrap the WHOLE build so ANY failure
+    // before the session takes ownership removes THIS launch's own socket file — never the
+    // shared home, which a concurrent launch may own (§9.1). On success ownership transfers
+    // to the returned session, whose teardown removes the whole home via removeSessionFiles.
+    const runtime = sessionRuntime({
+        stateDir,
+        elwoodSessionId: record.elwoodSessionId,
+        adapter: "codex",
+    });
+    return withSocketHomeCleanup(() => removeOwnSocketFile(runtime.socketPath), () => buildCodexSession({ record, stateDir, runtime, options, resumed, preflightWarning }));
+}
+//# sourceMappingURL=session.js.map

package/dist/codex/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/codex/session.ts"],"names":[],"mappings":"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"}

package/dist/codex/simple.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `CodexSession`: the public Codex session (PRD §5.8). Constructed synchronously with the
+ * same options as the low-level factory (`cwd` defaults to `process.cwd()`), it starts
+ * Codex lazily on first use and exposes both the ergonomic `send`/`stream` API and the
+ * full control surface (all lazy-start-aware). Prefer this over the deprecated `startCodex`
+ * factory.
+ */
+import { SessionBase } from "../core/simple/session.ts";
+import type { Unsubscribe } from "../core/types.ts";
+import type { CodexEventHandler, CodexEventName, CodexSessionApi, StartCodexOptions } from "./session/types.ts";
+/** Options for `CodexSession`: the low-level `startCodex` options with an optional `cwd`. */
+export type CodexSessionOptions = Omit<StartCodexOptions, "cwd"> & {
+    readonly cwd?: string;
+};
+export declare class CodexSession extends SessionBase<CodexSessionApi> {
+    private readonly options;
+    constructor(options?: CodexSessionOptions);
+    protected launch(): Promise<CodexSessionApi>;
+    /** Codex's `Stop` hook carries `last_assistant_message` — the standard completeness signal. */
+    protected readBoundarySignal: import("../core/simple/turn-types.ts").BoundarySignalReader;
+    /** Typed event subscription over the Codex event map (buffered before start). */
+    on<E extends CodexEventName>(event: E, handler: CodexEventHandler<E>): Unsubscribe;
+    off<E extends CodexEventName>(event: E, handler: CodexEventHandler<E>): void;
+}
+//# sourceMappingURL=simple.d.ts.map

package/dist/codex/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../src/codex/simple.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAW5B,6FAA6F;AAC7F,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG;IAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F,qBAAa,YAAa,SAAQ,WAAW,CAAC,eAAe,CAAC;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,GAAE,mBAAwB;IAO7C,SAAS,CAAC,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;IAI5C,+FAA+F;IAC/F,SAAS,CAAC,kBAAkB,8DAAyB;IAErD,iFAAiF;IACjF,EAAE,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,WAAW;IAKlF,GAAG,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI;CAG7E"}

package/dist/codex/simple.js

@@ -0,0 +1,37 @@
+/**
+ * `CodexSession`: the public Codex session (PRD §5.8). Constructed synchronously with the
+ * same options as the low-level factory (`cwd` defaults to `process.cwd()`), it starts
+ * Codex lazily on first use and exposes both the ergonomic `send`/`stream` API and the
+ * full control surface (all lazy-start-aware). Prefer this over the deprecated `startCodex`
+ * factory.
+ */
+import { resolveSessionPaths } from "../core/simple/resolve-paths.js";
+import { SessionBase } from "../core/simple/session.js";
+import { defaultBoundarySignal } from "../core/simple/turn.js";
+import { startCodex } from "./session/index.js";
+const _stopBoundaryCheck = true;
+void _stopBoundaryCheck;
+export class CodexSession extends SessionBase {
+    options;
+    constructor(options = {}) {
+        super();
+        // SNAPSHOT cwd + relative stateDir at CONSTRUCTION (see resolveSessionPaths): a chdir between
+        // construction and lazy launch must not change which project is launched or where state lands.
+        this.options = resolveSessionPaths(options);
+    }
+    launch() {
+        return startCodex(this.options);
+    }
+    /** Codex's `Stop` hook carries `last_assistant_message` — the standard completeness signal. */
+    readBoundarySignal = defaultBoundarySignal;
+    /** Typed event subscription over the Codex event map (buffered before start). */
+    on(event, handler) {
+        // Keyed by (event, handler) so the disposer works before AND after start and `off` scopes
+        // to the exact event even when a handler is reused; the closure keeps types (no cast).
+        return this.subscribe(event, handler, (session) => session.on(event, handler));
+    }
+    off(event, handler) {
+        this.unsubscribe(event, handler);
+    }
+}
+//# sourceMappingURL=simple.js.map

package/dist/codex/simple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.js","sourceRoot":"","sources":["../../src/codex/simple.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAA2B,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAGxF,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAchD,MAAM,kBAAkB,GAA2B,IAAI,CAAC;AACxD,KAAK,kBAAkB,CAAC;AAKxB,MAAM,OAAO,YAAa,SAAQ,WAA4B;IAC3C,OAAO,CAAoB;IAE5C,YAAY,UAA+B,EAAE;QAC3C,KAAK,EAAE,CAAC;QACR,8FAA8F;QAC9F,+FAA+F;QAC/F,IAAI,CAAC,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAES,MAAM;QACd,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED,+FAA+F;IACrF,kBAAkB,GAAG,qBAAqB,CAAC;IAErD,iFAAiF;IACjF,EAAE,CAA2B,KAAQ,EAAE,OAA6B;QAClE,0FAA0F;QAC1F,uFAAuF;QACvF,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACjF,CAAC;IACD,GAAG,CAA2B,KAAQ,EAAE,OAA6B;QACnE,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACnC,CAAC;CACF"}

package/dist/codex/start-or-resume.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Codex try-resume-else-start convenience entry point.
+ * Implements PRD §5.6 and C-API-26; every resume-relevant start option (including
+ * `reasoningEffort`, which a resume must re-supply per C-CODEX-21) is forwarded.
+ */
+import { type StartOrResumeResult } from "../core/start-or-resume.ts";
+import type { CodexSessionApi, StartCodexOptions } from "./session-types.ts";
+export type StartOrResumeCodexOptions = StartCodexOptions & {
+    readonly elwoodSessionId?: string;
+};
+export declare function startOrResumeCodex(options: StartOrResumeCodexOptions): Promise<StartOrResumeResult<CodexSessionApi>>;
+//# sourceMappingURL=start-or-resume.d.ts.map

package/dist/codex/start-or-resume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-or-resume.d.ts","sourceRoot":"","sources":["../../src/codex/start-or-resume.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,mBAAmB,EAAiB,MAAM,4BAA4B,CAAC;AAIrF,OAAO,KAAK,EAAE,eAAe,EAAsB,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEjG,MAAM,MAAM,yBAAyB,GAAG,iBAAiB,GAAG;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC,CAO/C"}

package/dist/codex/start-or-resume.js

@@ -0,0 +1,31 @@
+/**
+ * Codex try-resume-else-start convenience entry point.
+ * Implements PRD §5.6 and C-API-26; every resume-relevant start option (including
+ * `reasoningEffort`, which a resume must re-supply per C-CODEX-21) is forwarded.
+ */
+import { startOrResume } from "../core/start-or-resume.js";
+import { compact } from "../state/launch-posture.js";
+import { startCodex } from "./session.js";
+import { resumeCodex } from "./session-resume.js";
+export function startOrResumeCodex(options) {
+    const { elwoodSessionId, ...startOptions } = options;
+    return startOrResume(elwoodSessionId, (id) => resumeCodex(resumeOptions(id, startOptions)), () => startCodex(startOptions));
+}
+// Every resume-relevant start option is forwarded (PRD §5.6); `compact` drops the
+// absent ones so `exactOptionalPropertyTypes` sees no explicit `undefined`.
+function resumeOptions(elwoodSessionId, start) {
+    const forwarded = compact({
+        stateDir: start.stateDir,
+        hooks: start.hooks,
+        initialSize: start.initialSize,
+        reasoningEffort: start.reasoningEffort,
+        sandbox: start.sandbox,
+        approvalPolicy: start.approvalPolicy,
+        autoupdate: start.autoupdate,
+        autotrust: start.autotrust,
+        hookTimeoutMs: start.hookTimeoutMs,
+        strictVersionCheck: start.strictVersionCheck,
+    });
+    return { elwoodSessionId, cwd: start.cwd, ...forwarded };
+}
+//# sourceMappingURL=start-or-resume.js.map

package/dist/codex/start-or-resume.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-or-resume.js","sourceRoot":"","sources":["../../src/codex/start-or-resume.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAA4B,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAOlD,MAAM,UAAU,kBAAkB,CAChC,OAAkC;IAElC,MAAM,EAAE,eAAe,EAAE,GAAG,YAAY,EAAE,GAAG,OAAO,CAAC;IACrD,OAAO,aAAa,CAClB,eAAe,EACf,CAAC,EAAE,EAAE,EAAE,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC,EACpD,GAAG,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAC/B,CAAC;AACJ,CAAC;AAED,kFAAkF;AAClF,4EAA4E;AAC5E,SAAS,aAAa,CAAC,eAAuB,EAAE,KAAwB;IACtE,MAAM,SAAS,GAAG,OAAO,CAAsD;QAC7E,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,eAAe,EAAE,KAAK,CAAC,eAAe;QACtC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;KAC7C,CAAC,CAAC;IACH,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,SAAS,EAAE,CAAC;AAC3D,CAAC"}

package/dist/codex/startup-prompts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Handles known Codex startup prompts that block interactive sessions.
+ * Implements PRD §4.4, §5.5, and §5.7.
+ */
+import type { SettledStartupOutcome } from "../core/startup/write.ts";
+import { type TrustWriteResult } from "../core/trust/responder.ts";
+import type { ElwoodWarningEvent } from "../core/types.ts";
+/** A Codex startup outcome paired with its PTY-write completion (§5.4, §5.7). */
+export type SettledCodexStartupOutcome = SettledStartupOutcome<"codex">;
+type CodexStartupPromptResult = {
+    readonly warnings: readonly ElwoodWarningEvent[];
+    readonly outcomes: readonly SettledCodexStartupOutcome[];
+};
+export declare class CodexStartupPromptResponder {
+    private buffer;
+    private readonly elwoodSessionId;
+    private readonly trust;
+    private readonly updatePrompt;
+    private skippedUpdate;
+    private warnedBanners;
+    constructor(elwoodSessionId?: string, autotrust?: boolean);
+    handle(screenText: string, write: (input: string) => TrustWriteResult, readFrame?: () => string): CodexStartupPromptResult;
+    private newWarnings;
+}
+/** The two banner warnings the startup responder parses (an exhaustive pair). */
+type CodexBannerWarning = Extract<ElwoodWarningEvent, {
+    readonly code: "mcp_server_not_logged_in" | "mcp_startup_incomplete";
+}>;
+export declare function findNumberedOption(text: string, pattern: RegExp): string | null;
+export declare function codexWarningsFromText(text: string, elwoodSessionId: string): readonly CodexBannerWarning[];
+export {};
+//# sourceMappingURL=startup-prompts.d.ts.map

package/dist/codex/startup-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-prompts.d.ts","sourceRoot":"","sources":["../../src/codex/startup-prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEtE,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACzF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAO3D,iFAAiF;AACjF,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;AAExE,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,0BAA0B,EAAE,CAAC;CAC1D,CAAC;AAIF,qBAAa,2BAA2B;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;IAC/D,OAAO,CAAC,aAAa,CAAU;IAM/B,OAAO,CAAC,aAAa,CAAqB;gBAE9B,eAAe,SAAK,EAAE,SAAS,UAAQ;IASnD,MAAM,CACJ,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,gBAAgB,EAC1C,SAAS,CAAC,EAAE,MAAM,MAAM,GACvB,wBAAwB;IAuD3B,OAAO,CAAC,WAAW;CAMpB;AAED,iFAAiF;AACjF,KAAK,kBAAkB,GAAG,OAAO,CAC/B,kBAAkB,EAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,0BAA0B,GAAG,wBAAwB,CAAA;CAAE,CACzE,CAAC;AASF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE/E;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,MAAM,GACtB,SAAS,kBAAkB,EAAE,CAU/B"}

package/dist/codex/startup-prompts.js

@@ -0,0 +1,136 @@
+/**
+ * Handles known Codex startup prompts that block interactive sessions.
+ * Implements PRD §4.4, §5.5, and §5.7.
+ */
+import { numberedOptions } from "../core/terminal-options.js";
+import { TrustPromptResponder } from "../core/trust/responder.js";
+import { CodexUpdatePromptTracker, codexUpdateOptionPattern, writeCodexUpdateSkip, } from "./update-prompt.js";
+const maxBufferLength = 6_000;
+export class CodexStartupPromptResponder {
+    buffer;
+    elwoodSessionId;
+    trust;
+    updatePrompt = new CodexUpdatePromptTracker();
+    skippedUpdate;
+    // The banner identities that fired a warning on the PREVIOUS frame. A warning fires
+    // only on the EDGE a banner first appears; a banner still present next frame is NOT
+    // re-emitted (that would replay the same live incident indefinitely, C-API-14). A
+    // banner that clears (drops out of this set) and reappears fires again — a genuinely
+    // new occurrence, matching "once when observed" rather than "replay while on screen".
+    warnedBanners = new Set();
+    constructor(elwoodSessionId = "", autotrust = false) {
+        this.elwoodSessionId = elwoodSessionId;
+        this.buffer = "";
+        // Owns the whole allowlisted trust family (directory + hook trust), not just
+        // one prompt; extended by adding entries to trustPromptAllowlist.
+        this.trust = new TrustPromptResponder("codex", autotrust);
+        this.skippedUpdate = false;
+    }
+    handle(screenText, write, readFrame) {
+        const outcomes = [];
+        this.buffer = `${this.buffer}\n${screenText}`.slice(-maxBufferLength);
+        // Trust prompts are matched against the CURRENT frame only: a stale phrase in
+        // the accumulated buffer must never pair with a different dialog's answer.
+        const trust = this.trust.handle(screenText, write, readFrame);
+        if (trust?.kind === "answered") {
+            outcomes.push({ outcome: { kind: "answered", ...trust.automation }, settled: trust.settled });
+        }
+        else if (trust?.kind === "option_pending") {
+            outcomes.push({ outcome: { kind: "option_pending", prompt: trust.prompt } });
+        }
+        // Skipping an available update is not a trust decision, so it stays here.
+        // The skip is EDGE-triggered and scoped to the CURRENT frame's update screen:
+        // `skippedUpdate` latches after a successful skip so a persistent update screen is
+        // not re-answered every frame, but it RE-ARMS the moment the update screen leaves
+        // the frame. That breaks the observed restart loop — Codex restarts itself, the
+        // update does not take, and the SAME update screen reappears; a cleared frame
+        // between the two appearances (Codex's restart draws a normal composer) re-arms us
+        // to skip the reappearance. Gating the attempt on the CURRENT frame (not just the
+        // accumulated buffer) also means a re-armed benign frame that merely mentions
+        // "update" never re-fires a skip against a stale buffered option — only a frame
+        // actually showing the update screen does. The buffer is still consulted to LOCATE
+        // the option, since Codex can split the banner and its numbered options across two
+        // consecutive frames.
+        const onUpdateScreen = this.updatePrompt.observe(screenText);
+        if (!onUpdateScreen)
+            this.skippedUpdate = false;
+        if (onUpdateScreen && !this.skippedUpdate) {
+            const option = findNumberedOption(this.buffer, codexUpdateOptionPattern);
+            if (option) {
+                // Settle OPTIMISTICALLY but keep the skip retryable if the write is
+                // rejected, so a later frame re-attempts it rather than falsely reporting
+                // the update as skipped (C-CODEX-17).
+                this.skippedUpdate = true;
+                const settled = writeCodexUpdateSkip(option, write, readFrame, this.updatePrompt.currentFramePredicate()).catch((error) => {
+                    this.skippedUpdate = false;
+                    throw error;
+                });
+                outcomes.push({ outcome: { kind: "answered", prompt: "update", input: option }, settled });
+            }
+        }
+        return { warnings: this.newWarnings(screenText), outcomes };
+    }
+    // Emit warnings only for banners NEWLY appearing on THIS frame, matched against the
+    // CURRENT frame (not the accumulated buffer) so a scrolled-off banner does not replay
+    // every later frame (C-API-14, §5.7). Banners are keyed by a STABLE semantic identity
+    // (code + the server(s) it names), not the raw rendered line — the emulator may render
+    // the same banner with different padding/wrapping across frames, which raw-line keying
+    // would treat as new. `warnedBanners` is reset to this frame's identities, so a banner
+    // that clears (leaves the frame) then reappears fires again as a genuinely new occurrence.
+    newWarnings(screenText) {
+        const matched = codexWarningsFromText(screenText, this.elwoodSessionId);
+        const fresh = matched.filter((warning) => !this.warnedBanners.has(bannerKey(warning)));
+        this.warnedBanners = new Set(matched.map(bannerKey));
+        return fresh;
+    }
+}
+/** A stable identity for a startup banner: its code plus the server(s) it names. */
+function bannerKey(warning) {
+    return warning.code === "mcp_server_not_logged_in"
+        ? `login:${warning.mcpServerName}`
+        : `startup:${warning.failedServers.join(",")}`;
+}
+export function findNumberedOption(text, pattern) {
+    return numberedOptions(text).find((option) => pattern.test(option.label))?.number ?? null;
+}
+export function codexWarningsFromText(text, elwoodSessionId) {
+    const warnings = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        const login = /The ([\w.-]+) MCP server is not logged in\. Run `([^`]+)`\./.exec(line);
+        if (login)
+            warnings.push(mcpLoginWarning(elwoodSessionId, line, login[1], login[2]));
+        const failed = /MCP startup incomplete \(failed:\s*([^)]+)\)/.exec(line);
+        if (failed)
+            warnings.push(mcpStartupWarning(elwoodSessionId, line, failed[1]));
+    }
+    return warnings;
+}
+function mcpLoginWarning(elwoodSessionId, raw, mcpServerName, recoveryCommand) {
+    return {
+        elwoodSessionId,
+        agent: "codex",
+        source: "terminal",
+        code: "mcp_server_not_logged_in",
+        severity: "warning",
+        message: `The ${mcpServerName} MCP server is not logged in.`,
+        mcpServerName,
+        recoveryCommand,
+        raw,
+    };
+}
+function mcpStartupWarning(elwoodSessionId, raw, failed) {
+    const failedServers = failed.split(",").map((server) => server.trim());
+    return {
+        elwoodSessionId,
+        agent: "codex",
+        source: "terminal",
+        code: "mcp_startup_incomplete",
+        severity: "warning",
+        message: `MCP startup incomplete: ${failedServers.join(", ")}.`,
+        failedServers,
+        recoveryCommands: failedServers.map((server) => `codex mcp login ${server}`),
+        raw,
+    };
+}
+//# sourceMappingURL=startup-prompts.js.map

package/dist/codex/startup-prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-prompts.js","sourceRoot":"","sources":["../../src/codex/startup-prompts.ts"],"names":[],"mappings":"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"}

package/dist/codex/tool-types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Codex built-in and extensible tool input types.
+ * Implements PRD §7A.
+ */
+export type CodexKnownToolName = "Bash" | "apply_patch";
+export type CodexUnknownToolName = `mcp__${string}` | `unknown:${string}`;
+export type CodexCommandToolInput = {
+    readonly command: string;
+    readonly description?: string | null;
+};
+export type CodexGenericToolInput = Readonly<Record<string, unknown>>;
+export type CodexToolEventFields = {
+    readonly tool_name: "Bash" | "apply_patch";
+    readonly tool_input: CodexCommandToolInput;
+    readonly tool_use_id?: string;
+} | {
+    readonly tool_name: CodexUnknownToolName;
+    readonly tool_input: CodexGenericToolInput;
+    readonly tool_use_id?: string;
+};
+//# sourceMappingURL=tool-types.d.ts.map

package/dist/codex/tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-types.d.ts","sourceRoot":"","sources":["../../src/codex/tool-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,aAAa,CAAC;AACxD,MAAM,MAAM,oBAAoB,GAAG,QAAQ,MAAM,EAAE,GAAG,WAAW,MAAM,EAAE,CAAC;AAE1E,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAC5B;IACE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC"}

package/dist/codex/tool-types.js

@@ -0,0 +1,6 @@
+/**
+ * Codex built-in and extensible tool input types.
+ * Implements PRD §7A.
+ */
+export {};
+//# sourceMappingURL=tool-types.js.map

package/dist/codex/tool-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-types.js","sourceRoot":"","sources":["../../src/codex/tool-types.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/codex/transcript/cursor-io.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bounded filesystem primitives for the Codex transcript cursor.
+ * Codex has only forward reads (no backward baseline-tail scan), so this is a thin
+ * re-export of the shared core primitives (PRD §7A/§5.4). See core/transcript/cursor-io.
+ */
+export { type ByteReader, byteLen, fileSize, type RangeRead, readBytes, readRange, resetByteReaderForTests, setByteReaderForTests, } from "../../core/transcript/cursor-io.ts";
+//# sourceMappingURL=cursor-io.d.ts.map

package/dist/codex/transcript/cursor-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.d.ts","sourceRoot":"","sources":["../../../src/codex/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,KAAK,UAAU,EACf,OAAO,EACP,QAAQ,EACR,KAAK,SAAS,EACd,SAAS,EACT,SAAS,EACT,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}

package/dist/codex/transcript/cursor-io.js

@@ -0,0 +1,7 @@
+/**
+ * Bounded filesystem primitives for the Codex transcript cursor.
+ * Codex has only forward reads (no backward baseline-tail scan), so this is a thin
+ * re-export of the shared core primitives (PRD §7A/§5.4). See core/transcript/cursor-io.
+ */
+export { byteLen, fileSize, readBytes, readRange, resetByteReaderForTests, setByteReaderForTests, } from "../../core/transcript/cursor-io.js";
+//# sourceMappingURL=cursor-io.js.map

package/dist/codex/transcript/cursor-io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.js","sourceRoot":"","sources":["../../../src/codex/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,OAAO,EACP,QAAQ,EAER,SAAS,EACT,SAAS,EACT,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}

package/dist/codex/transcript/cursor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bounded incremental reader for one Codex transcript JSONL file.
+ * Codex uses the shared bounded cursor verbatim (no backward baseline-tail scan and
+ * no async needsScan), so this re-exports the core cursor under the adapter's name.
+ * Implements PRD §7A/§5.4. See core/transcript/cursor.
+ */
+export { BoundedTranscriptCursor as CodexTranscriptCursor, type ChunkRead, type TakenLines, } from "../../core/transcript/cursor.ts";
+//# sourceMappingURL=cursor.d.ts.map

package/dist/codex/transcript/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/codex/transcript/cursor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,uBAAuB,IAAI,qBAAqB,EAChD,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,iCAAiC,CAAC"}

package/dist/codex/transcript/cursor.js

@@ -0,0 +1,8 @@
+/**
+ * Bounded incremental reader for one Codex transcript JSONL file.
+ * Codex uses the shared bounded cursor verbatim (no backward baseline-tail scan and
+ * no async needsScan), so this re-exports the core cursor under the adapter's name.
+ * Implements PRD §7A/§5.4. See core/transcript/cursor.
+ */
+export { BoundedTranscriptCursor as CodexTranscriptCursor, } from "../../core/transcript/cursor.js";
+//# sourceMappingURL=cursor.js.map

package/dist/codex/transcript/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../../src/codex/transcript/cursor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,uBAAuB,IAAI,qBAAqB,GAGjD,MAAM,iCAAiC,CAAC"}

package/dist/codex/transcript/drain.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bounded, self-yielding terminal drain for the Codex transcript watcher (flush).
+ * Implements PRD §7A/§5.4/§9.2: flushing at teardown drains the cursor to EOF within
+ * a chunk budget AND a small wall-clock slice, so no single call runs a
+ * hundreds-of-MiB synchronous loop that would stall the event loop. Any backlog
+ * still unread when the budget OR the slice is spent is accounted as a content-free
+ * `unread_backlog` drop, never read in an unbounded loop, so termination always
+ * completes in bounded work.
+ */
+import type { BoundedTranscriptCursor } from "../../core/transcript/cursor.ts";
+import type { DropReporter } from "../../core/transcript/drops.ts";
+import type { CodexLineEmitter } from "./emit.ts";
+/** A mutable chunk budget shared across every drain call across a watcher's life. */
+export type ChunkBudget = {
+    chunks: number;
+};
+/** One shared budget for a watcher's whole terminal-drain life. */
+export declare function newTerminalBudget(): ChunkBudget;
+/** The watcher collaborators a drain needs: the fs guard, emitter, and drop sink. */
+export type DrainContext = {
+    readFs<T>(path: string, read: () => T): T | undefined;
+    readonly lines: CodexLineEmitter;
+    readonly drops: DropReporter;
+    /** Per-call wall-clock ms cap (defaults to `drainSliceMs`); tests may override. */
+    readonly sliceMs?: number;
+    /** Monotonic clock (injectable for tests); defaults to `Date.now`. */
+    readonly now?: () => number;
+};
+export declare function drainToBudget(context: DrainContext, cursor: BoundedTranscriptCursor, budget: ChunkBudget): void;
+//# sourceMappingURL=drain.d.ts.map

package/dist/codex/transcript/drain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain.d.ts","sourceRoot":"","sources":["../../../src/codex/transcript/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,qFAAqF;AACrF,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAO7C,mEAAmE;AACnE,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C;AAED,qFAAqF;AACrF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B,CAAC;AAMF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,WAAW,GAClB,IAAI,CASN"}

package/dist/codex/transcript/drain.js

@@ -0,0 +1,48 @@
+/**
+ * Bounded, self-yielding terminal drain for the Codex transcript watcher (flush).
+ * Implements PRD §7A/§5.4/§9.2: flushing at teardown drains the cursor to EOF within
+ * a chunk budget AND a small wall-clock slice, so no single call runs a
+ * hundreds-of-MiB synchronous loop that would stall the event loop. Any backlog
+ * still unread when the budget OR the slice is spent is accounted as a content-free
+ * `unread_backlog` drop, never read in an unbounded loop, so termination always
+ * completes in bounded work.
+ */
+/** Terminal-drain chunk budget, shared ONCE per watcher across every flush call. */
+const drainChunkBudget = 256;
+/** Wall-clock ms a single drain call may run before the leftover backlog is dropped. */
+const drainSliceMs = 50;
+/** One shared budget for a watcher's whole terminal-drain life. */
+export function newTerminalBudget() {
+    return { chunks: drainChunkBudget };
+}
+// Drain the cursor to EOF within a chunk budget and a per-call wall-clock deadline.
+// A cursor left with an unread backlog when the budget OR the deadline is spent is
+// accounted as a content-free `unread_backlog` drop (its size, not content), and
+// the final buffered partial is flushed once.
+export function drainToBudget(context, cursor, budget) {
+    const now = context.now ?? Date.now;
+    const deadline = now() + (context.sliceMs ?? drainSliceMs);
+    const hasBacklog = drainCursor(context, cursor, budget, deadline, now);
+    // An unread teardown backlog is content-free data loss with its OWN cause: it
+    // surfaces as ONE live drop warning under a truthful cause.
+    if (hasBacklog)
+        context.drops.drop(cursor.path, "unread_backlog");
+    context.lines.emitLine(cursor.path, cursor.drainPending());
+    context.drops.flushPass(); // deliver this drain's coalesced drops (bounded fan-out)
+}
+// Read the cursor to EOF within the budget and the per-call deadline. Returns whether
+// bytes remained unread when the budget or the deadline was spent (false when drained).
+function drainCursor(context, cursor, budget, deadline, now) {
+    while (budget.chunks > 0 && now() < deadline) {
+        budget.chunks -= 1;
+        const chunk = context.readFs(cursor.path, () => cursor.readChunk());
+        if (chunk === undefined)
+            return false; // contained FS failure; nothing to account
+        if (chunk.text.length > 0)
+            context.lines.emitLines(cursor.path, chunk.text, cursor);
+        if (!chunk.canContinueNow)
+            return false;
+    }
+    return (context.readFs(cursor.path, () => cursor.remainingBytes()) ?? 0) > 0;
+}
+//# sourceMappingURL=drain.js.map

package/dist/codex/transcript/drain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain.js","sourceRoot":"","sources":["../../../src/codex/transcript/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,oFAAoF;AACpF,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAC7B,wFAAwF;AACxF,MAAM,YAAY,GAAG,EAAE,CAAC;AAExB,mEAAmE;AACnE,MAAM,UAAU,iBAAiB;IAC/B,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;AACtC,CAAC;AAaD,oFAAoF;AACpF,mFAAmF;AACnF,iFAAiF;AACjF,8CAA8C;AAC9C,MAAM,UAAU,aAAa,CAC3B,OAAqB,EACrB,MAA+B,EAC/B,MAAmB;IAEnB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACpC,MAAM,QAAQ,GAAG,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,CAAC;IAC3D,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;IACvE,8EAA8E;IAC9E,4DAA4D;IAC5D,IAAI,UAAU;QAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IAClE,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;IAC3D,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,yDAAyD;AACtF,CAAC;AAED,sFAAsF;AACtF,wFAAwF;AACxF,SAAS,WAAW,CAClB,OAAqB,EACrB,MAA+B,EAC/B,MAAmB,EACnB,QAAgB,EAChB,GAAiB;IAEjB,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC7C,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;QACnB,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QACpE,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,CAAC,2CAA2C;QAClF,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACpF,IAAI,CAAC,KAAK,CAAC,cAAc;YAAE,OAAO,KAAK,CAAC;IAC1C,CAAC;IACD,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC/E,CAAC"}

package/dist/codex/transcript/drops.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Content-free, live-only reporting of Codex transcript observation problems.
+ * Identical to Claude's, so it re-exports the shared core reporters (DropReporter /
+ * ReadErrorReporter) and notice types under the adapter's names. Each problem emits
+ * one live, count-free warning; nothing is accumulated. Implements PRD §7A/§5.4. See
+ * core/transcript/drops.
+ */
+export { type DropCause, DropReporter as CodexDropReporter, ReadErrorReporter as CodexReadErrorReporter, type TranscriptDropNotice as CodexDropNotice, type TranscriptReadErrorNotice as CodexReadErrorNotice, } from "../../core/transcript/drops.ts";
+//# sourceMappingURL=drops.d.ts.map

package/dist/codex/transcript/drops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drops.d.ts","sourceRoot":"","sources":["../../../src/codex/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,SAAS,EACd,YAAY,IAAI,iBAAiB,EACjC,iBAAiB,IAAI,sBAAsB,EAC3C,KAAK,oBAAoB,IAAI,eAAe,EAC5C,KAAK,yBAAyB,IAAI,oBAAoB,GACvD,MAAM,gCAAgC,CAAC"}

package/dist/codex/transcript/drops.js

@@ -0,0 +1,9 @@
+/**
+ * Content-free, live-only reporting of Codex transcript observation problems.
+ * Identical to Claude's, so it re-exports the shared core reporters (DropReporter /
+ * ReadErrorReporter) and notice types under the adapter's names. Each problem emits
+ * one live, count-free warning; nothing is accumulated. Implements PRD §7A/§5.4. See
+ * core/transcript/drops.
+ */
+export { DropReporter as CodexDropReporter, ReadErrorReporter as CodexReadErrorReporter, } from "../../core/transcript/drops.js";
+//# sourceMappingURL=drops.js.map

package/dist/codex/transcript/drops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drops.js","sourceRoot":"","sources":["../../../src/codex/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,YAAY,IAAI,iBAAiB,EACjC,iBAAiB,IAAI,sBAAsB,GAG5C,MAAM,gCAAgC,CAAC"}

package/dist/codex/transcript/emit.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Parses committed Codex transcript lines into events, reporting drops.
+ * Implements PRD §7A/§5.4 (C-API-12): only committed, parseable records become
+ * events; a malformed line or a discarded over-length record is reported through the
+ * drop reporter as a live, count-free warning (coalesced per scan pass), never as an
+ * event of its own.
+ */
+import type { BoundedTranscriptCursor } from "../../core/transcript/cursor.ts";
+import type { DropReporter } from "../../core/transcript/drops.ts";
+import type { CodexTranscriptEvent } from "./types.ts";
+/** Turns raw transcript text into parsed events for one watcher. */
+export declare class CodexLineEmitter {
+    private readonly elwoodSessionId;
+    private readonly emit;
+    private readonly drops;
+    constructor(id: string, emit: (event: CodexTranscriptEvent) => void, drops: DropReporter);
+    /** Emit complete lines from `text`; the cursor retains any trailing partial line. */
+    emitLines(path: string, text: string, cursor: BoundedTranscriptCursor): void;
+    /** Emit a single already-complete line (the final drained partial at teardown). */
+    emitLine(path: string, line: string): void;
+}
+//# sourceMappingURL=emit.d.ts.map