@with-logic/elwood 0.1.0

package/dist/runtime/initial-ready-advance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The one-shot initial-ready transition with an anti-starvation completion boundary,
+ * shared by BOTH adapters (PRD §5.3, C-API-42). The status engine commits
+ * `current = ready` BEFORE it emits and releases the queue, so a lifecycle-listener
+ * throw there would leave the queue suspended AND make a retry a no-op (status is
+ * already `ready`). On any throw this releases the queue DIRECTLY and surfaces the
+ * risk as a typed, content-free `initial_ready_fallback` warning (emitted lifecycle
+ * events may be stale), so queued input is never starved by a partially-committed
+ * ready transition.
+ */
+import type { ElwoodAgentKind } from "../core/activity.ts";
+import type { ElwoodWarningEvent } from "../core/types.ts";
+/** The narrow session surface the initial-ready advance needs. */
+export type InitialReadyAdvanceDeps = {
+    readonly agent: ElwoodAgentKind;
+    readonly elwoodSessionId: string;
+    readonly submitInitialReady: () => void;
+    readonly markReady: () => void;
+    readonly emitWarnings: (warnings: readonly ElwoodWarningEvent[]) => void;
+};
+export declare function advanceInitialReady(deps: InitialReadyAdvanceDeps): void;
+//# sourceMappingURL=initial-ready-advance.d.ts.map

package/dist/runtime/initial-ready-advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready-advance.d.ts","sourceRoot":"","sources":["../../src/runtime/initial-ready-advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,kEAAkE;AAClE,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,IAAI,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,KAAK,IAAI,CAAC;CAC1E,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAavE"}

package/dist/runtime/initial-ready-advance.js

@@ -0,0 +1,39 @@
+/**
+ * The one-shot initial-ready transition with an anti-starvation completion boundary,
+ * shared by BOTH adapters (PRD §5.3, C-API-42). The status engine commits
+ * `current = ready` BEFORE it emits and releases the queue, so a lifecycle-listener
+ * throw there would leave the queue suspended AND make a retry a no-op (status is
+ * already `ready`). On any throw this releases the queue DIRECTLY and surfaces the
+ * risk as a typed, content-free `initial_ready_fallback` warning (emitted lifecycle
+ * events may be stale), so queued input is never starved by a partially-committed
+ * ready transition.
+ */
+export function advanceInitialReady(deps) {
+    try {
+        deps.submitInitialReady();
+    }
+    catch {
+        // A lifecycle-event LISTENER threw after `current` committed to `ready`; release
+        // the queue unconditionally so queued input is never starved, then warn.
+        deps.markReady();
+        try {
+            deps.emitWarnings([fallbackWarning(deps.agent, deps.elwoodSessionId)]);
+        }
+        catch {
+            // A warning-sink/listener failure must never block the readiness release.
+        }
+    }
+}
+/** Live-only and content-free: no raw system message, no listener error text. */
+function fallbackWarning(agent, elwoodSessionId) {
+    return {
+        elwoodSessionId,
+        agent,
+        source: "lifecycle",
+        code: "initial_ready_fallback",
+        severity: "warning",
+        message: "Recording the initial-ready transition failed; released the queue directly, so lifecycle events may be stale.",
+        raw: "initial_ready_fallback",
+    };
+}
+//# sourceMappingURL=initial-ready-advance.js.map

package/dist/runtime/initial-ready-advance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready-advance.js","sourceRoot":"","sources":["../../src/runtime/initial-ready-advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAcH,MAAM,UAAU,mBAAmB,CAAC,IAA6B;IAC/D,IAAI,CAAC;QACH,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,iFAAiF;QACjF,yEAAyE;QACzE,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,CAAC,YAAY,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACzE,CAAC;QAAC,MAAM,CAAC;YACP,0EAA0E;QAC5E,CAAC;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,SAAS,eAAe,CAAC,KAAsB,EAAE,eAAuB;IACtE,OAAO;QACL,eAAe;QACf,KAAK;QACL,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,wBAAwB;QAC9B,QAAQ,EAAE,SAAS;QACnB,OAAO,EACL,+GAA+G;QACjH,GAAG,EAAE,wBAAwB;KAC9B,CAAC;AACJ,CAAC"}

