@with-logic/elwood 0.1.0

package/dist/core/simple/session.js

@@ -0,0 +1,155 @@
+/**
+ * Adapter-neutral lazy facade for ergonomic turns and the low-level control surface.
+ * Implements PRD §5.8.
+ */
+import { elwoodError, toError } from "../errors.js";
+import { SubscriptionRegistry } from "./subscriptions.js";
+import { runTurn } from "./turn.js";
+import { TurnQueue } from "./turn-queue.js";
+/** Lazy public session over one Elwood agent; only ergonomic turns serialize. */
+export class SessionBase {
+    live;
+    starting;
+    turns = new TurnQueue();
+    subscriptions = new SubscriptionRegistry();
+    /** The started underlying session, or `undefined` before the first start. */
+    get session() {
+        return this.live;
+    }
+    /** The current status; `starting` until the underlying session exists. */
+    get status() {
+        return this.live?.status ?? "starting";
+    }
+    /** Start the underlying session eagerly. Idempotent and concurrent-safe (C-API-47). */
+    start() {
+        if (this.live)
+            return Promise.resolve(this.live);
+        this.starting ??= this.launch().then((session) => {
+            // COMMIT the launched session BEFORE attaching buffered subscriptions: `attach` runs
+            // consumer code (and `terminal:data` synchronously replays startup output), which may
+            // throw. If it did so before `live` were set, the start would reject with a live PTY
+            // that `close()` could never see — an orphaned CLI process. `attachAll` contains each
+            // attach so a throwing consumer handler cannot abort the start or orphan the session.
+            this.live = session;
+            this.starting = undefined;
+            this.subscriptions.attachAll(session);
+            return session;
+        }, (error) => {
+            this.starting = undefined; // a failed start is RETRYABLE — clear so a later call re-launches
+            throw error;
+        });
+        return this.starting;
+    }
+    /** Stream one turn's simplified content events; ends when the turn settles (C-API-48). */
+    stream(prompt, options) {
+        // Trigger the lazy start SYNCHRONOUSLY (memoized) so a `close()` racing this call joins the
+        // same start and can't miss a session a deferred microtask would launch after close (C-API-51).
+        // The slot is reserved synchronously too (call order, not iteration order — C-API-50).
+        const starting = this.start();
+        // Pass THIS adapter's normalizer so the runner reads only the signal, not raw hook fields.
+        const readBoundarySignal = this.readBoundarySignal;
+        return this.turns.enqueue(() => starting.then((s) => runTurn(s, prompt, { ...(options ?? {}), readBoundarySignal })));
+    }
+    /** Send one turn and resolve with its assistant text, `\n\n`-joined (C-API-49). */
+    async send(prompt, options) {
+        const chunks = [];
+        for await (const event of this.stream(prompt, options)) {
+            if (event.type === "text")
+                chunks.push(event.text);
+        }
+        return chunks.join("\n\n");
+    }
+    /** Subscribe via a typed `attach` closure (no cast). See {@link SubscriptionRegistry.add}. */
+    subscribe(event, handler, attach) {
+        return this.subscriptions.add(event, handler, attach);
+    }
+    /** Remove the registration matching BOTH event and handler (so a reused handler is scoped right). */
+    unsubscribe(event, handler) {
+        this.subscriptions.removeByKey(event, handler);
+    }
+    // Control surface: each awaits lazy start, then delegates; only `send`/`stream` serialize. NOTE:
+    // the turn-PRODUCING raw methods (`sendMessage`/`sendPrompt`/`sendGuidance`) are NOT in the
+    // ergonomic queue — don't call them concurrently with an in-flight `send`/`stream` (§5.8).
+    async sendPrompt(prompt, options) {
+        return (await this.start()).sendPrompt(prompt, options);
+    }
+    async sendMessage(message, options) {
+        return (await this.start()).sendMessage(message, options);
+    }
+    async sendGuidance(message, options) {
+        return (await this.start()).sendGuidance(message, options);
+    }
+    async sendKeys(input) {
+        return (await this.start()).sendKeys(input);
+    }
+    async resize(size) {
+        return (await this.start()).resize(size);
+    }
+    async interrupt(options) {
+        return (await this.start()).interrupt(options);
+    }
+    async compact(options) {
+        return (await this.start()).compact(options);
+    }
+    async listModels(o) {
+        return (await this.start()).listModels(o);
+    }
+    async setModel(id, options) {
+        return (await this.start()).setModel(id, options);
+    }
+    async waitForStatus(match, timeoutMs) {
+        return (await this.start()).waitForStatus(match, timeoutMs);
+    }
+    async waitForActivity(match, timeoutMs) {
+        return (await this.start()).waitForActivity(match, timeoutMs);
+    }
+    async createLoop(request) {
+        return (await this.start()).createLoop(request);
+    }
+    async listLoops() {
+        return (await this.start()).listLoops();
+    }
+    async cancelLoop(loopId) {
+        return (await this.start()).cancelLoop(loopId);
+    }
+    /** Stop the underlying session, joining an in-flight lazy start (C-API-51). */
+    async close() {
+        const live = await this.settledSession();
+        if (!live)
+            return;
+        await this.closeLiveSession(live);
+    }
+    /** Stop one known-live session, preserving the public close fallback and diagnostics. */
+    async closeLiveSession(live) {
+        try {
+            await live.stop();
+        }
+        catch (stopError) {
+            try {
+                await live.kill();
+            }
+            catch (killError) {
+                // Both shutdown paths failed: surface the ORIGINAL stop failure with the kill
+                // failure attached, so a repeated cleanup/reap problem stays diagnosable.
+                throw elwoodError("termination_failed", "close() failed to stop or kill the session", {
+                    cause: toError(stopError).message,
+                    killCause: toError(killError).message,
+                });
+            }
+        }
+    }
+    // stop/kill/teardown: delegate to the live session; a no-op if it never started (C-API-52).
+    async stop() {
+        await this.live?.stop();
+    }
+    async kill() {
+        await this.live?.kill();
+    }
+    async teardown() {
+        await this.live?.teardown();
+    }
+    async settledSession() {
+        return this.live ?? (this.starting ? await this.starting.catch(() => undefined) : undefined);
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/core/simple/session.js.map

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

package/dist/core/simple/subscriptions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Buffered event subscriptions for the ergonomic session (PRD §5.8). `on` may be called before
+ * the underlying session starts; registrations are buffered here and attached on start, so
+ * subscribing never forces a start. Extracted from session.ts to keep both under the size cap.
+ */
+import type { Unsubscribe } from "../types.ts";
+/** The buffered-then-live subscription registry backing a session's `on`/`off`. */
+export declare class SubscriptionRegistry<S> {
+    private readonly registrations;
+    private live;
+    /**
+     * Add a subscription. Before start it is buffered and attached later; after start it is
+     * attached now. Returns an `Unsubscribe` that works in BOTH phases: it removes the pending
+     * registration before start, or invokes the stored live detach after — so a disposer captured
+     * before start still detaches the handler once the session launches.
+     */
+    add(event: unknown, handler: unknown, attach: (session: S) => Unsubscribe): Unsubscribe;
+    /** Remove the registration matching BOTH event and handler (so a reused handler is scoped right). */
+    removeByKey(event: unknown, handler: unknown): void;
+    /**
+     * Bind to the started session and attach every buffered registration, storing each live detach.
+     * Reentrancy-safe: `attach` can synchronously replay consumer code that itself `add`s or
+     * disposes a subscription, so we iterate a SNAPSHOT (a reentrant `add` attaches itself once, via
+     * the `this.live` path in `add`, and is not re-attached by this loop) and store the live detach
+     * only if the registration still exists — otherwise a self-dispose during replay would leak the
+     * listener, so we invoke the detach immediately. Each attach is CONTAINED: a throwing consumer
+     * handler must not abort the caller (the session is already live and owned) nor block later ones.
+     */
+    attachAll(session: S): void;
+    private remove;
+}
+//# sourceMappingURL=subscriptions.d.ts.map

package/dist/core/simple/subscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../../src/core/simple/subscriptions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAgB/C,mFAAmF;AACnF,qBAAa,oBAAoB,CAAC,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;IACvD,OAAO,CAAC,IAAI,CAAgB;IAE5B;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,WAAW,GAAG,WAAW;IAOvF,qGAAqG;IACrG,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAKnD;;;;;;;;OAQG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAgB3B,OAAO,CAAC,MAAM;CAMf"}

package/dist/core/simple/subscriptions.js

@@ -0,0 +1,63 @@
+/**
+ * Buffered event subscriptions for the ergonomic session (PRD §5.8). `on` may be called before
+ * the underlying session starts; registrations are buffered here and attached on start, so
+ * subscribing never forces a start. Extracted from session.ts to keep both under the size cap.
+ */
+/** The buffered-then-live subscription registry backing a session's `on`/`off`. */
+export class SubscriptionRegistry {
+    registrations = [];
+    live;
+    /**
+     * Add a subscription. Before start it is buffered and attached later; after start it is
+     * attached now. Returns an `Unsubscribe` that works in BOTH phases: it removes the pending
+     * registration before start, or invokes the stored live detach after — so a disposer captured
+     * before start still detaches the handler once the session launches.
+     */
+    add(event, handler, attach) {
+        const reg = { event, handler, attach, live: undefined };
+        if (this.live)
+            reg.live = attach(this.live);
+        this.registrations.push(reg);
+        return () => this.remove(reg);
+    }
+    /** Remove the registration matching BOTH event and handler (so a reused handler is scoped right). */
+    removeByKey(event, handler) {
+        const reg = this.registrations.find((r) => r.event === event && r.handler === handler);
+        if (reg)
+            this.remove(reg);
+    }
+    /**
+     * Bind to the started session and attach every buffered registration, storing each live detach.
+     * Reentrancy-safe: `attach` can synchronously replay consumer code that itself `add`s or
+     * disposes a subscription, so we iterate a SNAPSHOT (a reentrant `add` attaches itself once, via
+     * the `this.live` path in `add`, and is not re-attached by this loop) and store the live detach
+     * only if the registration still exists — otherwise a self-dispose during replay would leak the
+     * listener, so we invoke the detach immediately. Each attach is CONTAINED: a throwing consumer
+     * handler must not abort the caller (the session is already live and owned) nor block later ones.
+     */
+    attachAll(session) {
+        this.live = session;
+        for (const reg of [...this.registrations]) {
+            let live;
+            try {
+                live = reg.attach(session);
+            }
+            catch {
+                // Swallow a consumer attach/replay throw so it neither orphans the session nor fails start.
+                continue;
+            }
+            if (this.registrations.includes(reg))
+                reg.live = live; // still registered — keep its live detach
+            else
+                live(); // disposed reentrantly during replay — detach now so the listener never leaks
+        }
+    }
+    remove(reg) {
+        const index = this.registrations.indexOf(reg);
+        if (index < 0)
+            return; // already removed
+        this.registrations.splice(index, 1);
+        reg.live?.(); // detach from the live session if it was attached
+    }
+}
+//# sourceMappingURL=subscriptions.js.map

package/dist/core/simple/subscriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.js","sourceRoot":"","sources":["../../../src/core/simple/subscriptions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkBH,mFAAmF;AACnF,MAAM,OAAO,oBAAoB;IACd,aAAa,GAAsB,EAAE,CAAC;IAC/C,IAAI,CAAgB;IAE5B;;;;;OAKG;IACH,GAAG,CAAC,KAAc,EAAE,OAAgB,EAAE,MAAmC;QACvE,MAAM,GAAG,GAAoB,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QACzE,IAAI,IAAI,CAAC,IAAI;YAAE,GAAG,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,qGAAqG;IACrG,WAAW,CAAC,KAAc,EAAE,OAAgB;QAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,IAAI,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;QACvF,IAAI,GAAG;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,OAAU;QAClB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;QACpB,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1C,IAAI,IAA6B,CAAC;YAClC,IAAI,CAAC;gBACH,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC7B,CAAC;YAAC,MAAM,CAAC;gBACP,4FAA4F;gBAC5F,SAAS;YACX,CAAC;YACD,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAClC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,0CAA0C;;gBACxD,IAAI,EAAE,CAAC,CAAC,8EAA8E;QAC7F,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,GAAoB;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9C,IAAI,KAAK,GAAG,CAAC;YAAE,OAAO,CAAC,kBAAkB;QACzC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACpC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,kDAAkD;IAClE,CAAC;CACF"}

package/dist/core/simple/turn-acceptance.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Recovers an ergonomic turn whose deadline-released paste was swallowed by a
+ * cold-start composer placeholder. Implements PRD §5.3/§5.8 and C-API-48.
+ */
+export type TurnAcceptanceIo = {
+    readonly replay: () => Promise<void>;
+    readonly acceptReady: () => void;
+    readonly fail: (error: unknown) => void;
+};
+export declare class TurnAcceptance {
+    private readonly quietMs;
+    private readonly io;
+    private accepted;
+    private pendingReady;
+    private replayAttempts;
+    private timer;
+    constructor(quietMs: number, io: TurnAcceptanceIo);
+    accept(): void;
+    running(): void;
+    ready(): boolean;
+    dispose(): void;
+    private recover;
+    private armWatchdog;
+    private ensureWatchdog;
+    private cancelTimer;
+}
+//# sourceMappingURL=turn-acceptance.d.ts.map

package/dist/core/simple/turn-acceptance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-acceptance.d.ts","sourceRoot":"","sources":["../../../src/core/simple/turn-acceptance.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC,CAAC;AAEF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmB;IACtC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,KAAK,CAA4C;gBAE7C,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,gBAAgB;IAKjD,MAAM,IAAI,IAAI;IAOd,OAAO,IAAI,IAAI;IAKf,KAAK,IAAI,OAAO;IAOhB,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,OAAO;IAiBf,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;CAIpB"}

package/dist/core/simple/turn-acceptance.js

@@ -0,0 +1,71 @@
+/**
+ * Recovers an ergonomic turn whose deadline-released paste was swallowed by a
+ * cold-start composer placeholder. Implements PRD §5.3/§5.8 and C-API-48.
+ */
+import { elwoodError } from "../errors.js";
+const maxReplayAttempts = 2;
+export class TurnAcceptance {
+    quietMs;
+    io;
+    accepted = false;
+    pendingReady = false;
+    replayAttempts = 0;
+    timer;
+    constructor(quietMs, io) {
+        this.quietMs = quietMs;
+        this.io = io;
+    }
+    accept() {
+        if (this.accepted)
+            return;
+        this.accepted = true;
+        this.cancelTimer();
+        if (this.pendingReady)
+            this.io.acceptReady();
+    }
+    running() {
+        this.pendingReady = false;
+        if (this.timer)
+            this.armWatchdog();
+    }
+    ready() {
+        if (this.accepted)
+            return true;
+        this.pendingReady = true;
+        this.armWatchdog();
+        return false;
+    }
+    dispose() {
+        this.accepted = true;
+        this.cancelTimer();
+    }
+    recover() {
+        this.timer = undefined;
+        if (this.replayAttempts >= maxReplayAttempts) {
+            this.io.fail(elwoodError("wait_timeout", "turn submission was not accepted"));
+            return;
+        }
+        this.pendingReady = false;
+        this.replayAttempts += 1;
+        void this.io.replay().then(() => this.ensureWatchdog(), (error) => {
+            this.cancelTimer();
+            this.io.fail(error);
+        });
+    }
+    armWatchdog() {
+        this.cancelTimer();
+        this.timer = setTimeout(() => this.recover(), this.quietMs);
+        this.timer.unref?.();
+    }
+    ensureWatchdog() {
+        if (this.accepted || this.timer)
+            return;
+        this.armWatchdog();
+    }
+    cancelTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+}
+//# sourceMappingURL=turn-acceptance.js.map

package/dist/core/simple/turn-acceptance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-acceptance.js","sourceRoot":"","sources":["../../../src/core/simple/turn-acceptance.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAQ5B,MAAM,OAAO,cAAc;IACR,OAAO,CAAS;IAChB,EAAE,CAAmB;IAC9B,QAAQ,GAAG,KAAK,CAAC;IACjB,YAAY,GAAG,KAAK,CAAC;IACrB,cAAc,GAAG,CAAC,CAAC;IACnB,KAAK,CAA4C;IAEzD,YAAY,OAAe,EAAE,EAAoB;QAC/C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,YAAY;YAAE,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;IAC/C,CAAC;IAED,OAAO;QACL,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,IAAI,CAAC,KAAK;YAAE,IAAI,CAAC,WAAW,EAAE,CAAC;IACrC,CAAC;IAED,KAAK;QACH,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAEO,OAAO;QACb,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,IAAI,IAAI,CAAC,cAAc,IAAI,iBAAiB,EAAE,CAAC;YAC7C,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,kCAAkC,CAAC,CAAC,CAAC;YAC9E,OAAO;QACT,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC;QACzB,KAAK,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CACxB,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,EAC3B,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC,CACF,CAAC;IACJ,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5D,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IACvB,CAAC;IAEO,cAAc;QACpB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO;QACxC,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,KAAK;YAAE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;IACzB,CAAC;CACF"}

package/dist/core/simple/turn-boundary.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The turn's REAL agent boundary (PRD §5.8, C-API-48/50): the point past which the serializer
+ * may start the next turn. Separated from the runner (turn.ts) to keep both under the size cap.
+ *
+ * SUCCESS path: the gate's genuine end (oracle matched / quiet window — the transcript has
+ * drained) or a terminal status. NOT bare `ready`: Claude transcript activity arrives AFTER
+ * `ready`, so releasing there would let the next turn bind this turn's still-arriving (untagged)
+ * activity. FAILURE path (consumer timeout/catch-up/backlog): the agent may still be RUNNING —
+ * and a silent long-running tool is quiet, not done — so a quiet window is unsafe. The boundary
+ * then waits for a real `ready` (a busy agent is `running`, not ready) or terminal, followed by
+ * a short transcript-drain settle. A hung agent holds the slot until `close()`/`kill()` forces a
+ * terminal status — honest backpressure, never a silent early release.
+ */
+export declare class TurnBoundary {
+    /** Resolves when the next turn may safely start. The serializer holds its slot on this. */
+    readonly promise: Promise<void>;
+    private resolve;
+    private reached;
+    private consumerFailed;
+    private drainTimer;
+    private readonly onReach;
+    private readonly drainMs;
+    /** `onReach` runs once the boundary lands (e.g. to attempt listener cleanup). `drainMs` is the
+     *  post-failure `ready` drain window (default `DRAIN_MS`; overridable for tests). */
+    constructor(onReach: () => void, drainMs?: number);
+    /** Land the boundary now (idempotent): a terminal status, or the gate's genuine success end. */
+    reach(): void;
+    /** Mark that the consumer turn failed: the boundary now waits for a real `ready`/terminal, not quiet. */
+    markConsumerFailed(): void;
+    /**
+     * A `ready` after a consumer failure means the agent turn is done (a still-working tool is
+     * `running`, not ready): arm a short transcript-drain settle so trailing untagged events flush
+     * before the slot releases. Re-armed by further activity/`ready`. No-op before a failure or once
+     * the boundary is reached.
+     */
+    armDrain(): void;
+    /** True once a drain settle is pending — a trailing event should re-arm it, not ignore it. */
+    get draining(): boolean;
+    /** True once the boundary has landed (for the runner's combined cleanup gate). */
+    get isReached(): boolean;
+}
+//# sourceMappingURL=turn-boundary.d.ts.map

package/dist/core/simple/turn-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-boundary.d.ts","sourceRoot":"","sources":["../../../src/core/simple/turn-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,qBAAa,YAAY;IACvB,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,UAAU,CAA4C;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC;yFACqF;gBACzE,OAAO,EAAE,MAAM,IAAI,EAAE,OAAO,SAAW;IAQnD,gGAAgG;IAChG,KAAK,IAAI,IAAI;IASb,yGAAyG;IACzG,kBAAkB,IAAI,IAAI;IAI1B;;;;;OAKG;IACH,QAAQ,IAAI,IAAI;IAOhB,8FAA8F;IAC9F,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,kFAAkF;IAClF,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}

