@blxzer/pactile 0.5.0

package/dist/commands/channel/supervisor/idle.js

@@ -0,0 +1,72 @@
+/**
+ * Supervisor-side idle-timeout timer.
+ *
+ * Complements the spawn-time guard: each running worker self-terminates
+ * after its own idle TTL so a long-lived supervisor can't keep an
+ * otherwise-idle worker alive indefinitely.
+ *
+ * Behavior:
+ *   - Start an idle timer right after `spawned`.
+ *   - Reset / restart on `turn_finished` and `interrupted` (worker
+ *     transitioned back to idle).
+ *   - Pause on `turn_started` (worker is mid-turn; never kill mid-turn).
+ *   - On idle timeout, call `shutdown.request("SIGTERM", "idle-timeout")`.
+ *
+ * Lives outside `createShutdown` so the shutdown funnel only owns the
+ * kill ladder + `killed` append. Cancellation is via the returned
+ * handle (used on supervisor teardown).
+ */
+/**
+ * Schedule a self-resetting idle timer. `idleTimeoutMs <= 0` short-
+ * circuits to a no-op handle (idle cleanup disabled).
+ */
+export function scheduleSupervisorIdleTimer(args) {
+    const { idleTimeoutMs, shutdown, isChildExited, log } = args;
+    if (idleTimeoutMs <= 0) {
+        return {
+            reset: () => undefined,
+            pause: () => undefined,
+            cancel: () => undefined,
+        };
+    }
+    let timer;
+    let cancelled = false;
+    const clear = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const fire = () => {
+        timer = undefined;
+        if (cancelled)
+            return;
+        if (shutdown.isShuttingDown() ||
+            shutdown.hasTerminalEvent() ||
+            isChildExited()) {
+            return;
+        }
+        log.write(`[supervisor] idle timeout ${idleTimeoutMs}ms reached, requesting shutdown\n`);
+        void shutdown.request("SIGTERM", "idle-timeout");
+    };
+    const start = () => {
+        if (cancelled)
+            return;
+        clear();
+        timer = setTimeout(fire, idleTimeoutMs);
+        // Don't keep the supervisor alive solely for the idle timer; if
+        // every other handle has gone away the worker has nothing to do.
+        timer.unref?.();
+    };
+    // Initial schedule: worker just spawned, currently idle.
+    start();
+    return {
+        reset: start,
+        pause: clear,
+        cancel: () => {
+            cancelled = true;
+            clear();
+        },
+    };
+}
+//# sourceMappingURL=idle.js.map