package/dist/runtime/initial-ready-fallback.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The live, content-free warning for a fallback initial-ready transition.
+ * Implements PRD §5.3 and C-API-42: when recording a session's one-shot initial-ready
+ * transition throws (a lifecycle-event listener), Elwood still releases the control
+ * queue directly so queued input is never starved, but emitted lifecycle events may be
+ * stale. This surfaces that risk as a typed `initial_ready_fallback` warning carrying
+ * no raw system message or session content. Both adapters.
+ */
+import type { ElwoodAgentKind } from "../core/activity.ts";
+import type { ElwoodWarningEvent } from "../core/types.ts";
+export declare function initialReadyFallbackWarning(agent: ElwoodAgentKind, elwoodSessionId: string): ElwoodWarningEvent;
+//# sourceMappingURL=initial-ready-fallback.d.ts.map

package/dist/runtime/initial-ready-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready-fallback.d.ts","sourceRoot":"","sources":["../../src/runtime/initial-ready-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,eAAe,EACtB,eAAe,EAAE,MAAM,GACtB,kBAAkB,CAWpB"}

package/dist/runtime/initial-ready-fallback.js

@@ -0,0 +1,20 @@
+/**
+ * The live, content-free warning for a fallback initial-ready transition.
+ * Implements PRD §5.3 and C-API-42: when recording a session's one-shot initial-ready
+ * transition throws (a lifecycle-event listener), Elwood still releases the control
+ * queue directly so queued input is never starved, but emitted lifecycle events may be
+ * stale. This surfaces that risk as a typed `initial_ready_fallback` warning carrying
+ * no raw system message or session content. Both adapters.
+ */
+export function initialReadyFallbackWarning(agent, elwoodSessionId) {
+    return {
+        elwoodSessionId,
+        agent,
+        source: "lifecycle",
+        code: "initial_ready_fallback",
+        severity: "warning",
+        message: "Recording the initial-ready transition failed; released the queue directly, so lifecycle events may be stale.",
+        raw: "initial_ready_fallback",
+    };
+}
+//# sourceMappingURL=initial-ready-fallback.js.map

package/dist/runtime/initial-ready-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready-fallback.js","sourceRoot":"","sources":["../../src/runtime/initial-ready-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,UAAU,2BAA2B,CACzC,KAAsB,EACtB,eAAuB;IAEvB,OAAO;QACL,eAAe;QACf,KAAK;QACL,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,wBAAwB;QAC9B,QAAQ,EAAE,SAAS;QACnB,OAAO,EACL,+GAA+G;QACjH,GAAG,EAAE,wBAAwB;KAC9B,CAAC;AACJ,CAAC"}

package/dist/runtime/initial-ready.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared hook-backed initial-readiness marker with a starvation deadline.
+ * Implements PRD §5.3, C-API-19, and C-API-28.
+ *
+ * On a COLD start both adapters gate the first queued message on a pre-input
+ * readiness hook — Claude's `InstructionsLoaded`, Codex's `SessionStart` — the CLI's
+ * authoritative "initialized and accepting input" signal, fired via `mark`. The
+ * rendered composer is NOT a readiness signal on cold start: it paints as a boot
+ * placeholder before input is accepted, so releasing the first queued message on it
+ * would swallow the message. On RESUME the input loop is live when the composer paints,
+ * so `markReadyOnResumeComposer` releases readiness on the first composer marker
+ * (verified accepted, not swallowed) — UNLESS a blocking dialog is on screen, whose
+ * option caret is byte-identical to the composer marker. The hooks differ on resume:
+ * Codex does NOT re-fire `SessionStart` (so the composer is the fast signal), while
+ * Claude's `InstructionsLoaded` DOES re-fire — so a resumed Claude is a hook/composer
+ * race, whichever arrives first (readiness is idempotent). `armDeadline` is the ultimate
+ * fallback for both start and resume so a missing readiness signal never starves the
+ * queue forever.
+ */
+export type InitialReady = {
+    readonly cancel: () => void;
+    readonly replay: () => void;
+    readonly armDeadline: () => void;
+    /** Fire readiness now (one-shot) — the pre-input readiness hook path. */
+    readonly mark: () => void;
+    /**
+     * Re-attempt a readiness mark that a hook/deadline requested while a blocking
+     * dialog was on screen. Call per rendered frame with the frame's blocking fact:
+     * once the dialog clears, the deferred readiness fires so the queue is never
+     * drained INTO the dialog and is never permanently starved BY it (C-API-28).
+     */
+    readonly retryWhenUnblocked: (blockingVisible: boolean) => void;
+};
+/** The rendered-frame facts the resume-composer readiness path inspects. */
+export type ComposerReadyFacts = {
+    readonly composer_visible: boolean;
+    readonly blocking_prompt_visible: boolean;
+};
+/**
+ * On RESUME, mark readiness on the first genuine composer frame: the composer is
+ * visible AND no blocking dialog is on screen. The dialog's option caret (`›`/`❯`) is
+ * byte-identical to the composer marker, so a dialog frame must NOT latch readiness —
+ * otherwise a draining queued message's Enter could approve the dialog; readiness waits
+ * for the dialog to clear. Cold start (`resumed: false`) never fires here, so the
+ * composer stays an unsafe signal there (C-API-28).
+ */
+export declare function markReadyOnResumeComposer(ready: Pick<InitialReady, "mark">, resumed: boolean, facts: ComposerReadyFacts): void;
+export declare function initialReady(callback: () => void, maxWaitMs?: number, isBlocked?: () => boolean): InitialReady;
+//# sourceMappingURL=initial-ready.d.ts.map