package/dist/core/simple/turn-boundary.js

@@ -0,0 +1,72 @@
+/**
+ * The turn's REAL agent boundary (PRD §5.8, C-API-48/50): the point past which the serializer
+ * may start the next turn. Separated from the runner (turn.ts) to keep both under the size cap.
+ *
+ * SUCCESS path: the gate's genuine end (oracle matched / quiet window — the transcript has
+ * drained) or a terminal status. NOT bare `ready`: Claude transcript activity arrives AFTER
+ * `ready`, so releasing there would let the next turn bind this turn's still-arriving (untagged)
+ * activity. FAILURE path (consumer timeout/catch-up/backlog): the agent may still be RUNNING —
+ * and a silent long-running tool is quiet, not done — so a quiet window is unsafe. The boundary
+ * then waits for a real `ready` (a busy agent is `running`, not ready) or terminal, followed by
+ * a short transcript-drain settle. A hung agent holds the slot until `close()`/`kill()` forces a
+ * terminal status — honest backpressure, never a silent early release.
+ */
+/** Short transcript-drain settle (ms) after a post-failure `ready` — trailing events flush. */
+const DRAIN_MS = 750;
+export class TurnBoundary {
+    /** Resolves when the next turn may safely start. The serializer holds its slot on this. */
+    promise;
+    resolve;
+    reached = false;
+    consumerFailed = false;
+    drainTimer;
+    onReach;
+    drainMs;
+    /** `onReach` runs once the boundary lands (e.g. to attempt listener cleanup). `drainMs` is the
+     *  post-failure `ready` drain window (default `DRAIN_MS`; overridable for tests). */
+    constructor(onReach, drainMs = DRAIN_MS) {
+        this.onReach = onReach;
+        this.drainMs = drainMs;
+        this.promise = new Promise((resolve) => {
+            this.resolve = resolve;
+        });
+    }
+    /** Land the boundary now (idempotent): a terminal status, or the gate's genuine success end. */
+    reach() {
+        if (this.reached)
+            return;
+        this.reached = true;
+        if (this.drainTimer)
+            clearTimeout(this.drainTimer);
+        this.drainTimer = undefined; // so `draining` reports the truth once the boundary has landed
+        this.resolve();
+        this.onReach();
+    }
+    /** Mark that the consumer turn failed: the boundary now waits for a real `ready`/terminal, not quiet. */
+    markConsumerFailed() {
+        this.consumerFailed = true;
+    }
+    /**
+     * A `ready` after a consumer failure means the agent turn is done (a still-working tool is
+     * `running`, not ready): arm a short transcript-drain settle so trailing untagged events flush
+     * before the slot releases. Re-armed by further activity/`ready`. No-op before a failure or once
+     * the boundary is reached.
+     */
+    armDrain() {
+        if (this.reached || !this.consumerFailed)
+            return;
+        if (this.drainTimer)
+            clearTimeout(this.drainTimer);
+        this.drainTimer = setTimeout(() => this.reach(), this.drainMs);
+        this.drainTimer.unref?.();
+    }
+    /** True once a drain settle is pending — a trailing event should re-arm it, not ignore it. */
+    get draining() {
+        return this.drainTimer !== undefined;
+    }
+    /** True once the boundary has landed (for the runner's combined cleanup gate). */
+    get isReached() {
+        return this.reached;
+    }
+}
+//# sourceMappingURL=turn-boundary.js.map

