@with-logic/elwood 0.1.0

package/dist/runtime/readiness/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/readiness/initial-ready.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-ready.js","sourceRoot":"","sources":["../../../src/runtime/readiness/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/reap-tree.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Reaps the process tree of a PTY leader on session teardown.
+ * Implements PRD §5.3 and §9.4 (C-LIFE-10): a CLI-spawned helper such as the
+ * Claude hook bridge is a descendant of the PTY leader. Because POSIX reparents
+ * a surviving descendant to PID 1 the instant its parent exits, a parent-pid
+ * walk (`pgrep -P`) cannot find it afterwards — but node-pty starts the leader
+ * as its own session/process-group leader, and group membership is inherited
+ * and survives reparenting. So we reap by SIGKILLing the leader's process group,
+ * which reaches every descendant in one in-process syscall: no subprocess, no
+ * PATH lookup, no post-exit reparenting blind spot.
+ */
+/** Injectable so tests never signal real process groups; production uses `process.kill`. */
+export type ProcessGroupKiller = {
+    /** SIGKILLs the process group `pgid` (via `kill(-pgid)`); tolerates an empty/dead group. */
+    readonly killGroup: (pgid: number) => void;
+};
+/**
+ * SIGKILLs the process group led by `leaderPid`, reaping every descendant still
+ * in the group — including one already reparented to PID 1. node-pty starts the
+ * leader via `setsid()`, so it heads its own session and its pgid equals its pid;
+ * that group is always distinct from the host's own group, so this cannot signal
+ * the host process. Refuses only pids the kernel would misroute (see
+ * `isReapableGroupId`), never an arbitrary numeric floor. An already-dead group
+ * (leader and children exited together) is the normal case and its `ESRCH` is
+ * swallowed; a real kill failure such as `EPERM` propagates.
+ */
+export declare function reapProcessGroup(leaderPid: number, ops?: ProcessGroupKiller): void;
+export declare function setGroupKillerForTests(killer: ProcessGroupKiller): void;
+export declare function resetGroupKillerForTests(): void;
+/**
+ * Swallows the ESRCH raised when the group is already empty (the normal case:
+ * the leader and its children exited together) and re-throws any other error —
+ * a real failure (e.g. EPERM) that must not be reported as a successful reap.
+ * Reads the errno through `errnoCode`, which narrows object-ness first, so a
+ * thrown `null`/non-Error is preserved and rethrown rather than triggering a
+ * secondary TypeError while inspecting it (C-ERR-01). Exported for focused
+ * coverage of both branches without an unsafe real signal.
+ */
+export declare function rethrowUnlessGroupGone(error: unknown): void;
+/**
+ * Owns a single PTY leader's group reap. A SUCCESSFUL reap MUST happen at most
+ * once: `stop()` then a later `teardown()` both want to guarantee the group is
+ * gone, but signaling the same numeric pgid twice is unsafe — once the group is
+ * empty the kernel may recycle the pid, and a second `kill(-pgid)` would hit an
+ * unrelated group. So the latch is set only AFTER the kill succeeds (an already
+ * empty group's `ESRCH` is normalized to success by `reapProcessGroup`). A real
+ * failure (e.g. EPERM) leaves the latch OPEN and rethrows, so a later teardown
+ * call can retry rather than leaving the descendant leak permanently unreaped.
+ */
+export declare class SessionReaper {
+    private readonly leaderPid;
+    private readonly ops;
+    private done;
+    constructor(leaderPid: number, ops?: ProcessGroupKiller);
+    /**
+     * Reap the group once it succeeds; a successful call latches so subsequent
+     * calls no-op (no recycled-pgid double-kill). A failed kill does NOT latch and
+     * rethrows, keeping the reap retryable on a later lifecycle call.
+     */
+    reap(): void;
+}
+//# sourceMappingURL=reap-tree.d.ts.map

package/dist/runtime/reap-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reap-tree.d.ts","sourceRoot":"","sources":["../../src/runtime/reap-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,4FAA4F;AAC5F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,4FAA4F;IAC5F,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C,CAAC;AAoBF;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAE,kBAAiC,GAAG,IAAI,CAGhG;AAiBD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAEvE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE3D;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IACzC,OAAO,CAAC,IAAI,CAAS;gBAET,SAAS,EAAE,MAAM,EAAE,GAAG,GAAE,kBAAiC;IAKrE;;;;OAIG;IACH,IAAI,IAAI,IAAI;CAKb"}

