trellis-he 0.6.0-beta.17

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

@@ -0,0 +1,160 @@
+/**
+ * Inbox watcher: tails events.jsonl for `kind:message` events addressed
+ * to this worker and forwards them into the worker's stdin via the
+ * adapter's `encodeUserMessage`. A persisted cursor file keeps respawns
+ * from replaying messages 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 "trellis-he-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
+        to: workerName, // explicit-to-other is filtered here; broadcasts pass
+        kind: "message",
+    }, 
+    // 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;
+        // 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;
+        const text = (ev.text ?? "").trim();
+        if (!text)
+            continue;
+        const tag = ev.tag;
+        // 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 (tag !== "interrupt") {
+            await waitForActiveTurnToFinish(args.turnTracker, signal);
+            if (signal.aborted)
+                return;
+        }
+        if (tag === "interrupt") {
+            await appendEvent(channelName, {
+                kind: "interrupt_requested",
+                by: ev.by,
+                worker: workerName,
+                reason: "user",
+                message: text,
+            });
+            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(adapter.encodeUserMessage(text, tag, 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,66 @@
+/**
+ * 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";
+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;
+}
+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,GAAG,eAAe,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnE,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;CACpB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB,CAuI3E"}

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

@@ -0,0 +1,143 @@
+/**
+ * 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 } = 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 } : {}),
+        });
+    };
+    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"}

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

@@ -0,0 +1,121 @@
+/**
+ * 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 fs from "node:fs";
+import { appendEvent } from "../store/events.js";
+import { workerFile } from "../store/paths.js";
+/**
+ * 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 function pumpStdout(stream, onLine, onError) {
+    let buf = "";
+    stream.on("data", (chunk) => {
+        buf += chunk.toString("utf-8");
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (line.trim()) {
+                Promise.resolve()
+                    .then(() => onLine(line))
+                    .catch((err) => {
+                    if (onError) {
+                        try {
+                            onError(err instanceof Error ? err : new Error(String(err)));
+                        }
+                        catch {
+                            // swallow handler-of-handler errors
+                        }
+                    }
+                });
+            }
+        }
+    });
+}
+/**
+ * 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 async function applyParseResult(channelName, workerName, result, child, shutdown, turnTracker) {
+    for (const ev of result.events) {
+        // Claim the terminal slot SYNCHRONOUSLY before the await so a
+        // racing `child.on("exit") → finalizeOnExit` can't see
+        // `terminalEmitted=false` and synthesise a duplicate fallback while
+        // we're in the middle of writing the real terminal event.
+        if (ev.kind === "done" || ev.kind === "error") {
+            shutdown.markTerminalEmitted();
+        }
+        await appendEvent(channelName, {
+            kind: ev.kind,
+            by: workerName,
+            ...(ev.payload ?? {}),
+        });
+        if (ev.kind === "done" || ev.kind === "error") {
+            const turn = turnTracker?.finish();
+            if (turn) {
+                const outcome = ev.kind === "done" ? "done" : "error";
+                await appendEvent(channelName, {
+                    kind: "turn_finished",
+                    by: workerName,
+                    worker: workerName,
+                    inputSeq: turn.inputSeq,
+                    turnId: turn.turnId,
+                    outcome,
+                });
+            }
+        }
+    }
+    if (result.side) {
+        const { reply, persistSessionId, persistThreadId } = result.side;
+        if (persistSessionId) {
+            fs.writeFileSync(workerFile(channelName, workerName, "session-id"), persistSessionId);
+        }
+        if (persistThreadId) {
+            fs.writeFileSync(workerFile(channelName, workerName, "thread-id"), persistThreadId);
+        }
+        if (reply) {
+            for (const r of reply) {
+                try {
+                    child.stdin.write(r);
+                }
+                catch {
+                    // worker stdin closed — supervisor will exit soon
+                }
+            }
+        }
+    }
+}
+/**
+ * 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 function startStdoutPump(args) {
+    const { channelName, workerName, child, adapter, adapterCtx, log, shutdown, turnTracker, } = args;
+    pumpStdout(child.stdout, async (line) => {
+        log.write(line + "\n");
+        const result = adapter.parseLine(line, adapterCtx);
+        await applyParseResult(channelName, workerName, result, child, shutdown, turnTracker);
+    }, (err) => {
+        log.write(`[supervisor] stdout line handler failed: ${err.message}\n`);
+        void appendEvent(channelName, {
+            kind: "error",
+            by: `supervisor:${workerName}`,
+            message: `stdout pipeline error: ${err.message}`,
+        }).catch(() => undefined);
+    });
+}
+//# sourceMappingURL=stdout.js.map

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

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

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

@@ -0,0 +1,20 @@
+export interface ActiveTurn {
+    inputSeq: number;
+    turnId: string;
+}
+export type TurnOutcome = "done" | "error" | "aborted";
+/**
+ * Host-local turn tracker for one supervisor process.
+ *
+ * The durable SOT is events.jsonl. This object only remembers the input
+ * message seq long enough for the inbox watcher and stdout pump to emit
+ * matching `turn_started` / `turn_finished` events.
+ */
+export declare class TurnTracker {
+    #private;
+    begin(inputSeq: number): ActiveTurn;
+    finish(): ActiveTurn | undefined;
+    abortCurrent(): ActiveTurn | undefined;
+    current(): ActiveTurn | undefined;
+}
+//# sourceMappingURL=turns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"turns.d.ts","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/turns.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD;;;;;;GAMG;AACH,qBAAa,WAAW;;IAGtB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;IASnC,MAAM,IAAI,UAAU,GAAG,SAAS;IAIhC,YAAY,IAAI,UAAU,GAAG,SAAS;IAItC,OAAO,IAAI,UAAU,GAAG,SAAS;CAGlC"}

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

@@ -0,0 +1,28 @@
+/**
+ * Host-local turn tracker for one supervisor process.
+ *
+ * The durable SOT is events.jsonl. This object only remembers the input
+ * message seq long enough for the inbox watcher and stdout pump to emit
+ * matching `turn_started` / `turn_finished` events.
+ */
+export class TurnTracker {
+    #turns = [];
+    begin(inputSeq) {
+        const turn = {
+            inputSeq,
+            turnId: `msg:${inputSeq}`,
+        };
+        this.#turns.push(turn);
+        return turn;
+    }
+    finish() {
+        return this.#turns.pop();
+    }
+    abortCurrent() {
+        return this.#turns.pop();
+    }
+    current() {
+        return this.#turns.at(-1);
+    }
+}
+//# sourceMappingURL=turns.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"turns.js","sourceRoot":"","sources":["../../../../src/commands/channel/supervisor/turns.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,OAAO,WAAW;IACtB,MAAM,GAAiB,EAAE,CAAC;IAE1B,KAAK,CAAC,QAAgB;QACpB,MAAM,IAAI,GAAe;YACvB,QAAQ;YACR,MAAM,EAAE,OAAO,QAAQ,EAAE;SAC1B,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC;CACF"}