package/dist/runtime/initial-ready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready.d.ts","sourceRoot":"","sources":["../../src/runtime/initial-ready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,CAAC,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC;CACjE,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAC3C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,kBAAkB,GACxB,IAAI,CAEN;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,IAAI,EACpB,SAAS,SAAS,EAClB,SAAS,GAAE,MAAM,OAAqB,GACrC,YAAY,CA4Cd"}

package/dist/runtime/initial-ready.js

@@ -0,0 +1,81 @@
+/**
+ * Shared hook-backed initial-readiness marker with a starvation deadline.
+ * Implements PRD §5.3, C-API-19, and C-API-28.
+ *
+ * On a COLD start both adapters gate the first queued message on a pre-input
+ * readiness hook — Claude's `InstructionsLoaded`, Codex's `SessionStart` — the CLI's
+ * authoritative "initialized and accepting input" signal, fired via `mark`. The
+ * rendered composer is NOT a readiness signal on cold start: it paints as a boot
+ * placeholder before input is accepted, so releasing the first queued message on it
+ * would swallow the message. On RESUME the input loop is live when the composer paints,
+ * so `markReadyOnResumeComposer` releases readiness on the first composer marker
+ * (verified accepted, not swallowed) — UNLESS a blocking dialog is on screen, whose
+ * option caret is byte-identical to the composer marker. The hooks differ on resume:
+ * Codex does NOT re-fire `SessionStart` (so the composer is the fast signal), while
+ * Claude's `InstructionsLoaded` DOES re-fire — so a resumed Claude is a hook/composer
+ * race, whichever arrives first (readiness is idempotent). `armDeadline` is the ultimate
+ * fallback for both start and resume so a missing readiness signal never starves the
+ * queue forever.
+ */
+/**
+ * On RESUME, mark readiness on the first genuine composer frame: the composer is
+ * visible AND no blocking dialog is on screen. The dialog's option caret (`›`/`❯`) is
+ * byte-identical to the composer marker, so a dialog frame must NOT latch readiness —
+ * otherwise a draining queued message's Enter could approve the dialog; readiness waits
+ * for the dialog to clear. Cold start (`resumed: false`) never fires here, so the
+ * composer stays an unsafe signal there (C-API-28).
+ */
+export function markReadyOnResumeComposer(ready, resumed, facts) {
+    if (resumed && facts.composer_visible && !facts.blocking_prompt_visible)
+        ready.mark();
+}
+export function initialReady(callback, maxWaitMs = 10_000, isBlocked = () => false) {
+    let ready = false;
+    let deferredByBlock = false;
+    let deadline;
+    const mark = () => {
+        if (ready)
+            return;
+        // A blocking dialog is on screen (it may have rendered while still `starting`,
+        // so it never latched `blocked`): do NOT release the queue into it. Remember the
+        // request and re-fire it from `retryWhenUnblocked` once the dialog clears — never
+        // latch here, so readiness is neither drained into the dialog nor starved by it.
+        if (isBlocked()) {
+            deferredByBlock = true;
+            return;
+        }
+        deferredByBlock = false;
+        // Latch AFTER the callback returns, so if it throws (a throwing status/activity
+        // listener) readiness is NOT consumed and a later hook/deadline/frame retries —
+        // a failed transition must never permanently starve the queue (C-API-28).
+        callback();
+        ready = true;
+    };
+    return {
+        cancel: () => {
+            if (deadline)
+                clearTimeout(deadline);
+        },
+        mark,
+        retryWhenUnblocked: (blockingVisible) => {
+            if (!ready && deferredByBlock && !blockingVisible)
+                mark();
+        },
+        replay: () => void (ready && callback()),
+        // Arms on the first frame regardless of hook arrival, so a missing or failed
+        // readiness hook cannot starve readiness forever. The deadline's mark is contained
+        // (a throwing callback on a timer would otherwise be an uncaught exception); if it
+        // fails, `ready` stays false so a later hook or composer frame still retries.
+        armDeadline: () => {
+            deadline ??= setTimeout(() => {
+                try {
+                    mark();
+                }
+                catch {
+                    // Retried by a subsequent readiness hook or rendered composer frame.
+                }
+            }, maxWaitMs);
+        },
+    };
+}
+//# sourceMappingURL=initial-ready.js.map