package/dist/commands/channel/supervisor/idle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle.js","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/idle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA0BH;;;GAGG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAA2B;IAE3B,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7D,IAAI,aAAa,IAAI,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS;YACtB,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS;YACtB,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS;SACxB,CAAC;IACJ,CAAC;IAED,IAAI,KAAgD,CAAC;IACrD,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,MAAM,KAAK,GAAG,GAAS,EAAE;QACvB,IAAI,KAAK,EAAE,CAAC;YACV,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,KAAK,GAAG,SAAS,CAAC;QACpB,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG,GAAS,EAAE;QACtB,KAAK,GAAG,SAAS,CAAC;QAClB,IAAI,SAAS;YAAE,OAAO;QACtB,IACE,QAAQ,CAAC,cAAc,EAAE;YACzB,QAAQ,CAAC,gBAAgB,EAAE;YAC3B,aAAa,EAAE,EACf,CAAC;YACD,OAAO;QACT,CAAC;QACD,GAAG,CAAC,KAAK,CACP,6BAA6B,aAAa,mCAAmC,CAC9E,CAAC;QACF,KAAK,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IACnD,CAAC,CAAC;IAEF,MAAM,KAAK,GAAG,GAAS,EAAE;QACvB,IAAI,SAAS;YAAE,OAAO;QACtB,KAAK,EAAE,CAAC;QACR,KAAK,GAAG,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QACxC,gEAAgE;QAChE,iEAAiE;QACjE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAClB,CAAC,CAAC;IAEF,yDAAyD;IACzD,KAAK,EAAE,CAAC;IAER,OAAO;QACL,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,GAAG,EAAE;YACX,SAAS,GAAG,IAAI,CAAC;YACjB,KAAK,EAAE,CAAC;QACV,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/commands/channel/supervisor/inbox.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Inbox watcher: tails events.jsonl for worker-addressed messages and
+ * interrupt requests, then forwards accepted input into the worker's stdin.
+ * A persisted cursor file keeps respawns from replaying events the previous
+ * supervisor already delivered.
+ *
+ * Step 3 of the supervisor refactor: pulled out of supervisor.ts so the
+ * orchestrator only needs to call `runInboxWatcher(...)`. Cursor
+ * read/write helpers stay private to this module.
+ */
+import type { ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+import { type InboxPolicy } from "@blxzer/pactile-core/channel";
+import type { WorkerAdapter } from "../adapters/index.js";
+import type { TurnTracker } from "./turns.js";
+type Child = ChildProcessByStdio<Writable, Readable, Readable>;
+export interface InboxWatcherArgs {
+    channelName: string;
+    workerName: string;
+    adapter: WorkerAdapter;
+    ctx: unknown;
+    child: Child;
+    signal: AbortSignal;
+    /** Inbox delivery policy. Defaults to `explicitOnly` (legacy behavior). */
+    inboxPolicy?: InboxPolicy;
+    turnTracker?: TurnTracker;
+}
+export declare function runInboxWatcher(args: InboxWatcherArgs): Promise<void>;
+export {};
+//# sourceMappingURL=inbox.d.ts.map

package/dist/commands/channel/supervisor/inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.d.ts","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/inbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,KAAK,KAAK,GAAG,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAE/D,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoH3E"}

package/dist/commands/channel/supervisor/inbox.js

@@ -0,0 +1,160 @@
+/**
+ * Inbox watcher: tails events.jsonl for worker-addressed messages and
+ * interrupt requests, then forwards accepted input into the worker's stdin.
+ * A persisted cursor file keeps respawns from replaying events the previous
+ * supervisor already delivered.
+ *
+ * Step 3 of the supervisor refactor: pulled out of supervisor.ts so the
+ * orchestrator only needs to call `runInboxWatcher(...)`. Cursor
+ * read/write helpers stay private to this module.
+ */
+import fs from "node:fs";
+import { DEFAULT_INBOX_POLICY, matchesInboxPolicy, } from "@blxzer/pactile-core/channel";
+import { appendEvent } from "../store/events.js";
+import { workerFile } from "../store/paths.js";
+import { watchEvents } from "../store/watch.js";
+export async function runInboxWatcher(args) {
+    const { channelName, workerName, adapter, ctx, child, signal } = args;
+    const inboxPolicy = args.inboxPolicy ?? DEFAULT_INBOX_POLICY;
+    // Resume from persisted cursor: first-time spawn → 0 (read full backlog);
+    // respawn after kill → last forwarded seq (no replay).
+    let cursor = readInboxCursor(channelName, workerName);
+    for await (const ev of watchEvents(channelName, {
+        self: workerName, // ignore our own events
+        kind: ["message", "interrupt_requested"],
+    }, 
+    // First run with cursor=0 reads backlog from start; subsequent runs
+    // use sinceSeq to skip already-processed events. Both cases tail
+    // future events normally.
+    { signal, sinceSeq: cursor, fromStart: cursor === 0 ? true : undefined })) {
+        if (signal.aborted)
+            return;
+        if (ev.kind === "message") {
+            // Core decides delivery from the worker's inbox policy: explicitOnly
+            // (default) consumes only targeted messages; broadcastAndExplicit
+            // also consumes broadcasts.
+            if (!matchesInboxPolicy(ev, workerName, inboxPolicy))
+                continue;
+        }
+        else if (ev.worker !== workerName) {
+            continue;
+        }
+        const text = (ev.text ?? "").trim();
+        const interruptText = (ev.message ?? "").trim();
+        const isInterrupt = ev.kind === "interrupt_requested";
+        if (!text && (!isInterrupt || !interruptText))
+            continue;
+        // Block until the adapter says it can accept input (e.g. codex
+        // thread/start has produced a threadId). Drop the message if we
+        // never get ready before being aborted.
+        if (!adapter.isReady(ctx)) {
+            const deadline = Date.now() + 60_000;
+            while (!adapter.isReady(ctx) &&
+                Date.now() < deadline &&
+                !signal.aborted) {
+                await sleep(25);
+            }
+            if (!adapter.isReady(ctx)) {
+                // never became ready; advance the cursor anyway so we don't
+                // re-attempt this exact event on next start.
+                cursor = ev.seq;
+                writeInboxCursor(channelName, workerName, cursor);
+                continue;
+            }
+        }
+        if (!isInterrupt) {
+            await waitForActiveTurnToFinish(args.turnTracker, signal);
+            if (signal.aborted)
+                return;
+        }
+        if (isInterrupt) {
+            const aborted = args.turnTracker?.abortCurrent();
+            if (aborted) {
+                await appendEvent(channelName, {
+                    kind: "turn_finished",
+                    by: workerName,
+                    worker: workerName,
+                    inputSeq: aborted.inputSeq,
+                    turnId: aborted.turnId,
+                    outcome: "aborted",
+                });
+            }
+            await appendEvent(channelName, {
+                kind: "interrupted",
+                by: workerName,
+                worker: workerName,
+                ...(aborted?.turnId ? { turnId: aborted.turnId } : {}),
+                reason: "user",
+                method: "stdin",
+                outcome: aborted ? "interrupted" : "no-active-turn",
+            });
+        }
+        let turn = args.turnTracker?.begin(ev.seq);
+        try {
+            if (turn) {
+                await appendEvent(channelName, {
+                    kind: "turn_started",
+                    by: workerName,
+                    worker: workerName,
+                    inputSeq: ev.seq,
+                    turnId: turn.turnId,
+                });
+            }
+            child.stdin.write(isInterrupt
+                ? adapter.encodeInterruptMessage(interruptText, ctx)
+                : adapter.encodeUserMessage(text, ctx));
+            cursor = ev.seq;
+            writeInboxCursor(channelName, workerName, cursor);
+        }
+        catch {
+            if (turn) {
+                args.turnTracker?.finish();
+                await appendEvent(channelName, {
+                    kind: "turn_finished",
+                    by: workerName,
+                    worker: workerName,
+                    inputSeq: turn.inputSeq,
+                    turnId: turn.turnId,
+                    outcome: "aborted",
+                }).catch(() => undefined);
+                turn = undefined;
+            }
+            // stdin closed, worker exiting — bail out
+            return;
+        }
+    }
+}
+/**
+ * Per-worker inbox consumption cursor. Persisted to
+ * `<worker>.inbox-cursor` so a respawn (same worker name) doesn't replay
+ * messages that the previous supervisor already forwarded into the worker
+ * process. The cursor is the highest seq we've already turned into a
+ * worker stdin write.
+ */
+function readInboxCursor(channelName, workerName) {
+    try {
+        const raw = fs.readFileSync(workerFile(channelName, workerName, "inbox-cursor"), "utf-8");
+        const n = Number(raw.trim());
+        return Number.isFinite(n) && n > 0 ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function writeInboxCursor(channelName, workerName, seq) {
+    try {
+        fs.writeFileSync(workerFile(channelName, workerName, "inbox-cursor"), String(seq), "utf-8");
+    }
+    catch {
+        // ignore — cursor is best-effort; worst case we replay a message
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function waitForActiveTurnToFinish(turnTracker, signal) {
+    while (turnTracker?.current() && !signal.aborted) {
+        await sleep(25);
+    }
+}
+//# sourceMappingURL=inbox.js.map

package/dist/commands/channel/supervisor/inbox.js.map

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

package/dist/commands/channel/supervisor/shutdown.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ShutdownController — the single funnel for every "this worker is going
+ * away" trigger (explicit kill, timeout, post-spawn crash, signal, child
+ * exit). It owns:
+ *
+ *   - the `shutdownReason` flag (idempotent — first call wins)
+ *   - the SIGTERM → grace → SIGKILL ladder
+ *   - the trailing `killed` event append
+ *   - a `terminalEmitted` flag tracking adapter-emitted done/error
+ *   - `finalizeOnExit` — synthesises a fallback `done`/`error` when the
+ *     worker exited without the adapter sending one (otherwise
+ *     `wait --kind done` would hang forever)
+ *   - `awaitFinalize` — lets `child.on("exit")` block process.exit until
+ *     any in-progress killed-append from a concurrent shutdown completes
+ *
+ * Step 2 of the supervisor refactor: this absorbs the 5 reviewer issues
+ * (codex #1 crashed-without-done, #2 fire-and-forget shutdown, #3 spawn
+ * after shutdown requested, #4 handshake error detail; claude M2 post-
+ * spawn error ordering, L1 pre-spawn double-fire guard) into a single
+ * state machine. The supervisor.ts orchestrator stays mostly mechanical.
+ */
+import type { ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+type Child = ChildProcessByStdio<Writable, Readable, Readable>;
+export type ShutdownReason = "explicit-kill" | "timeout" | "crash" | "idle-timeout";
+export interface ShutdownController {
+    /** Idempotent: only the first call wins. Returns the killed-append
+     *  promise so callers can await ordering if they need to. */
+    request(signal: NodeJS.Signals, reason: ShutdownReason): Promise<void>;
+    /** Synchronously mark shutdown intent without starting the kill
+     *  ladder or appending `killed`. Use when other code must see
+     *  `isShuttingDown=true` BEFORE the caller proceeds to any await
+     *  (e.g. post-spawn error handler that needs to `await appendEvent`
+     *  first, but doesn't want the main flow to keep writing `spawned`).
+     *  Returns true if this call claimed the flag, false if already set. */
+    claim(reason: ShutdownReason): boolean;
+    isShuttingDown(): boolean;
+    reason(): ShutdownReason | null;
+    /** Mark that the adapter has produced a `done` or `error` event, so
+     *  `finalizeOnExit` won't synthesise a fallback. */
+    markTerminalEmitted(): void;
+    hasTerminalEvent(): boolean;
+    /** Call from `child.on("exit")` — synthesises a fallback terminal
+     *  event if the adapter never produced one, then awaits any pending
+     *  `request()` so `killed` lands before the supervisor exits. */
+    finalizeOnExit(code: number | null, signal: NodeJS.Signals | null): Promise<void>;
+    /** Promise that resolves when the current (or last) `request()` has
+     *  finished writing its `killed` event. No-op when never requested. */
+    awaitFinalize(): Promise<void>;
+}
+export interface CreateShutdownArgs {
+    channelName: string;
+    workerName: string;
+    log: {
+        write: (data: string) => void;
+    };
+    /** Lazy child getter — the controller is created before `spawn()`
+     *  returns, so we read the child handle at shutdown time. */
+    getChild: () => Child;
+    graceMs: number;
+    /** Recorded on the `killed` event for the timeout reason. */
+    timeoutMs?: number;
+    /** Recorded on the `killed` event when reason is `"idle-timeout"`. */
+    idleTimeoutMs?: number;
+}
+export declare function createShutdown(args: CreateShutdownArgs): ShutdownController;
+export {};
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/commands/channel/supervisor/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,KAAK,KAAK,GAAG,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAE/D,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,SAAS,GACT,OAAO,GACP,cAAc,CAAC;AAEnB,MAAM,WAAW,kBAAkB;IACjC;iEAC6D;IAC7D,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE;;;;;4EAKwE;IACxE,KAAK,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC;IACvC,cAAc,IAAI,OAAO,CAAC;IAC1B,MAAM,IAAI,cAAc,GAAG,IAAI,CAAC;IAEhC;wDACoD;IACpD,mBAAmB,IAAI,IAAI,CAAC;IAC5B,gBAAgB,IAAI,OAAO,CAAC;IAE5B;;qEAEiE;IACjE,cAAc,CACZ,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;2EACuE;IACvE,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IACvC;iEAC6D;IAC7D,QAAQ,EAAE,MAAM,KAAK,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB,CAkJ3E"}

package/dist/commands/channel/supervisor/shutdown.js

@@ -0,0 +1,146 @@
+/**
+ * ShutdownController — the single funnel for every "this worker is going
+ * away" trigger (explicit kill, timeout, post-spawn crash, signal, child
+ * exit). It owns:
+ *
+ *   - the `shutdownReason` flag (idempotent — first call wins)
+ *   - the SIGTERM → grace → SIGKILL ladder
+ *   - the trailing `killed` event append
+ *   - a `terminalEmitted` flag tracking adapter-emitted done/error
+ *   - `finalizeOnExit` — synthesises a fallback `done`/`error` when the
+ *     worker exited without the adapter sending one (otherwise
+ *     `wait --kind done` would hang forever)
+ *   - `awaitFinalize` — lets `child.on("exit")` block process.exit until
+ *     any in-progress killed-append from a concurrent shutdown completes
+ *
+ * Step 2 of the supervisor refactor: this absorbs the 5 reviewer issues
+ * (codex #1 crashed-without-done, #2 fire-and-forget shutdown, #3 spawn
+ * after shutdown requested, #4 handshake error detail; claude M2 post-
+ * spawn error ordering, L1 pre-spawn double-fire guard) into a single
+ * state machine. The supervisor.ts orchestrator stays mostly mechanical.
+ */
+import { appendEvent } from "../store/events.js";
+export function createShutdown(args) {
+    const { channelName, workerName, log, getChild, graceMs, timeoutMs, idleTimeoutMs, } = args;
+    let shutdownReason = null;
+    let requestSignal = null;
+    let terminalEmitted = false;
+    let killedPromise = null;
+    const childStillRunning = (child) => child.exitCode === null && child.signalCode === null;
+    const startKillLadder = (child) => {
+        try {
+            child.stdin.end();
+        }
+        catch {
+            // already closed
+        }
+        setTimeout(() => {
+            if (childStillRunning(child)) {
+                log.write(`[supervisor] grace expired, SIGTERM worker\n`);
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch {
+                    // already dead
+                }
+                setTimeout(() => {
+                    if (childStillRunning(child)) {
+                        log.write(`[supervisor] still alive, SIGKILL worker\n`);
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch {
+                            // already dead
+                        }
+                    }
+                }, graceMs);
+            }
+        }, graceMs);
+    };
+    const writeKilled = async (reason, signal) => {
+        await appendEvent(channelName, {
+            kind: "killed",
+            by: `supervisor:${workerName}`,
+            reason,
+            signal,
+            ...(reason === "timeout" && timeoutMs ? { timeout_ms: timeoutMs } : {}),
+            ...(reason === "idle-timeout" && idleTimeoutMs
+                ? { idle_timeout_ms: idleTimeoutMs }
+                : {}),
+        });
+    };
+    const claim = (reason) => {
+        if (shutdownReason)
+            return false;
+        shutdownReason = reason;
+        return true;
+    };
+    const request = async (signal, reason) => {
+        // The kill ladder + killed-append are one-shot; whether we got here
+        // via `claim()` + `request()` (post-spawn error) or a single
+        // `request()` (signal / timeout), only run them once.
+        if (killedPromise) {
+            await killedPromise.catch(() => undefined);
+            return;
+        }
+        shutdownReason ??= reason;
+        requestSignal ??= signal;
+        log.write(`[supervisor] shutting down worker (reason=${shutdownReason}, signal=${requestSignal})\n`);
+        startKillLadder(getChild());
+        killedPromise = writeKilled(shutdownReason, requestSignal);
+        await killedPromise;
+    };
+    const finalizeOnExit = async (code, signal) => {
+        log.write(`[supervisor] worker exit code=${code ?? "null"} signal=${signal ?? "null"}\n`);
+        // #1 fix: synthesise a terminal event so consumers blocked on
+        // `wait --kind done` don't hang when the adapter never produced
+        // one. Only applies to COLD exits (no explicit shutdown requested);
+        // when shutdown was requested the `killed` event already serves as
+        // the terminal signal and a synthesised error would just duplicate.
+        //
+        // The flag is claimed SYNCHRONOUSLY before the await so two
+        // concurrent `finalizeOnExit` calls (or `applyParseResult` racing
+        // with `child.on("exit")`) can't both pass the guard and emit
+        // duplicate synthetic events. `by` is the worker name (not
+        // `supervisor:<name>`) so `wait --from <worker> --kind done` wakes
+        // for the synthesised event same as for an adapter-emitted one.
+        if (!terminalEmitted && shutdownReason === null) {
+            terminalEmitted = true;
+            if (code === 0) {
+                await appendEvent(channelName, {
+                    kind: "done",
+                    by: workerName,
+                    synthesized: true,
+                    exit_code: code,
+                });
+            }
+            else {
+                await appendEvent(channelName, {
+                    kind: "error",
+                    by: workerName,
+                    message: `worker exited without terminal event (code=${code ?? "null"}, signal=${signal ?? "null"})`,
+                    synthesized: true,
+                    exit_code: code,
+                    exit_signal: signal,
+                });
+            }
+        }
+        // #2 fix: wait for any in-progress `killed` append from a concurrent
+        // shutdown request so it lands before the supervisor exits.
+        if (killedPromise)
+            await killedPromise.catch(() => undefined);
+    };
+    return {
+        request,
+        claim,
+        isShuttingDown: () => shutdownReason !== null,
+        reason: () => shutdownReason,
+        markTerminalEmitted: () => {
+            terminalEmitted = true;
+        },
+        hasTerminalEvent: () => terminalEmitted,
+        finalizeOnExit,
+        awaitFinalize: () => killedPromise ?? Promise.resolve(),
+    };
+}
+//# sourceMappingURL=shutdown.js.map

package/dist/commands/channel/supervisor/shutdown.js.map

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

package/dist/commands/channel/supervisor/stdout.d.ts

@@ -0,0 +1,51 @@
+/**
+ * stdout pipeline: line-buffered reader → adapter.parseLine → append
+ * events into events.jsonl + persist session/thread IDs + write any
+ * adapter `reply` back to the worker's stdin.
+ *
+ * Step 3 of the supervisor refactor: pulled out of supervisor.ts so the
+ * orchestrator stays thin. The pump itself is pure (no fs / process), so
+ * unit testing the line-splitting logic is straightforward once we want
+ * to. `applyParseResult` still touches fs for session-id persistence —
+ * that's intentional, it's the only place that needs to.
+ */
+import type { ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+import type { WorkerAdapter } from "../adapters/index.js";
+import type { ParseResult } from "../adapters/types.js";
+import type { ShutdownController } from "./shutdown.js";
+import type { TurnTracker } from "./turns.js";
+type Child = ChildProcessByStdio<Writable, Readable, Readable>;
+/**
+ * Line-buffered stdout pump. Yields each non-empty line to `onLine` as
+ * soon as a newline arrives, wraps the handler in a `.catch` so a thrown
+ * await doesn't escape as `unhandledRejection`, and reports the failure
+ * through `onError` for observability.
+ */
+export declare function pumpStdout(stream: Readable, onLine: (line: string) => Promise<void> | void, onError?: (err: Error) => void): void;
+/**
+ * Translate an adapter `ParseResult` into channel events + adapter-level
+ * side-effects (session-id persistence, stdin writes). Also tells the
+ * shutdown controller when the adapter emits a `done`/`error` so the
+ * fallback synthesiser in `finalizeOnExit` doesn't duplicate.
+ */
+export declare function applyParseResult(channelName: string, workerName: string, result: ParseResult, child: Child, shutdown: ShutdownController, turnTracker?: TurnTracker): Promise<void>;
+/**
+ * Convenience wrapper: wire `pumpStdout` to `applyParseResult` with
+ * standard error-event-on-failure handling. The orchestrator just calls
+ * this and forgets about line buffering / parse plumbing.
+ */
+export declare function startStdoutPump(args: {
+    channelName: string;
+    workerName: string;
+    child: Child;
+    adapter: WorkerAdapter;
+    adapterCtx: unknown;
+    log: {
+        write: (data: string) => void;
+    };
+    shutdown: ShutdownController;
+    turnTracker?: TurnTracker;
+}): void;
+export {};
+//# sourceMappingURL=stdout.d.ts.map

package/dist/commands/channel/supervisor/stdout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdout.d.ts","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/stdout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,YAAY,CAAC;AAE3D,KAAK,KAAK,GAAG,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC9C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,GAC7B,IAAI,CAuBN;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,kBAAkB,EAC5B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,IAAI,CAAC,CAqDf;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,GAAG,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IACvC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GAAG,IAAI,CAkCP"}