package/dist/runtime/reap-tree.js

@@ -0,0 +1,108 @@
+/**
+ * Reaps the process tree of a PTY leader on session teardown.
+ * Implements PRD §5.3 and §9.4 (C-LIFE-10): a CLI-spawned helper such as the
+ * Claude hook bridge is a descendant of the PTY leader. Because POSIX reparents
+ * a surviving descendant to PID 1 the instant its parent exits, a parent-pid
+ * walk (`pgrep -P`) cannot find it afterwards — but node-pty starts the leader
+ * as its own session/process-group leader, and group membership is inherited
+ * and survives reparenting. So we reap by SIGKILLing the leader's process group,
+ * which reaches every descendant in one in-process syscall: no subprocess, no
+ * PATH lookup, no post-exit reparenting blind spot.
+ */
+import { errnoCode } from "../core/errors.js";
+/**
+ * A pgid is reapable when it identifies the KNOWN-OWNED node-pty leader's group
+ * rather than a system group or the host itself. Ownership is NOT inferred from a
+ * numeric floor — that is an allocation detail, and after PID-space wrap or inside
+ * a constrained namespace a legitimate leader can be low (a prior arbitrary `< 100`
+ * floor silently no-op'd such leaders and leaked their descendants). We instead
+ * accept every valid child pid while refusing the two ids a group SIGKILL must
+ * never touch:
+ *   - `pgid <= 1` — pid 0 means "our own group" to `kill(2)`, and pid 1 is
+ *     `init`/`launchd`; a fake pid 1 in tests once reaped a developer's real apps.
+ *   - the host's OWN pid — node-pty gives the leader a fresh session via `setsid()`
+ *     so its pgid can never legitimately equal ours, but if a bad pgid ever did we
+ *     must not signal `-process.pid` and kill ourselves.
+ */
+function isReapableGroupId(pgid) {
+    return Number.isInteger(pgid) && pgid > 1 && pgid !== process.pid;
+}
+/**
+ * SIGKILLs the process group led by `leaderPid`, reaping every descendant still
+ * in the group — including one already reparented to PID 1. node-pty starts the
+ * leader via `setsid()`, so it heads its own session and its pgid equals its pid;
+ * that group is always distinct from the host's own group, so this cannot signal
+ * the host process. Refuses only pids the kernel would misroute (see
+ * `isReapableGroupId`), never an arbitrary numeric floor. An already-dead group
+ * (leader and children exited together) is the normal case and its `ESRCH` is
+ * swallowed; a real kill failure such as `EPERM` propagates.
+ */
+export function reapProcessGroup(leaderPid, ops = activeKiller) {
+    if (!isReapableGroupId(leaderPid))
+        return;
+    ops.killGroup(leaderPid);
+}
+const defaultKiller = {
+    killGroup(pgid) {
+        try {
+            process.kill(-pgid, "SIGKILL");
+        }
+        catch (error) {
+            rethrowUnlessGroupGone(error);
+        }
+    },
+};
+// The killer used when a caller does not inject one. A test seam so session
+// lifecycle tests can observe (and neutralize) the group SIGKILL without a real
+// signal, and without every session/terminate call site taking a killer param.
+let activeKiller = defaultKiller;
+export function setGroupKillerForTests(killer) {
+    activeKiller = killer;
+}
+export function resetGroupKillerForTests() {
+    activeKiller = defaultKiller;
+}
+/**
+ * Swallows the ESRCH raised when the group is already empty (the normal case:
+ * the leader and its children exited together) and re-throws any other error —
+ * a real failure (e.g. EPERM) that must not be reported as a successful reap.
+ * Reads the errno through `errnoCode`, which narrows object-ness first, so a
+ * thrown `null`/non-Error is preserved and rethrown rather than triggering a
+ * secondary TypeError while inspecting it (C-ERR-01). Exported for focused
+ * coverage of both branches without an unsafe real signal.
+ */
+export function rethrowUnlessGroupGone(error) {
+    if (errnoCode(error) !== "ESRCH")
+        throw error;
+}
+/**
+ * Owns a single PTY leader's group reap. A SUCCESSFUL reap MUST happen at most
+ * once: `stop()` then a later `teardown()` both want to guarantee the group is
+ * gone, but signaling the same numeric pgid twice is unsafe — once the group is
+ * empty the kernel may recycle the pid, and a second `kill(-pgid)` would hit an
+ * unrelated group. So the latch is set only AFTER the kill succeeds (an already
+ * empty group's `ESRCH` is normalized to success by `reapProcessGroup`). A real
+ * failure (e.g. EPERM) leaves the latch OPEN and rethrows, so a later teardown
+ * call can retry rather than leaving the descendant leak permanently unreaped.
+ */
+export class SessionReaper {
+    leaderPid;
+    ops;
+    done = false;
+    constructor(leaderPid, ops = activeKiller) {
+        this.leaderPid = leaderPid;
+        this.ops = ops;
+    }
+    /**
+     * Reap the group once it succeeds; a successful call latches so subsequent
+     * calls no-op (no recycled-pgid double-kill). A failed kill does NOT latch and
+     * rethrows, keeping the reap retryable on a later lifecycle call.
+     */
+    reap() {
+        if (this.done)
+            return;
+        reapProcessGroup(this.leaderPid, this.ops);
+        this.done = true;
+    }
+}
+//# sourceMappingURL=reap-tree.js.map