package/dist/runtime/initial-ready.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready.js","sourceRoot":"","sources":["../../src/runtime/initial-ready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAuBH;;;;;;;GAOG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAiC,EACjC,OAAgB,EAChB,KAAyB;IAEzB,IAAI,OAAO,IAAI,KAAK,CAAC,gBAAgB,IAAI,CAAC,KAAK,CAAC,uBAAuB;QAAE,KAAK,CAAC,IAAI,EAAE,CAAC;AACxF,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,QAAoB,EACpB,SAAS,GAAG,MAAM,EAClB,YAA2B,GAAG,EAAE,CAAC,KAAK;IAEtC,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,QAAmD,CAAC;IACxD,MAAM,IAAI,GAAG,GAAG,EAAE;QAChB,IAAI,KAAK;YAAE,OAAO;QAClB,+EAA+E;QAC/E,iFAAiF;QACjF,kFAAkF;QAClF,iFAAiF;QACjF,IAAI,SAAS,EAAE,EAAE,CAAC;YAChB,eAAe,GAAG,IAAI,CAAC;YACvB,OAAO;QACT,CAAC;QACD,eAAe,GAAG,KAAK,CAAC;QACxB,gFAAgF;QAChF,gFAAgF;QAChF,0EAA0E;QAC1E,QAAQ,EAAE,CAAC;QACX,KAAK,GAAG,IAAI,CAAC;IACf,CAAC,CAAC;IACF,OAAO;QACL,MAAM,EAAE,GAAG,EAAE;YACX,IAAI,QAAQ;gBAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC;QACD,IAAI;QACJ,kBAAkB,EAAE,CAAC,eAAe,EAAE,EAAE;YACtC,IAAI,CAAC,KAAK,IAAI,eAAe,IAAI,CAAC,eAAe;gBAAE,IAAI,EAAE,CAAC;QAC5D,CAAC;QACD,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,EAAE,CAAC;QACxC,6EAA6E;QAC7E,mFAAmF;QACnF,mFAAmF;QACnF,8EAA8E;QAC9E,WAAW,EAAE,GAAG,EAAE;YAChB,QAAQ,KAAK,UAAU,CAAC,GAAG,EAAE;gBAC3B,IAAI,CAAC;oBACH,IAAI,EAAE,CAAC;gBACT,CAAC;gBAAC,MAAM,CAAC;oBACP,qEAAqE;gBACvE,CAAC;YACH,CAAC,EAAE,SAAS,CAAC,CAAC;QAChB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/runtime/loop-restore.d.ts