package/dist/core/simple/turn-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-boundary.js","sourceRoot":"","sources":["../../../src/core/simple/turn-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,+FAA+F;AAC/F,MAAM,QAAQ,GAAG,GAAG,CAAC;AAErB,MAAM,OAAO,YAAY;IACvB,2FAA2F;IAClF,OAAO,CAAgB;IACxB,OAAO,CAAc;IACrB,OAAO,GAAG,KAAK,CAAC;IAChB,cAAc,GAAG,KAAK,CAAC;IACvB,UAAU,CAA4C;IAC7C,OAAO,CAAa;IACpB,OAAO,CAAS;IAEjC;yFACqF;IACrF,YAAY,OAAmB,EAAE,OAAO,GAAG,QAAQ;QACjD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAC3C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gGAAgG;IAChG,KAAK;QACH,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,IAAI,CAAC,UAAU;YAAE,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACnD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,+DAA+D;QAC5F,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,yGAAyG;IACzG,kBAAkB;QAChB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,QAAQ;QACN,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO;QACjD,IAAI,IAAI,CAAC,UAAU;YAAE,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACnD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/D,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC;IAC5B,CAAC;IAED,8FAA8F;IAC9F,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC;IACvC,CAAC;IAED,kFAAkF;IAClF,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF"}