package/dist/runtime/reap-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reap-tree.js","sourceRoot":"","sources":["../../src/runtime/reap-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAQ9C;;;;;;;;;;;;;GAaG;AACH,SAAS,iBAAiB,CAAC,IAAY;IACrC,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,KAAK,OAAO,CAAC,GAAG,CAAC;AACpE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAiB,EAAE,MAA0B,YAAY;IACxF,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC;QAAE,OAAO;IAC1C,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AAC3B,CAAC;AAED,MAAM,aAAa,GAAuB;IACxC,SAAS,CAAC,IAAY;QACpB,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sBAAsB,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;CACF,CAAC;AAEF,4EAA4E;AAC5E,gFAAgF;AAChF,+EAA+E;AAC/E,IAAI,YAAY,GAAuB,aAAa,CAAC;AAErD,MAAM,UAAU,sBAAsB,CAAC,MAA0B;IAC/D,YAAY,GAAG,MAAM,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,wBAAwB;IACtC,YAAY,GAAG,aAAa,CAAC;AAC/B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,OAAO;QAAE,MAAM,KAAK,CAAC;AAChD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,aAAa;IACP,SAAS,CAAS;IAClB,GAAG,CAAqB;IACjC,IAAI,GAAG,KAAK,CAAC;IAErB,YAAY,SAAiB,EAAE,MAA0B,YAAY;QACnE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,IAAI,IAAI,CAAC,IAAI;YAAE,OAAO;QACtB,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF"}

package/dist/runtime/seams.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Test seams for process, platform, and PTY dependencies.
+ * Implements PRD §13 testability without changing public behavior.
+ */
+import type { PtyFactory } from "../pty/types.ts";
+export type CommandResult = {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly error?: {
+        readonly code?: string | undefined;
+        readonly message: string;
+    };
+};
+/**
+ * Runs a subprocess and returns its result. Production is async (`spawn`) so a
+ * roster of concurrent spawns never serializes on the host event loop; test
+ * fakes may stay synchronous — callers always `await` the result.
+ */
+export type CommandRunner = (command: string, args: readonly string[]) => CommandResult | Promise<CommandResult>;
+export declare function currentPtyFactory(): PtyFactory;
+export declare function currentCommandRunner(): CommandRunner;
+export declare function currentPlatform(): string;
+export declare function setPtyFactoryForTests(factory: PtyFactory): void;
+export declare function setCommandRunnerForTests(runner: CommandRunner): void;
+export declare function setPlatformForTests(value: string): void;
+export declare function resetRuntimeSeamsForTests(): void;
+//# sourceMappingURL=seams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seams.d.ts","sourceRoot":"","sources":["../../src/runtime/seams.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACnF,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,KACpB,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAM5C,wBAAgB,iBAAiB,IAAI,UAAU,CAE9C;AAED,wBAAgB,oBAAoB,IAAI,aAAa,CAEpD;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAE/D;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAEpE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEvD;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAKhD"}

package/dist/runtime/seams.js