@@ -0,0 +1,10 @@
+/** Restores persisted loop definitions before live resources start (PRD §5.9/§9.3). */
+import { type PersistedLoopDefinition, readLoopDefinitions, writeLoopDefinitions } from "../state/loop-store.ts";
+type LoopRestoreIo = {
+    readonly read: typeof readLoopDefinitions;
+    readonly write: typeof writeLoopDefinitions;
+};
+/** Read definitions and durably prune expiry before a resumed PTY or bridge is created. */
+export declare function loadRuntimeLoopDefinitions(stateDir: string, elwoodSessionId: string, now?: number, io?: LoopRestoreIo): readonly PersistedLoopDefinition[];
+export {};
+//# sourceMappingURL=loop-restore.d.ts.map

package/dist/runtime/loop-restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-restore.d.ts","sourceRoot":"","sources":["../../src/runtime/loop-restore.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAGvF,OAAO,EACL,KAAK,uBAAuB,EAE5B,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAEhC,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,OAAO,mBAAmB,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,OAAO,oBAAoB,CAAC;CAC7C,CAAC;AAOF,2FAA2F;AAC3F,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,GAAG,SAAa,EAChB,EAAE,GAAE,aAAyB,GAC5B,SAAS,uBAAuB,EAAE,CAcpC"}

package/dist/runtime/loop-restore.js

@@ -0,0 +1,26 @@
+/** Restores persisted loop definitions before live resources start (PRD §5.9/§9.3). */
+import { elwoodError } from "../core/errors.js";
+import { pruneExpiredLoopDefinitions, readLoopDefinitions, writeLoopDefinitions, } from "../state/loop-store.js";
+const defaultIo = {
+    read: readLoopDefinitions,
+    write: writeLoopDefinitions,
+};
+/** Read definitions and durably prune expiry before a resumed PTY or bridge is created. */
+export function loadRuntimeLoopDefinitions(stateDir, elwoodSessionId, now = Date.now(), io = defaultIo) {
+    const definitions = io.read(stateDir, elwoodSessionId);
+    const expired = definitions.find((definition) => definition.expiresAt <= now);
+    if (expired === undefined)
+        return definitions;
+    const active = pruneExpiredLoopDefinitions(definitions, now);
+    try {
+        io.write(stateDir, elwoodSessionId, active);
+    }
+    catch {
+        // Details name only the loop id, never its prompt (§10 loop_persistence_failed).
+        throw elwoodError("loop_persistence_failed", "Could not prune expired loop state.", {
+            loopId: expired.id,
+        });
+    }
+    return active;
+}
+//# sourceMappingURL=loop-restore.js.map

package/dist/runtime/loop-restore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-restore.js","sourceRoot":"","sources":["../../src/runtime/loop-restore.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAEvF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAEL,2BAA2B,EAC3B,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAOhC,MAAM,SAAS,GAAkB;IAC/B,IAAI,EAAE,mBAAmB;IACzB,KAAK,EAAE,oBAAoB;CAC5B,CAAC;AAEF,2FAA2F;AAC3F,MAAM,UAAU,0BAA0B,CACxC,QAAgB,EAChB,eAAuB,EACvB,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,EAChB,KAAoB,SAAS;IAE7B,MAAM,WAAW,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC;IAC9E,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAC9C,MAAM,MAAM,GAAG,2BAA2B,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IAC7D,IAAI,CAAC;QACH,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,iFAAiF;QACjF,MAAM,WAAW,CAAC,yBAAyB,EAAE,qCAAqC,EAAE;YAClF,MAAM,EAAE,OAAO,CAAC,EAAE;SACnB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/runtime/probe.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bounded one-shot subprocess probe used by the command-runner seam.
+ * Implements PRD §9.2 bounded probe runtime/output (C-PERF-01, C-PERF-03): a
+ * misbehaving CLI on PATH must not hang or flood memory during a `--version`,
+ * `update`, or `--help` probe.
+ */
+import type { CommandResult } from "./seams.ts";
+export declare function setProbeTimeoutMsForTests(value: number): void;
+export declare function resetProbeTimeoutForTests(): void;
+export declare function runProbe(command: string, args: readonly string[]): Promise<CommandResult>;
+//# sourceMappingURL=probe.d.ts.map

package/dist/runtime/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/runtime/probe.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE7D;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAgCD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAsCzF"}

package/dist/runtime/probe.js

