@yagni-app/code 0.1.0 → 0.2.0

package/dist/extension/pipeline/runState.js

@@ -0,0 +1,275 @@
+/**
+ * The headless model behind every `/go` progress display.
+ *
+ * `RunState` folds the structured `PipelineProgress` signals, curated
+ * `ActivityLine`s and raw assistant `JsonEvent` usage into one small model that
+ * both surfaces render from: the terminal's boxed ANSI panel (via
+ * `ActivityFeed`, which is now a pure renderer over this) and the desktop's
+ * Agents tab (via `toJSON()`, pushed as one line over `setWidget`).
+ *
+ * It owns no I/O and no clock — the caller injects `at` — so it is fully
+ * deterministic in tests, exactly like the feed it replaces.
+ *
+ * Two properties are load-bearing:
+ *
+ *  1. **Lens events never touch their parent stage.** A `stage_start` /
+ *     `stage_done` carrying a `lens` mutates only that lens's agent. Without
+ *     this the per-lens signals would mark the terminal's `review` row done
+ *     while two lenses were still running.
+ *
+ *  2. **Per-agent action lists only.** The terminal's flat, arrival-ordered ring
+ *     buffer stays in `ActivityFeed`: it exists to fit pi's widget cap, which is
+ *     a property of that renderer rather than of the run. Keeping it there means
+ *     the panel's cross-lens interleaving is preserved by code that never moved.
+ */
+/** The fixed stage order shown by both surfaces (v1 stages + the post-loop FINISH row). */
+export const STAGE_ORDER = ["map", "plan", "implement", "review", "fix", "finish"];
+/**
+ * Per-agent action cap. Generous compared to the terminal's `MAX_VISIBLE_ACTIONS`
+ * because the desktop pane scrolls: the TUI's 4-row ceiling is a widget-height
+ * constraint, not a truth about how much happened.
+ */
+export const AGENT_ACTION_WINDOW = 40;
+function emptyUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+/**
+ * Stable agent id: a lens child is keyed by its lens AND round, and fix — the
+ * only lens-less stage that re-executes per round — by its round, so each
+ * round's fix keeps its own clock and usage instead of accumulating tokens on a
+ * timer that resets (the "181k tok in 59s" artifact). Review stage-level events
+ * stay on the bare `review` node: they mark the round boundary, and the lens
+ * children carry the round's real work.
+ */
+export function agentId(stageId, lens, round) {
+    if (lens)
+        return `${stageId}:${lens}:r${round ?? 1}`;
+    if (stageId === "fix" && round !== undefined)
+        return `fix:r${round}`;
+    return stageId;
+}
+export class RunState {
+    runId;
+    ticket;
+    startedAt;
+    endedAt;
+    stopReason;
+    serverRunId;
+    round = 0;
+    findingsTotal = 0;
+    findingsBlocking = 0;
+    rounds = [];
+    agents;
+    constructor(init) {
+        this.runId = init.runId;
+        this.ticket = init.ticket;
+        this.startedAt = init.startedAt;
+        this.agents = STAGE_ORDER.map((id) => ({
+            id,
+            stageId: id,
+            status: "pending",
+            summary: "",
+            actions: [],
+            usage: emptyUsage(),
+        }));
+    }
+    /** The lens-less stage agent, or undefined for an unknown stage. */
+    stageAgent(stageId) {
+        return this.agents.find((a) => a.id === stageId);
+    }
+    /**
+     * The agent for a tag, created on demand. Lens children are inserted directly
+     * after their parent stage and any existing siblings, so the array order still
+     * reads top-to-bottom for the desktop and the lens-less filter still yields
+     * STAGE_ORDER for the terminal.
+     */
+    ensureAgent(stageId, lens, round, at) {
+        const id = agentId(stageId, lens, round);
+        const found = this.agents.find((a) => a.id === id);
+        if (found)
+            return found;
+        const node = {
+            id,
+            stageId,
+            ...(lens ? { lens } : {}),
+            ...(round !== undefined ? { round } : {}),
+            status: "active",
+            summary: "",
+            startedAt: at,
+            actions: [],
+            usage: emptyUsage(),
+        };
+        const parentIdx = this.agents.findIndex((a) => a.id === stageId);
+        if (parentIdx < 0) {
+            this.agents.push(node);
+            return node;
+        }
+        let insertAt = parentIdx + 1;
+        // Skip existing children (lens or per-round nodes: any id that is not its own
+        // stage row) so siblings append in arrival order after their parent.
+        while (insertAt < this.agents.length && this.agents[insertAt]?.id !== this.agents[insertAt]?.stageId)
+            insertAt += 1;
+        this.agents.splice(insertAt, 0, node);
+        return node;
+    }
+    /** Fold a structured progress signal. `at` is only read by the desktop surface. */
+    applyProgress(p, at = 0) {
+        switch (p.kind) {
+            case "stage_start": {
+                if (typeof p.round === "number")
+                    this.round = p.round;
+                // `ensureAgent` routes by id: a lens or per-round fix signal creates its
+                // own child; a bare stage signal (including review's round boundary,
+                // which must return to active even though a prior round left it done)
+                // lands on the pre-seeded stage node.
+                const target = this.ensureAgent(p.stageId, p.lens, p.round, at);
+                target.status = "active";
+                target.startedAt = at;
+                // `delete`, not `= undefined`: an explicitly-undefined property still
+                // shows up in Object.keys, and the wire shape is asserted by key set.
+                delete target.endedAt;
+                break;
+            }
+            case "stage_done": {
+                if (typeof p.round === "number")
+                    this.round = p.round;
+                const target = this.ensureAgent(p.stageId, p.lens, p.round, at);
+                if (p.degraded === "failed") {
+                    target.status = "failed";
+                }
+                else if (target.status !== "failed") {
+                    target.status = "done";
+                }
+                target.endedAt = at;
+                if (typeof p.findings === "number")
+                    target.findings = p.findings;
+                if (typeof p.blocking === "number")
+                    target.blocking = p.blocking;
+                if (p.degraded)
+                    target.degraded = p.degraded;
+                break;
+            }
+            case "findings": {
+                this.round = p.round;
+                this.findingsTotal = p.total;
+                this.findingsBlocking = p.blocking;
+                // Keep the per-round history too: the header tally is the latest round,
+                // but the trajectory across rounds is what shows the loop converging.
+                const tally = { round: p.round, findings: p.total, blocking: p.blocking };
+                const existing = this.rounds.findIndex((r) => r.round === p.round);
+                if (existing >= 0)
+                    this.rounds[existing] = tally;
+                else
+                    this.rounds.push(tally);
+                break;
+            }
+            case "done": {
+                this.stopReason = p.stopReason;
+                const failed = p.stopReason === "failed" || p.stopReason === "aborted";
+                for (const a of this.agents) {
+                    if (a.status === "active") {
+                        a.status = failed ? "failed" : "done";
+                        a.endedAt = at;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Fold one curated line. Narration becomes the emitting agent's summary;
+     * actions ride BOTH the agent's own list and the terminal's flat ring buffer.
+     */
+    applyLine(line, tag, at = 0) {
+        const target = this.ensureAgent(tag.stageId, tag.lens, tag.round, at);
+        if (line.kind === "narration") {
+            target.summary = line.text;
+            return;
+        }
+        if (line.state === "running") {
+            target.actions.push({
+                ...(line.toolCallId !== undefined ? { toolCallId: line.toolCallId } : {}),
+                text: line.text,
+                state: "running",
+            });
+            if (target.actions.length > AGENT_ACTION_WINDOW)
+                target.actions.shift();
+            return;
+        }
+        // A resolving end: update the matching running entry in place.
+        if (line.toolCallId === undefined)
+            return;
+        const mine = target.actions.find((a) => a.toolCallId === line.toolCallId);
+        if (mine)
+            mine.state = line.state;
+    }
+    /** Fold an assistant turn's usage into the emitting agent. Ignores everything else. */
+    applyUsage(ev, tag, at = 0) {
+        if (ev.type !== "message_end" || ev.message?.role !== "assistant")
+            return;
+        const target = this.ensureAgent(tag.stageId, tag.lens, tag.round, at);
+        target.usage.turns += 1;
+        const u = ev.message.usage;
+        if (!u)
+            return;
+        target.usage.input += u.input ?? 0;
+        target.usage.output += u.output ?? 0;
+        target.usage.cacheRead += u.cacheRead ?? 0;
+        target.usage.cacheWrite += u.cacheWrite ?? 0;
+        target.usage.cost += u.cost?.total ?? 0;
+    }
+    /** Stamp the run's end. Separate from `done` because FINISH runs after the pipeline returns. */
+    markEnded(at) {
+        this.endedAt = at;
+    }
+    /**
+     * Record the backend's run UUID once `openFreshRun` resolves (goCommand.ts,
+     * a beat after the run starts — never known at construction). The caller is
+     * responsible for repainting immediately after this so the desktop learns
+     * it as soon as possible rather than on the next debounced paint.
+     */
+    setServerRunId(id) {
+        this.serverRunId = id;
+    }
+    // ---- Terminal renderer accessors (never serialized) ----------------------
+    /**
+     * Stage rows for the panel: one row per stage, in order. Lens children are the
+     * desktop's business alone, and a looped stage that re-executes per round
+     * (fix) paints its LATEST round's node so the row shows the live execution,
+     * not a stale bare placeholder.
+     */
+    stageAgents() {
+        return STAGE_ORDER.flatMap((id) => {
+            const perRound = this.agents.filter((a) => a.stageId === id && a.lens === undefined && a.id !== id);
+            const row = perRound[perRound.length - 1] ?? this.stageAgent(id);
+            return row ? [row] : [];
+        });
+    }
+    header() {
+        return {
+            ticket: this.ticket,
+            round: this.round,
+            findingsTotal: this.findingsTotal,
+            findingsBlocking: this.findingsBlocking,
+        };
+    }
+    // ---- Wire record ---------------------------------------------------------
+    /** Named `toJSON` so `JSON.stringify(run)` yields the wire shape directly. */
+    toJSON() {
+        return {
+            v: 1,
+            runId: this.runId,
+            ticket: this.ticket,
+            round: this.round,
+            findingsTotal: this.findingsTotal,
+            findingsBlocking: this.findingsBlocking,
+            rounds: this.rounds,
+            startedAt: this.startedAt,
+            ...(this.endedAt !== undefined ? { endedAt: this.endedAt } : {}),
+            ...(this.stopReason ? { stopReason: this.stopReason } : {}),
+            agents: this.agents,
+            ...(this.serverRunId !== undefined ? { serverRunId: this.serverRunId } : {}),
+        };
+    }
+}
+//# sourceMappingURL=runState.js.map

package/dist/extension/pipeline/runner.d.ts

@@ -0,0 +1,98 @@
+/**
+ * THIN, IMPURE per-stage spawn-runner — lifted almost verbatim from the pi
+ * subagent example's `runSingleAgent` (index.ts L267-429).
+ *
+ * It writes the grounded persona body to a 0600 temp file, builds the grounded
+ * child argv, spawns ONE pi child, line-buffers the stdout NDJSON, delegates all
+ * parsing to `events.ts`, applies `PER_TASK_OUTPUT_CAP`, wires abort
+ * (SIGTERM then SIGKILL after 5s if the child has not really exited), and cleans
+ * up the temp file.
+ *
+ * v1 spawns `pi` directly (NOT the `yagni-code` launcher) and re-injects
+ * `-e <self> --provider yagni`, inheriting the parent's env (token / base URL /
+ * agent dir). This avoids a yagni-code-cli ↔ pi-extension-yagni circular
+ * dependency — see the blueprint risks.
+ *
+ * ALL impurity sits behind injectable seams (`spawn`, `writePrompt`,
+ * `resolveChild`) so the runner is unit-tested with a fake spawn emitting canned
+ * NDJSON — no real process, no model, no network. The live end-to-end run is
+ * Jack dogfood, not CI.
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import { type JsonEvent, type PipelineStage, type ReviewLens, type StageResult } from "./types.js";
+/** Injectable seams so the runner is unit-testable without fs / process / net. */
+export interface RunStageDeps {
+    cwd: string;
+    signal?: AbortSignal;
+    spawn?: typeof nodeSpawn;
+    writePrompt?: (body: string) => Promise<{
+        filePath: string;
+        cleanup: () => void;
+    }>;
+    resolveChild?: () => {
+        piCli: string;
+        extensionPath: string;
+    };
+    /** Optional environment for spawned child stages. Defaults to Node's inherited env. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * YAG-471 attribution: the tracked run's server-assigned id (a UUID), sent to
+     * the child as `YAGNI_RUN_ID` so the model proxy's `x-yagni-run-id` header
+     * wins over the session id for `llm_usage.session_id`. Absent when the run is
+     * untracked (recording disabled/failed) — the child still gets a caller
+     * label, just not a run id; attribution degrades gracefully rather than
+     * blocking anything.
+     */
+    attribution?: {
+        runId?: string;
+    };
+    /**
+     * YAG-471 attribution: the child's caller label, sent as `YAGNI_CALLER` (the
+     * model proxy's `x-yagni-caller` header). Defaults to `go:<stage.id>` (or
+     * `go:<stage.id>:<lens>` for a fanned-out review lens) when absent, so the
+     * /go pipeline's own stage loop never has to set this explicitly. The
+     * subagent tool and the advisor pass their own label through this seam.
+     */
+    callerLabel?: string;
+    /**
+     * Additive live tap: invoked once per parsed NDJSON event, in stream order,
+     * right after it is buffered for the reducers. PURE side-channel for the
+     * activity feed — it changes nothing about buffering, capping, abort, or the
+     * StageResult reduction, and a headless run simply omits it.
+     */
+    onEvent?: (ev: JsonEvent) => void;
+    /**
+     * Max bytes for a single stdout (NDJSON) line before it is discarded. Guards
+     * against a pathological runaway line growing `buffer` without bound and
+     * OOM-crashing the harness. Defaults to {@link DEFAULT_MAX_STDOUT_LINE_BYTES};
+     * tests inject a small value.
+     */
+    maxLineBytes?: number;
+    /**
+     * System-prompt body builder override. The general subagent tool injects
+     * custom agent bodies (from .claude/agents files) through this seam; /go's
+     * stages keep the default grounded personas.
+     */
+    personaBody?: (stage: PipelineStage, opts: {
+        grounded?: boolean;
+    }) => string;
+}
+/**
+ * Default per-line stdout ceiling (16 MiB). A legitimate NDJSON event — even one
+ * carrying a large tool payload — is far below this; a line beyond it is a
+ * runaway/garbage line, dropped rather than accumulated. Keeps the stdout reader
+ * O(n) and memory-bounded (a single ~GB line previously OOM-crashed `runStage`).
+ */
+export declare const DEFAULT_MAX_STDOUT_LINE_BYTES: number;
+/**
+ * Run one grounded child stage and reduce its NDJSON stream into a StageResult.
+ * `ctx.lens` (when set, for a fanned-out review) selects the lens clause in the
+ * persona body and is threaded through the invocation builder.
+ */
+export declare function runStage(stage: PipelineStage, ctx: {
+    ticket: string;
+    previous?: string;
+    lens?: ReviewLens;
+    grounded?: boolean;
+}, deps: RunStageDeps): Promise<StageResult>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/extension/pipeline/runner.js

@@ -0,0 +1,310 @@
+/**
+ * THIN, IMPURE per-stage spawn-runner — lifted almost verbatim from the pi
+ * subagent example's `runSingleAgent` (index.ts L267-429).
+ *
+ * It writes the grounded persona body to a 0600 temp file, builds the grounded
+ * child argv, spawns ONE pi child, line-buffers the stdout NDJSON, delegates all
+ * parsing to `events.ts`, applies `PER_TASK_OUTPUT_CAP`, wires abort
+ * (SIGTERM then SIGKILL after 5s if the child has not really exited), and cleans
+ * up the temp file.
+ *
+ * v1 spawns `pi` directly (NOT the `yagni-code` launcher) and re-injects
+ * `-e <self> --provider yagni`, inheriting the parent's env (token / base URL /
+ * agent dir). This avoids a yagni-code-cli ↔ pi-extension-yagni circular
+ * dependency — see the blueprint risks.
+ *
+ * ALL impurity sits behind injectable seams (`spawn`, `writePrompt`,
+ * `resolveChild`) so the runner is unit-tested with a fake spawn emitting canned
+ * NDJSON — no real process, no model, no network. The live end-to-end run is
+ * Jack dogfood, not CI.
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { finalOutputFrom, foldEvent, newEventAccumulator } from "./events.js";
+import { buildStageInvocation, groundedChildArgv } from "./invocation.js";
+import { personaBody } from "./personas.js";
+import { PER_TASK_OUTPUT_CAP, } from "./types.js";
+/**
+ * Default per-line stdout ceiling (16 MiB). A legitimate NDJSON event — even one
+ * carrying a large tool payload — is far below this; a line beyond it is a
+ * runaway/garbage line, dropped rather than accumulated. Keeps the stdout reader
+ * O(n) and memory-bounded (a single ~GB line previously OOM-crashed `runStage`).
+ */
+export const DEFAULT_MAX_STDOUT_LINE_BYTES = 16 * 1024 * 1024;
+/** Default: write the persona body to a private (0600) temp file. */
+async function defaultWritePrompt(body) {
+    const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "yagni-pipeline-"));
+    const filePath = path.join(dir, "persona.md");
+    await fs.promises.writeFile(filePath, body, { encoding: "utf-8", mode: 0o600 });
+    const cleanup = () => {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            fs.rmdirSync(dir);
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    return { filePath, cleanup };
+}
+/**
+ * Default child resolution: the parent process IS pi (so `process.argv[1]` is
+ * pi's cli), and our compiled extension entry sits one dir up from this module.
+ */
+function defaultResolveChild() {
+    const piCli = process.argv[1] ?? "pi";
+    const extensionPath = fileURLToPath(new URL("../index.js", import.meta.url));
+    return { piCli, extensionPath };
+}
+const EMPTY_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+/** Truncate to PER_TASK_OUTPUT_CAP bytes, never exceeding the cap. */
+function capOutput(output) {
+    if (Buffer.byteLength(output, "utf8") <= PER_TASK_OUTPUT_CAP)
+        return output;
+    let truncated = output.slice(0, PER_TASK_OUTPUT_CAP);
+    while (Buffer.byteLength(truncated, "utf8") > PER_TASK_OUTPUT_CAP) {
+        truncated = truncated.slice(0, -1);
+    }
+    return truncated;
+}
+/**
+ * Run one grounded child stage and reduce its NDJSON stream into a StageResult.
+ * `ctx.lens` (when set, for a fanned-out review) selects the lens clause in the
+ * persona body and is threaded through the invocation builder.
+ */
+export async function runStage(stage, ctx, deps) {
+    const spawnFn = deps.spawn ?? nodeSpawn;
+    const writePrompt = deps.writePrompt ?? defaultWritePrompt;
+    const resolveChild = deps.resolveChild ?? defaultResolveChild;
+    const personaStage = ctx.lens ? { ...stage, lens: ctx.lens } : stage;
+    // grounded defaults true; only the M6 blind eval lane passes grounded: false.
+    const body = (deps.personaBody ?? personaBody)(personaStage, { grounded: ctx.grounded !== false });
+    const { filePath, cleanup } = await writePrompt(body);
+    const result = {
+        stageId: stage.id,
+        agent: stage.agent,
+        exitCode: 0,
+        finalOutput: "",
+        usage: { ...EMPTY_USAGE },
+        stderr: "",
+        toolCalls: 0,
+        toolErrors: 0,
+    };
+    try {
+        const passthrough = buildStageInvocation(stage, {
+            ticket: ctx.ticket,
+            previous: ctx.previous,
+            promptFilePath: filePath,
+            lens: ctx.lens,
+        });
+        const { piCli, extensionPath } = resolveChild();
+        const argv = groundedChildArgv(passthrough, { piCli, extensionPath });
+        // Fold events into a fixed-size accumulator as they stream — never retain
+        // the full array (that OOMs on a verbose stage; YAG-317 follow-up).
+        const acc = newEventAccumulator();
+        let eventCount = 0;
+        let stderr = "";
+        let wasAborted = false;
+        const maxLineBytes = deps.maxLineBytes ?? DEFAULT_MAX_STDOUT_LINE_BYTES;
+        let overlongLinesDropped = 0;
+        // Env-gated diagnostic (no-op unless YAGNI_PIPELINE_DEBUG_DIR set). Captures
+        // per-stage stream metrics — total bytes, max single NDJSON line, event count,
+        // interim heap — plus the full final output. Used to characterise the plan
+        // `length` truncation and the implement-stage OOM. Safe to leave in.
+        const DEBUG_DIR = process.env.YAGNI_PIPELINE_DEBUG_DIR;
+        const dbgLabel = ctx.lens ? `${stage.id}-${ctx.lens}` : stage.id;
+        let dbgTotalBytes = 0, dbgMaxLineBytes = 0, dbgLineCount = 0, dbgLastLogBytes = 0;
+        const dbgLog = (note) => {
+            if (!DEBUG_DIR)
+                return;
+            try {
+                fs.mkdirSync(DEBUG_DIR, { recursive: true });
+                const m = process.memoryUsage();
+                fs.appendFileSync(path.join(DEBUG_DIR, `${dbgLabel}.stream.log`), `${new Date().toISOString()} ${note} bytes=${dbgTotalBytes} maxLineBytes=${dbgMaxLineBytes} lines=${dbgLineCount} events=${eventCount} heapUsedMB=${Math.round(m.heapUsed / 1048576)} rssMB=${Math.round(m.rss / 1048576)}\n`);
+            }
+            catch { /* ignore */ }
+        };
+        // YAG-471 attribution: every child builds its OWN provider config at init
+        // (reading its own env), so a per-child env var becomes a per-child header.
+        // The caller label defaults from the stage/lens being run; a run id is
+        // included only when the caller (the orchestrator, once its run is tracked)
+        // supplied one — its absence just means this child's completions attribute
+        // to the session id alone.
+        const callerLabel = deps.callerLabel ?? (ctx.lens ? `go:${stage.id}:${ctx.lens}` : `go:${stage.id}`);
+        const childEnv = {
+            ...(deps.env ?? process.env),
+            YAGNI_CALLER: callerLabel,
+            ...(deps.attribution?.runId ? { YAGNI_RUN_ID: deps.attribution.runId } : {}),
+        };
+        const exitCode = await new Promise((resolve) => {
+            const proc = spawnFn(process.execPath, argv, {
+                cwd: deps.cwd,
+                env: childEnv,
+                shell: false,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let buffer = "";
+            // `overlong` = we are mid-way through a line that already blew the cap; we
+            // discard incoming bytes until its terminating newline, then drop the line.
+            let overlong = false;
+            const processLine = (line) => {
+                if (DEBUG_DIR) {
+                    const b = Buffer.byteLength(line, "utf8");
+                    if (b > dbgMaxLineBytes)
+                        dbgMaxLineBytes = b;
+                    dbgLineCount++;
+                }
+                if (!line.trim())
+                    return;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                foldEvent(acc, event);
+                eventCount += 1;
+                deps.onEvent?.(event);
+            };
+            // Track real process exit explicitly. `ChildProcess.killed` is set the
+            // instant a signal is *sent*, not when the process exits — so it cannot
+            // gate the SIGKILL escalation (it is already true after SIGTERM). This
+            // flag flips only on the real `close`/`error`, so a child that ignores
+            // SIGTERM still gets force-killed after the grace window.
+            const signal = deps.signal;
+            let closed = false;
+            let killTimer;
+            const onAbort = () => {
+                wasAborted = true;
+                // pid guard: kill() on a child whose spawn FAILED resolves to pid 0 —
+                // the whole process group — and would take the parent down with it.
+                if (proc.pid)
+                    proc.kill("SIGTERM");
+                killTimer = setTimeout(() => {
+                    if (!closed && proc.pid)
+                        proc.kill("SIGKILL");
+                }, 5000);
+                killTimer.unref?.();
+            };
+            const finish = (code) => {
+                closed = true;
+                if (killTimer)
+                    clearTimeout(killTimer);
+                // Detach the abort listener on normal completion so it does not
+                // accumulate on the shared, long-lived pipeline signal across stages.
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+                resolve(code);
+            };
+            proc.stdout?.on("data", (data) => {
+                const s = data.toString();
+                if (DEBUG_DIR) {
+                    dbgTotalBytes += Buffer.byteLength(s, "utf8");
+                    if (dbgTotalBytes - dbgLastLogBytes > 20_000_000) {
+                        dbgLastLogBytes = dbgTotalBytes;
+                        dbgLog("stream");
+                    }
+                }
+                // Incremental newline scan — never re-split a growing buffer (that was
+                // O(n²) and OOM-crashed on a runaway single line). `buffer` only ever
+                // holds the current *partial* line, and is capped at maxLineBytes: an
+                // over-cap line is dropped, not accumulated.
+                let start = 0;
+                for (;;) {
+                    const nl = s.indexOf("\n", start);
+                    if (nl === -1) {
+                        if (!overlong) {
+                            buffer += s.slice(start);
+                            if (buffer.length > maxLineBytes) {
+                                overlong = true;
+                                buffer = "";
+                            }
+                        }
+                        break;
+                    }
+                    const seg = s.slice(start, nl);
+                    start = nl + 1;
+                    if (overlong) {
+                        overlong = false;
+                        overlongLinesDropped += 1;
+                        continue;
+                    }
+                    const line = buffer + seg;
+                    buffer = "";
+                    if (line.length > maxLineBytes) {
+                        overlongLinesDropped += 1;
+                        continue;
+                    }
+                    processLine(line);
+                }
+            });
+            proc.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("close", (code) => {
+                if (overlong) {
+                    overlongLinesDropped += 1;
+                    overlong = false;
+                    buffer = "";
+                }
+                else if (buffer.trim())
+                    processLine(buffer);
+                finish(code ?? 0);
+            });
+            proc.on("error", () => finish(1));
+            if (signal) {
+                if (signal.aborted)
+                    onAbort();
+                else
+                    signal.addEventListener("abort", onAbort);
+            }
+        });
+        result.exitCode = exitCode;
+        result.stderr = stderr;
+        result.finalOutput = capOutput(finalOutputFrom(acc));
+        result.usage = acc.usage;
+        // R3-a: tap tool-result counts into stage health. The orchestrator turns
+        // this ratio into a write-stage failure when most edits errored, so a
+        // clean-looking summary can't mask a silent partial implement.
+        result.toolCalls = acc.toolCalls;
+        result.toolErrors = acc.toolErrors;
+        if (acc.stopReason)
+            result.stopReason = acc.stopReason;
+        if (acc.errorMessage)
+            result.errorMessage = acc.errorMessage;
+        if (wasAborted)
+            result.stopReason = "aborted";
+        if (overlongLinesDropped > 0)
+            result.overlongLinesDropped = overlongLinesDropped;
+        if (DEBUG_DIR) {
+            try {
+                fs.mkdirSync(DEBUG_DIR, { recursive: true });
+                const finalOut = finalOutputFrom(acc);
+                fs.writeFileSync(path.join(DEBUG_DIR, `${dbgLabel}.summary.json`), JSON.stringify({
+                    stageId: stage.id, lens: ctx.lens, exitCode,
+                    stopReason: result.stopReason, usage: result.usage,
+                    events_count: eventCount, total_stream_bytes: dbgTotalBytes,
+                    max_line_bytes: dbgMaxLineBytes, line_count: dbgLineCount,
+                    final_output_bytes: Buffer.byteLength(finalOut, "utf8"),
+                    final_output: finalOut,
+                }, null, 2));
+                dbgLog("stage_end");
+            }
+            catch { /* ignore */ }
+        }
+        return result;
+    }
+    finally {
+        cleanup();
+    }
+}
+//# sourceMappingURL=runner.js.map