@@ -0,0 +1,34 @@
+/**
+ * Test seams for process, platform, and PTY dependencies.
+ * Implements PRD §13 testability without changing public behavior.
+ */
+import { nodePtyFactory } from "../pty/node.js";
+import { resetProbeTimeoutForTests, runProbe } from "./probe.js";
+let ptyFactory = null;
+let commandRunner = runProbe;
+let platform = process.platform;
+export function currentPtyFactory() {
+    return ptyFactory ?? nodePtyFactory;
+}
+export function currentCommandRunner() {
+    return commandRunner;
+}
+export function currentPlatform() {
+    return platform;
+}
+export function setPtyFactoryForTests(factory) {
+    ptyFactory = factory;
+}
+export function setCommandRunnerForTests(runner) {
+    commandRunner = runner;
+}
+export function setPlatformForTests(value) {
+    platform = value;
+}
+export function resetRuntimeSeamsForTests() {
+    ptyFactory = null;
+    commandRunner = runProbe;
+    platform = process.platform;
+    resetProbeTimeoutForTests();
+}
+//# sourceMappingURL=seams.js.map

package/dist/runtime/seams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seams.js","sourceRoot":"","sources":["../../src/runtime/seams.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAmBjE,IAAI,UAAU,GAAsB,IAAI,CAAC;AACzC,IAAI,aAAa,GAAkB,QAAQ,CAAC;AAC5C,IAAI,QAAQ,GAAW,OAAO,CAAC,QAAQ,CAAC;AAExC,MAAM,UAAU,iBAAiB;IAC/B,OAAO,UAAU,IAAI,cAAc,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,OAAmB;IACvD,UAAU,GAAG,OAAO,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,MAAqB;IAC5D,aAAa,GAAG,MAAM,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,QAAQ,GAAG,KAAK,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,yBAAyB;IACvC,UAAU,GAAG,IAAI,CAAC;IAClB,aAAa,GAAG,QAAQ,CAAC;IACzB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAC5B,yBAAyB,EAAE,CAAC;AAC9B,CAAC"}

package/dist/runtime/session/base.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The caller-facing control surface shared by both adapter sessions — prompt,
+ * message, and guidance submission (with image attachment), raw keys, resize,
+ * interrupt/compact, the model picker, and recurring loops — layered over the
+ * lifecycle core in `lifecycle.ts`. Implements PRD §5.3, §5.7, §5.9.
+ */
+import type { ElwoodAgentKind } from "../../core/activity/index.ts";
+import type { SendOptions } from "../../core/images/types.ts";
+import type { ElwoodLoopRequest, ElwoodLoopSnapshot } from "../../core/loops/types.ts";
+import type { ModelPickerSpec } from "../../core/models/picker.ts";
+import type { AgentModelOption } from "../../core/models/rows.ts";
+import type { TerminalReplayBuffer } from "../../core/terminal-replay.ts";
+import type { TerminalSize } from "../../core/types.ts";
+import type { PtyProcess } from "../../pty/types.ts";
+import type { PersistedLoopDefinition } from "../../state/loop-store.ts";
+import type { SessionRuntime } from "../../state/runtime-paths.ts";
+import type { SessionRecord } from "../../state/store.ts";
+import type { ElwoodTerminal } from "../../terminal/headless.ts";
+import { SessionLifecycle } from "./lifecycle.ts";
+import type { SessionStatusEmitter } from "./status-wiring.ts";
+type Timeout = {
+    readonly timeoutMs?: number;
+};
+export declare abstract class AgentSessionBase extends SessionLifecycle {
+    protected abstract readonly picker: ModelPickerSpec;
+    private readonly commands;
+    private readonly imageBudget;
+    protected constructor(agent: ElwoodAgentKind, record: SessionRecord, stateDir: string, runtime: SessionRuntime, pty: PtyProcess, terminal: ElwoodTerminal, statusEvents: SessionStatusEmitter, terminalReplay: TerminalReplayBuffer, loopDefinitions: readonly PersistedLoopDefinition[]);
+    sendPrompt(prompt: string, options?: SendOptions): Promise<void>;
+    sendMessage(message: string, options?: SendOptions): Promise<void>;
+    sendGuidance(message: string, options?: SendOptions): Promise<void>;
+    sendKeys(input: string | Uint8Array): Promise<void>;
+    resize(size: TerminalSize): Promise<void>;
+    interrupt(options?: Timeout): Promise<void>;
+    compact(options?: Timeout): Promise<void>;
+    listModels(options?: Timeout): Promise<readonly AgentModelOption[]>;
+    setModel(id: string, options?: Timeout): Promise<void>;
+    createLoop(request: ElwoodLoopRequest): Promise<ElwoodLoopSnapshot>;
+    listLoops(): Promise<readonly ElwoodLoopSnapshot[]>;
+    cancelLoop(loopId: string): Promise<void>;
+    /** Attach `paths` to the composer before the queued text is submitted (C-API-44). */
+    protected abstract attachImages(paths: readonly string[], signal: AbortSignal): Promise<void>;
+    /** Re-apply a resize that was held during startup (a best-effort restore). */
+    protected restoreHeldSize(size: TerminalSize): void;
+    private enqueue;
+}
+export {};
+//# sourceMappingURL=base.d.ts.map