package/dist/core/simple/turn-gate.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The completion gate for one ergonomic turn (PRD §5.8): a single-producer/single-consumer
+ * async queue that ends a turn DETERMINISTICALLY once the transcript has caught up.
+ *
+ * `observeReady()` (on `ready`) begins completion checks and arms a `catchUpMs` failure cap. The
+ * turn ends when the collected assistant text CONTAINS the Stop hook's expected text (the oracle),
+ * or — with no expected text — after `quietMs` of no new content; if neither happens within
+ * `catchUpMs` of `ready` it fails with `wait_timeout`. `end()`/`fail()` are IDEMPOTENT (first
+ * completion wins). `done()` resolves/rejects at that completion for the runner; `drain()` is the
+ * consumer view and finishes only once the queue is also empty (a completion racing ahead of the
+ * last buffered event never truncates it).
+ */
+import { type TurnEvent } from "./events.ts";
+export declare class TurnGate {
+    private readonly queue;
+    private head;
+    private pendingBytes;
+    private ended;
+    private error;
+    private wake;
+    private readyObserved;
+    private readonly oracle;
+    private quietTimer;
+    private catchUpTimer;
+    private readonly quietMs;
+    private readonly catchUpMs;
+    private readonly maxPendingEvents;
+    private readonly maxPendingBytes;
+    private resolveDone;
+    private rejectDone;
+    private readonly donePromise;
+    constructor(quietMs: number, catchUpMs: number, maxPendingEvents?: number, maxPendingBytes?: number);
+    /** Resolves at the real turn boundary; rejects on failure/timeout. For the turn runner. */
+    done(): Promise<void>;
+    /** Backing-array length — the retained storage. A CONTINUOUS stream must keep this bounded. */
+    get backingSize(): number;
+    observeText(text: string): void;
+    /**
+     * Feed one normalized boundary signal. `undefined` is NOT a boundary (a non-`Stop` hook such as
+     * `Notification` arriving after `Stop`) and leaves an installed oracle untouched — else late
+     * assistant text would fall through to the quiet window and leak into the next turn. A string
+     * installs the oracle; an empty one clears it (→ quiet settle).
+     */
+    expectText(text: string | undefined): void;
+    push(event: TurnEvent): void;
+    /** `ready` observed — begin completion checks and arm the post-ready catch-up cap. */
+    observeReady(): void;
+    /** Complete the turn (idempotent — the first completion wins). */
+    end(): void;
+    /** Fail the turn (idempotent — a late timer cannot overwrite an already-committed end). */
+    fail(error: unknown): void;
+    /** Clear every timer (idempotent); called on end/fail. */
+    dispose(): void;
+    /** End now if the transcript has caught up to the expected text; else arm the fallback. */
+    private reconcile;
+    private armQuiet;
+    drain(): AsyncGenerator<TurnEvent>;
+}
+//# sourceMappingURL=turn-gate.d.ts.map

package/dist/core/simple/turn-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-gate.d.ts","sourceRoot":"","sources":["../../../src/core/simple/turn-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,aAAa,CAAC;AAiB7D,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;IACnD,OAAO,CAAC,UAAU,CAA4C;IAC9D,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgB;gBAG1C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,gBAAgB,SAAqB,EACrC,eAAe,SAAoB;IAgBrC,2FAA2F;IAC3F,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,+FAA+F;IAC/F,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI/B;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAW1C,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAkB5B,sFAAsF;IACtF,YAAY,IAAI,IAAI;IAUpB,kEAAkE;IAClE,GAAG,IAAI,IAAI;IAOX,2FAA2F;IAC3F,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQ1B,0DAA0D;IAC1D,OAAO,IAAI,IAAI;IAMf,2FAA2F;IAC3F,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,QAAQ;IAMT,KAAK,IAAI,cAAc,CAAC,SAAS,CAAC;CA0B1C"}