@@ -0,0 +1,120 @@
+/**
+ * Bounded one-shot subprocess probe used by the command-runner seam.
+ * Implements PRD §9.2 bounded probe runtime/output (C-PERF-01, C-PERF-03): a
+ * misbehaving CLI on PATH must not hang or flood memory during a `--version`,
+ * `update`, or `--help` probe.
+ */
+import { spawn } from "node:child_process";
+import { completeUtf8Length } from "../core/utf8.js";
+import { rethrowUnlessGroupGone } from "./shutdown/reap-tree.js";
+const defaultProbeTimeoutMs = 15_000;
+const maxProbeOutputBytes = 1_000_000;
+let probeTimeoutMs = defaultProbeTimeoutMs;
+export function setProbeTimeoutMsForTests(value) {
+    probeTimeoutMs = value;
+}
+export function resetProbeTimeoutForTests() {
+    probeTimeoutMs = defaultProbeTimeoutMs;
+}
+/** Accumulates stream chunks up to a hard byte cap, tracking overflow. */
+class CappedBuffer {
+    chunks = [];
+    byteLength = 0;
+    overflowed = false;
+    append(chunk) {
+        // Once the cap is hit the probe is aborted and its pipes destroyed, so no chunk
+        // ever arrives after `overflowed` is set; the first over-cap chunk is the last.
+        const remaining = maxProbeOutputBytes - this.byteLength;
+        if (chunk.length > remaining) {
+            this.chunks.push(chunk.subarray(0, remaining));
+            this.byteLength = maxProbeOutputBytes;
+            this.overflowed = true;
+            return;
+        }
+        this.chunks.push(chunk);
+        this.byteLength += chunk.length;
+    }
+    text() {
+        // Byte capping can split a multibyte code point at the boundary. Drop any
+        // incomplete trailing UTF-8 sequence so the decoded string re-encodes to
+        // at most the byte cap (C-PERF-03) rather than growing via a replacement
+        // character.
+        const bytes = Buffer.concat(this.chunks);
+        return bytes.subarray(0, completeUtf8Length(bytes)).toString("utf8");
+    }
+}
+export function runProbe(command, args) {
+    return new Promise((resolve) => {
+        // Probe shells are interactive so they load the same user PATH as the PTY launch. Give
+        // them a fresh session: an interactive shell otherwise enables job control on Elwood's
+        // controlling terminal and can leave its short-lived command's process group in the
+        // foreground, causing headed cleanup to stop on SIGTTOU before restoring terminal modes.
+        const child = spawn(command, [...args], { detached: true });
+        const out = new CappedBuffer();
+        const err = new CappedBuffer();
+        let settled = false;
+        // Kill only when WE abort the probe (timeout/overflow); a normal exit or
+        // spawn failure needs no signal (C-PERF-03).
+        const settle = (result, kill = false) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (kill)
+                abortProbe(child);
+            resolve(result);
+        };
+        const onData = (buffer) => (chunk) => {
+            buffer.append(chunk);
+            if (out.overflowed || err.overflowed)
+                settle(overflow(out.text(), err.text()), true);
+        };
+        child.stdout.on("data", onData(out));
+        child.stderr.on("data", onData(err));
+        // Spawn failure (e.g. ENOENT) fires `error` and not `close`. Node's spawn
+        // `error` always carries a `code`, which preflight maps to `*_not_found`.
+        child.on("error", (e) => {
+            settle({ status: null, stdout: out.text(), stderr: err.text(), error: mapError(e) });
+        });
+        child.on("close", (code) => {
+            settle({ status: code, stdout: out.text(), stderr: err.text() });
+        });
+        const timer = setTimeout(() => {
+            settle(timedOut(out.text(), err.text()), true);
+        }, probeTimeoutMs);
+        timer.unref?.();
+    });
+}
+/**
+ * Aborts a probe Elwood gave up on. `detached: true` made the shell its own
+ * process-group leader, so SIGKILLing the GROUP (not just the shell pid) also
+ * reaches grandchildren such as an installer spawned under `claude update` via
+ * `zsh -l -i -c`; a survivor would otherwise inherit the stdio pipes, keep them
+ * open, and pin the host event loop long after the probe "timed out". The pipes
+ * are destroyed here for the same reason: nothing a killed probe still writes is
+ * wanted, and an open pipe alone keeps the loop alive.
+ */
+function abortProbe(child) {
+    try {
+        // A spawn failure settles via `error` on the next tick, before any timer or
+        // data can request a kill, so a killed child always has a pid.
+        process.kill(-child.pid, "SIGKILL");
+    }
+    catch (error) {
+        rethrowUnlessGroupGone(error);
+    }
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
+function mapError(error) {
+    return { code: error.code, message: error.message };
+}
+function timedOut(stdout, stderr) {
+    const message = `probe timed out after ${probeTimeoutMs} ms`;
+    return { status: null, stdout, stderr, error: { code: "ETIMEDOUT", message } };
+}
+function overflow(stdout, stderr) {
+    const message = `probe output exceeded ${maxProbeOutputBytes} bytes`;
+    return { status: null, stdout, stderr, error: { code: "E2BIG", message } };
+}
+//# sourceMappingURL=probe.js.map

package/dist/runtime/probe.js.map

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

package/dist/runtime/readiness/advance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The one-shot initial-ready transition with an anti-starvation completion boundary,
+ * shared by BOTH adapters (PRD §5.3, C-API-42). The status engine commits
+ * `current = ready` BEFORE it emits and releases the queue, so a lifecycle-listener
+ * throw there would leave the queue suspended AND make a retry a no-op (status is
+ * already `ready`). On any throw this releases the queue DIRECTLY and surfaces the
+ * risk as a typed, content-free `initial_ready_fallback` warning (emitted lifecycle
+ * events may be stale), so queued input is never starved by a partially-committed
+ * ready transition.
+ */
+import type { ElwoodAgentKind } from "../../core/activity/index.ts";
+import type { ElwoodWarningEvent } from "../../core/types.ts";
+/** The narrow session surface the initial-ready advance needs. */
+export type InitialReadyAdvanceDeps = {
+    readonly agent: ElwoodAgentKind;
+    readonly elwoodSessionId: string;
+    readonly submitInitialReady: () => void;
+    readonly markReady: () => void;
+    readonly emitWarnings: (warnings: readonly ElwoodWarningEvent[]) => void;
+};
+export declare function advanceInitialReady(deps: InitialReadyAdvanceDeps): void;
+//# sourceMappingURL=advance.d.ts.map

package/dist/runtime/readiness/advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.d.ts","sourceRoot":"","sources":["../../../src/runtime/readiness/advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,kEAAkE;AAClE,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,IAAI,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,KAAK,IAAI,CAAC;CAC1E,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAavE"}

package/dist/runtime/readiness/advance.js

@@ -0,0 +1,39 @@
+/**
+ * The one-shot initial-ready transition with an anti-starvation completion boundary,
+ * shared by BOTH adapters (PRD §5.3, C-API-42). The status engine commits
+ * `current = ready` BEFORE it emits and releases the queue, so a lifecycle-listener
+ * throw there would leave the queue suspended AND make a retry a no-op (status is
+ * already `ready`). On any throw this releases the queue DIRECTLY and surfaces the
+ * risk as a typed, content-free `initial_ready_fallback` warning (emitted lifecycle
+ * events may be stale), so queued input is never starved by a partially-committed
+ * ready transition.
+ */
+export function advanceInitialReady(deps) {
+    try {
+        deps.submitInitialReady();
+    }
+    catch {
+        // A lifecycle-event LISTENER threw after `current` committed to `ready`; release
+        // the queue unconditionally so queued input is never starved, then warn.
+        deps.markReady();
+        try {
+            deps.emitWarnings([fallbackWarning(deps.agent, deps.elwoodSessionId)]);
+        }
+        catch {
+            // A warning-sink/listener failure must never block the readiness release.
+        }
+    }
+}
+/** Live-only and content-free: no raw system message, no listener error text. */
+function fallbackWarning(agent, elwoodSessionId) {
+    return {
+        elwoodSessionId,
+        agent,
+        source: "lifecycle",
+        code: "initial_ready_fallback",
+        severity: "warning",
+        message: "Recording the initial-ready transition failed; released the queue directly, so lifecycle events may be stale.",
+        raw: "initial_ready_fallback",
+    };
+}
+//# sourceMappingURL=advance.js.map

package/dist/runtime/readiness/advance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.js","sourceRoot":"","sources":["../../../src/runtime/readiness/advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAcH,MAAM,UAAU,mBAAmB,CAAC,IAA6B;IAC/D,IAAI,CAAC;QACH,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,iFAAiF;QACjF,yEAAyE;QACzE,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,CAAC,YAAY,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACzE,CAAC;QAAC,MAAM,CAAC;YACP,0EAA0E;QAC5E,CAAC;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,SAAS,eAAe,CAAC,KAAsB,EAAE,eAAuB;IACtE,OAAO;QACL,eAAe;QACf,KAAK;QACL,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,wBAAwB;QAC9B,QAAQ,EAAE,SAAS;QACnB,OAAO,EACL,+GAA+G;QACjH,GAAG,EAAE,wBAAwB;KAC9B,CAAC;AACJ,CAAC"}

package/dist/runtime/readiness/initial-ready.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared hook-backed initial-readiness marker with a starvation deadline.
+ * Implements PRD §5.3, C-API-19, and C-API-28.
+ *
+ * On a COLD start both adapters gate the first queued message on a pre-input
+ * readiness hook — Claude's `InstructionsLoaded`, Codex's `SessionStart` — the CLI's
+ * authoritative "initialized and accepting input" signal, fired via `mark`. The
+ * rendered composer is NOT a readiness signal on cold start: it paints as a boot
+ * placeholder before input is accepted, so releasing the first queued message on it
+ * would swallow the message. On RESUME the input loop is live when the composer paints,
+ * so `markReadyOnResumeComposer` releases readiness on the first composer marker
+ * (verified accepted, not swallowed) — UNLESS a blocking dialog is on screen, whose
+ * option caret is byte-identical to the composer marker. The hooks differ on resume:
+ * Codex does NOT re-fire `SessionStart` (so the composer is the fast signal), while
+ * Claude's `InstructionsLoaded` DOES re-fire — so a resumed Claude is a hook/composer
+ * race, whichever arrives first (readiness is idempotent). `armDeadline` is the ultimate
+ * fallback for both start and resume so a missing readiness signal never starves the
+ * queue forever.
+ */
+export type InitialReady = {
+    readonly cancel: () => void;
+    readonly replay: () => void;
+    readonly armDeadline: () => void;
+    /** Fire readiness now (one-shot) — the pre-input readiness hook path. */
+    readonly mark: () => void;
+    /**
+     * Re-attempt a readiness mark that a hook/deadline requested while a blocking
+     * dialog was on screen. Call per rendered frame with the frame's blocking fact:
+     * once the dialog clears, the deferred readiness fires so the queue is never
+     * drained INTO the dialog and is never permanently starved BY it (C-API-28).
+     */
+    readonly retryWhenUnblocked: (blockingVisible: boolean) => void;
+};
+/** The rendered-frame facts the resume-composer readiness path inspects. */
+export type ComposerReadyFacts = {
+    readonly composer_visible: boolean;
+    readonly blocking_prompt_visible: boolean;
+};
+/**
+ * On RESUME, mark readiness on the first genuine composer frame: the composer is
+ * visible AND no blocking dialog is on screen. The dialog's option caret (`›`/`❯`) is
+ * byte-identical to the composer marker, so a dialog frame must NOT latch readiness —
+ * otherwise a draining queued message's Enter could approve the dialog; readiness waits
+ * for the dialog to clear. Cold start (`resumed: false`) never fires here, so the
+ * composer stays an unsafe signal there (C-API-28).
+ */
+export declare function markReadyOnResumeComposer(ready: Pick<InitialReady, "mark">, resumed: boolean, facts: ComposerReadyFacts): void;
+export declare function initialReady(callback: () => void, maxWaitMs?: number, isBlocked?: () => boolean): InitialReady;
+//# sourceMappingURL=initial-ready.d.ts.map

package/dist/runtime/readiness/initial-ready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready.d.ts","sourceRoot":"","sources":["../../../src/runtime/readiness/initial-ready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,CAAC,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC;CACjE,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAC3C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,kBAAkB,GACxB,IAAI,CAEN;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,IAAI,EACpB,SAAS,SAAS,EAClB,SAAS,GAAE,MAAM,OAAqB,GACrC,YAAY,CA4Cd"}