package/dist/runtime/session/base.d.ts.map

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

package/dist/runtime/session/base.js

@@ -0,0 +1,76 @@
+/**
+ * The caller-facing control surface shared by both adapter sessions — prompt,
+ * message, and guidance submission (with image attachment), raw keys, resize,
+ * interrupt/compact, the model picker, and recurring loops — layered over the
+ * lifecycle core in `lifecycle.ts`. Implements PRD §5.3, §5.7, §5.9.
+ */
+import { CommandSurface } from "./commands.js";
+import { enqueueSubmission, QueuedImageBudget, } from "./image-attach.js";
+import { SessionLifecycle } from "./lifecycle.js";
+import { applyResize, restoreHeldResize } from "./resize.js";
+export class AgentSessionBase extends SessionLifecycle {
+    commands;
+    imageBudget = new QueuedImageBudget();
+    constructor(agent, record, stateDir, runtime, pty, terminal, statusEvents, terminalReplay, loopDefinitions) {
+        super(agent, record, stateDir, runtime, pty, terminal, statusEvents, terminalReplay, loopDefinitions);
+        // `picker` is a subclass field initializer that runs AFTER this constructor, so the
+        // surface resolves it per call rather than capturing it here.
+        this.commands = new CommandSurface({
+            terminal,
+            statusEvents,
+            status: () => this.status,
+            everReady: () => this.everReady,
+            picker: () => this.picker,
+            submit: (command, kind) => this.controlQueue.send(command, kind),
+        });
+    }
+    sendPrompt(prompt, options) {
+        return this.enqueue(prompt, "prompt", options);
+    }
+    sendMessage(message, options) {
+        return this.enqueue(message, "message", options);
+    }
+    sendGuidance(message, options) {
+        return this.enqueue(message, "guidance", options);
+    }
+    sendKeys(input) {
+        return this.inSession(async () => {
+            await this.terminal.sendInput(input);
+            this.loops.callerActivity();
+        });
+    }
+    resize(size) {
+        return this.inSession(() => applyResize(this.pty, this.terminal, size));
+    }
+    interrupt(options) {
+        return this.inSession(() => this.commands.interrupt(options));
+    }
+    compact(options) {
+        return this.inSession(() => this.commands.compact(options));
+    }
+    listModels(options) {
+        return this.inSession(() => this.commands.listModels(options));
+    }
+    setModel(id, options) {
+        return this.inSession(() => this.commands.setModel(id, options));
+    }
+    createLoop(request) {
+        return this.inSession(() => this.loops.create(request));
+    }
+    listLoops() {
+        return this.inSession(() => this.loops.list(), true);
+    }
+    cancelLoop(loopId) {
+        return this.inSession(() => this.loops.cancel(loopId), true);
+    }
+    /** Re-apply a resize that was held during startup (a best-effort restore). */
+    restoreHeldSize(size) {
+        void restoreHeldResize(this.pty, this.terminal, size);
+    }
+    enqueue(input, kind, options) {
+        const driver = (paths, signal) => this.attachImages(paths, signal);
+        const send = (attach) => this.controlQueue.send(input, kind, attach);
+        return this.inSession(() => enqueueSubmission(options?.images, driver, send, this.imageBudget));
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/runtime/session/base.js.map

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

package/dist/runtime/session/commands.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The session's control surface, shared by every adapter session and extracted
+ * from AgentSessionBase to keep it within the file-size cap. It owns `interrupt`
+ * (direct Escape delivery gated on readiness state, with a timeout and
+ * coalescing of concurrent interrupts, bypassing command submission) alongside
+ * the `compact` and `/model` picker commands (which do go through submission).
+ * Implements PRD §5.3.
+ */
+import { type ModelPickerSpec } from "../../core/models/picker.ts";
+import type { AgentModelOption } from "../../core/models/rows.ts";
+import type { ScreenTerminal } from "../../core/models/tui-screen.ts";
+import type { ElwoodSessionStatus } from "../../core/types.ts";
+import type { SessionStatusEmitter } from "./status-wiring.ts";
+type Timeout = {
+    readonly timeoutMs?: number;
+};
+/**
+ * The session primitives the control surface drives (interrupt readiness/status,
+ * compact submission, and the model picker). The picker is a thunk because the
+ * concrete adapter sets `picker` in a subclass field initializer that runs AFTER
+ * the base constructor, so it is resolved per call.
+ */
+export type CommandSurfaceDeps = {
+    readonly terminal: ScreenTerminal;
+    readonly statusEvents: SessionStatusEmitter;
+    readonly status: () => ElwoodSessionStatus;
+    readonly everReady: () => boolean;
+    readonly picker: () => ModelPickerSpec;
+    readonly submit: (command: string, kind: "compact" | "list_models" | "set_model") => Promise<void>;
+};
+/** Builds each command's interrupt/compact/picker closures from the injected primitives. */
+export declare class CommandSurface {
+    private readonly deps;
+    private interrupting;
+    constructor(deps: CommandSurfaceDeps);
+    interrupt(options?: Timeout): Promise<void>;
+    compact(options?: Timeout): Promise<void>;
+    listModels(options?: Timeout): Promise<readonly AgentModelOption[]>;
+    setModel(id: string, options?: Timeout): Promise<void>;
+    private io;
+}
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/runtime/session/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../src/runtime/session/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAGL,KAAK,eAAe,EAGrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,KAAK,OAAO,GAAG;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,eAAe,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,CACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,KAC1C,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,CAAC;AAEF,4FAA4F;AAC5F,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAI1C,OAAO,CAAC,YAAY,CAA4B;gBAEpC,IAAI,EAAE,kBAAkB;IAIpC,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB3C,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAQzC,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC;IAInE,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAItD,OAAO,CAAC,EAAE;CAGX"}

package/dist/runtime/session/commands.js

@@ -0,0 +1,52 @@
+/**
+ * The session's control surface, shared by every adapter session and extracted
+ * from AgentSessionBase to keep it within the file-size cap. It owns `interrupt`
+ * (direct Escape delivery gated on readiness state, with a timeout and
+ * coalescing of concurrent interrupts, bypassing command submission) alongside
+ * the `compact` and `/model` picker commands (which do go through submission).
+ * Implements PRD §5.3.
+ */
+import { compactCommand, sessionCompact } from "../../core/compact.js";
+import { ignoreInputFailure } from "../../core/input/index.js";
+import { interruptKey, sessionInterrupt } from "../../core/interrupt.js";
+import { listPickerModels, pickerTimeout, setPickerModel, } from "../../core/models/picker.js";
+/** Builds each command's interrupt/compact/picker closures from the injected primitives. */
+export class CommandSurface {
+    deps;
+    // Coalesces concurrent interrupts: a second call while one is in flight joins
+    // the first rather than writing a second Escape, which could land on the now
+    // idle composer after the first cancels the turn (a non-neutral keystroke).
+    interrupting;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    interrupt(options) {
+        if (this.interrupting)
+            return this.interrupting;
+        const sendEscape = () => Promise.resolve(this.deps.terminal.sendInput(interruptKey));
+        const { statusEvents, status, everReady } = this.deps;
+        const running = sessionInterrupt(statusEvents, status, everReady, sendEscape, options?.timeoutMs);
+        // Clear the in-flight guard on settle so a later interrupt can run afresh.
+        this.interrupting = running.finally(() => {
+            this.interrupting = undefined;
+        });
+        return this.interrupting;
+    }
+    compact(options) {
+        const submit = () => this.deps.submit(compactCommand, "compact");
+        const nudge = () => {
+            ignoreInputFailure(this.deps.terminal.sendInput("\r"));
+        };
+        return sessionCompact(this.deps.statusEvents, submit, nudge, options?.timeoutMs);
+    }
+    listModels(options) {
+        return listPickerModels(this.io("list_models"), this.deps.picker(), pickerTimeout(options));
+    }
+    setModel(id, options) {
+        return setPickerModel(this.io("set_model"), this.deps.picker(), id, pickerTimeout(options));
+    }
+    io(kind) {
+        return { terminal: this.deps.terminal, submit: (c) => this.deps.submit(c, kind) };
+    }
+}
+//# sourceMappingURL=commands.js.map

package/dist/runtime/session/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sourceRoot":"","sources":["../../../src/runtime/session/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EACL,gBAAgB,EAGhB,aAAa,EACb,cAAc,GACf,MAAM,6BAA6B,CAAC;AA0BrC,4FAA4F;AAC5F,MAAM,OAAO,cAAc;IACR,IAAI,CAAqB;IAC1C,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IACpE,YAAY,CAA4B;IAEhD,YAAY,IAAwB;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,SAAS,CAAC,OAAiB;QACzB,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC;QAChD,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC;QACrF,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;QACtD,MAAM,OAAO,GAAG,gBAAgB,CAC9B,YAAY,EACZ,MAAM,EACN,SAAS,EACT,UAAU,EACV,OAAO,EAAE,SAAS,CACnB,CAAC;QACF,2EAA2E;QAC3E,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE;YACvC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAChC,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,OAAO,CAAC,OAAiB;QACvB,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;QACjE,MAAM,KAAK,GAAG,GAAG,EAAE;YACjB,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QACzD,CAAC,CAAC;QACF,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IACnF,CAAC;IAED,UAAU,CAAC,OAAiB;QAC1B,OAAO,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED,QAAQ,CAAC,EAAU,EAAE,OAAiB;QACpC,OAAO,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9F,CAAC;IAEO,EAAE,CAAC,IAAiC;QAC1C,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;IACpF,CAAC;CACF"}

package/dist/runtime/session/exit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adapter-neutral PTY-exit orchestration (PRD §5.3, C-LIFE-10). Both the Claude
+ * and Codex exit boundaries drain the transcript, emit `terminal:exit` + activity,
+ * and submit terminal status (which reaps the descendant tree in its own `finally`)
+ * in the same order behind the same error boundary. This is that one shared shape.
+ */
+/**
+ * Run the exit-boundary `flushAndEmit` (transcript drain + `terminal:exit`/activity
+ * emission) behind an error boundary, then ALWAYS run `submitExit` in a `finally`.
+ * `submitExit` submits terminal status and reaps in its OWN `finally`, so a throwing
+ * transcript flush, `terminal:exit` listener, or activity listener can never skip
+ * the terminal status or the unconditional reap, and no listener failure escapes
+ * the native PTY-exit callback (which would leave the reap unrun).
+ */
+export declare function finishSessionExit(flushAndEmit: () => void, submitExit: () => void): void;
+//# sourceMappingURL=exit.d.ts.map

package/dist/runtime/session/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../../src/runtime/session/exit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,MAAM,IAAI,GAAG,IAAI,CAaxF"}

package/dist/runtime/session/exit.js

@@ -0,0 +1,32 @@
+/**
+ * Adapter-neutral PTY-exit orchestration (PRD §5.3, C-LIFE-10). Both the Claude
+ * and Codex exit boundaries drain the transcript, emit `terminal:exit` + activity,
+ * and submit terminal status (which reaps the descendant tree in its own `finally`)
+ * in the same order behind the same error boundary. This is that one shared shape.
+ */
+/**
+ * Run the exit-boundary `flushAndEmit` (transcript drain + `terminal:exit`/activity
+ * emission) behind an error boundary, then ALWAYS run `submitExit` in a `finally`.
+ * `submitExit` submits terminal status and reaps in its OWN `finally`, so a throwing
+ * transcript flush, `terminal:exit` listener, or activity listener can never skip
+ * the terminal status or the unconditional reap, and no listener failure escapes
+ * the native PTY-exit callback (which would leave the reap unrun).
+ */
+export function finishSessionExit(flushAndEmit, submitExit) {
+    try {
+        flushAndEmit();
+    }
+    catch {
+        // A throwing flush/emit listener must not skip terminal status + reap.
+    }
+    finally {
+        try {
+            submitExit();
+        }
+        catch {
+            // Status was submitted and the reap ran inside submitExit's own finally;
+            // contain any late status-listener throw so it can't abort the callback.
+        }
+    }
+}
+//# sourceMappingURL=exit.js.map