npm - @yagni-app/code-staging - Versions diffs - 0.0.0 → 0.1.0-staging.1002.1 - Mend

@yagni-app/code-staging 0.0.0 → 0.1.0-staging.1002.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (147) hide show

package/LICENSE.md +55 -0
package/README.md +166 -0
package/dist/branding.d.ts +25 -0
package/dist/branding.js +27 -0
package/dist/claudeCompat.d.ts +78 -0
package/dist/claudeCompat.js +198 -0
package/dist/cli.d.ts +55 -0
package/dist/cli.js +326 -0
package/dist/config.d.ts +19 -0
package/dist/config.js +28 -0
package/dist/credentials.d.ts +41 -0
package/dist/credentials.js +75 -0
package/dist/distribution.d.ts +15 -0
package/dist/distribution.js +45 -0
package/dist/doctor.d.ts +94 -0
package/dist/doctor.js +343 -0
package/dist/extension/advisor.d.ts +84 -0
package/dist/extension/advisor.js +101 -0
package/dist/extension/askAdvisorTool.d.ts +83 -0
package/dist/extension/askAdvisorTool.js +188 -0
package/dist/extension/askYagniTool.d.ts +39 -0
package/dist/extension/askYagniTool.js +63 -0
package/dist/extension/bless.d.ts +45 -0
package/dist/extension/bless.js +74 -0
package/dist/extension/branding.d.ts +48 -0
package/dist/extension/branding.js +119 -0
package/dist/extension/chipEditor.d.ts +117 -0
package/dist/extension/chipEditor.js +369 -0
package/dist/extension/config.d.ts +112 -0
package/dist/extension/config.js +108 -0
package/dist/extension/costHud.d.ts +73 -0
package/dist/extension/costHud.js +123 -0
package/dist/extension/decisionCapture.d.ts +52 -0
package/dist/extension/decisionCapture.js +66 -0
package/dist/extension/decisions.d.ts +83 -0
package/dist/extension/decisions.js +200 -0
package/dist/extension/diagnostics.d.ts +41 -0
package/dist/extension/diagnostics.js +110 -0
package/dist/extension/index.d.ts +116 -0
package/dist/extension/index.js +388 -0
package/dist/extension/initDone.d.ts +28 -0
package/dist/extension/initDone.js +66 -0
package/dist/extension/initPass.d.ts +152 -0
package/dist/extension/initPass.js +394 -0
package/dist/extension/nextWorkTool.d.ts +51 -0
package/dist/extension/nextWorkTool.js +80 -0
package/dist/extension/permission.d.ts +91 -0
package/dist/extension/permission.js +236 -0
package/dist/extension/pipeline/activity.d.ts +37 -0
package/dist/extension/pipeline/activity.js +151 -0
package/dist/extension/pipeline/activityFeed.d.ts +59 -0
package/dist/extension/pipeline/activityFeed.js +175 -0
package/dist/extension/pipeline/budget.d.ts +48 -0
package/dist/extension/pipeline/budget.js +68 -0
package/dist/extension/pipeline/checkpoint.d.ts +31 -0
package/dist/extension/pipeline/checkpoint.js +176 -0
package/dist/extension/pipeline/eval.d.ts +168 -0
package/dist/extension/pipeline/eval.js +182 -0
package/dist/extension/pipeline/events.d.ts +56 -0
package/dist/extension/pipeline/events.js +147 -0
package/dist/extension/pipeline/findings.d.ts +42 -0
package/dist/extension/pipeline/findings.js +144 -0
package/dist/extension/pipeline/finish.d.ts +128 -0
package/dist/extension/pipeline/finish.js +307 -0
package/dist/extension/pipeline/goCommand.d.ts +128 -0
package/dist/extension/pipeline/goCommand.js +972 -0
package/dist/extension/pipeline/goCompareCommand.d.ts +48 -0
package/dist/extension/pipeline/goCompareCommand.js +184 -0
package/dist/extension/pipeline/goFlags.d.ts +40 -0
package/dist/extension/pipeline/goFlags.js +46 -0
package/dist/extension/pipeline/goStatusCommands.d.ts +59 -0
package/dist/extension/pipeline/goStatusCommands.js +188 -0
package/dist/extension/pipeline/invocation.d.ts +45 -0
package/dist/extension/pipeline/invocation.js +64 -0
package/dist/extension/pipeline/orchestrator.d.ts +131 -0
package/dist/extension/pipeline/orchestrator.js +636 -0
package/dist/extension/pipeline/personas.d.ts +44 -0
package/dist/extension/pipeline/personas.js +248 -0
package/dist/extension/pipeline/resilience.d.ts +85 -0
package/dist/extension/pipeline/resilience.js +166 -0
package/dist/extension/pipeline/resume.d.ts +18 -0
package/dist/extension/pipeline/resume.js +106 -0
package/dist/extension/pipeline/runRegistry.d.ts +112 -0
package/dist/extension/pipeline/runRegistry.js +202 -0
package/dist/extension/pipeline/runSession.d.ts +152 -0
package/dist/extension/pipeline/runSession.js +167 -0
package/dist/extension/pipeline/runState.d.ts +158 -0
package/dist/extension/pipeline/runState.js +264 -0
package/dist/extension/pipeline/runner.d.ts +79 -0
package/dist/extension/pipeline/runner.js +298 -0
package/dist/extension/pipeline/scrubSecrets.d.ts +15 -0
package/dist/extension/pipeline/scrubSecrets.js +32 -0
package/dist/extension/pipeline/stages.d.ts +51 -0
package/dist/extension/pipeline/stages.js +113 -0
package/dist/extension/pipeline/ticketResolution.d.ts +34 -0
package/dist/extension/pipeline/ticketResolution.js +75 -0
package/dist/extension/pipeline/types.d.ts +436 -0
package/dist/extension/pipeline/types.js +48 -0
package/dist/extension/pipeline/verify.d.ts +277 -0
package/dist/extension/pipeline/verify.js +758 -0
package/dist/extension/pipeline/workspace.d.ts +32 -0
package/dist/extension/pipeline/workspace.js +73 -0
package/dist/extension/pipeline/worktree.d.ts +107 -0
package/dist/extension/pipeline/worktree.js +200 -0
package/dist/extension/provider.d.ts +11 -0
package/dist/extension/provider.js +26 -0
package/dist/extension/recall.d.ts +93 -0
package/dist/extension/recall.js +187 -0
package/dist/extension/recordContextTool.d.ts +38 -0
package/dist/extension/recordContextTool.js +85 -0
package/dist/extension/recordDecisionTool.d.ts +52 -0
package/dist/extension/recordDecisionTool.js +102 -0
package/dist/extension/repoDocs.d.ts +81 -0
package/dist/extension/repoDocs.js +260 -0
package/dist/extension/resilientFetch.d.ts +60 -0
package/dist/extension/resilientFetch.js +133 -0
package/dist/extension/reviewTool.d.ts +34 -0
package/dist/extension/reviewTool.js +81 -0
package/dist/extension/spool.d.ts +92 -0
package/dist/extension/spool.js +266 -0
package/dist/extension/stateHome.d.ts +2 -0
package/dist/extension/stateHome.js +6 -0
package/dist/extension/subagents.d.ts +135 -0
package/dist/extension/subagents.js +281 -0
package/dist/extension/surface.d.ts +10 -0
package/dist/extension/surface.js +12 -0
package/dist/extension/todos.d.ts +110 -0
package/dist/extension/todos.js +217 -0
package/dist/extension/tokenProvider.d.ts +93 -0
package/dist/extension/tokenProvider.js +234 -0
package/dist/launch.d.ts +76 -0
package/dist/launch.js +111 -0
package/dist/login.d.ts +45 -0
package/dist/login.js +142 -0
package/dist/logout.d.ts +14 -0
package/dist/logout.js +34 -0
package/dist/paths.d.ts +31 -0
package/dist/paths.js +87 -0
package/dist/piPackage.d.ts +33 -0
package/dist/piPackage.js +71 -0
package/dist/profiles.d.ts +80 -0
package/dist/profiles.js +222 -0
package/dist/refresh.d.ts +70 -0
package/dist/refresh.js +117 -0
package/dist/upgrade.d.ts +97 -0
package/dist/upgrade.js +284 -0
package/package.json +39 -3

package/dist/extension/pipeline/runSession.js ADDED Viewed

@@ -0,0 +1,167 @@
+/**
+ * The `/go` run-session adapter.
+ *
+ * Wraps the device-token `/api/yagni-code/runs*` endpoints so a YAGNI Code
+ * pipeline run becomes a tracked `runs` row visible on the Work page: open the
+ * run (`start`), stream each pipeline stage (`stage`), bank an in-loop
+ * correction (`correction`), and close it with an honest outcome (`finish`).
+ *
+ * CRITICAL invariant: recording must NEVER break the pipeline. Every call is
+ * fail-soft — it never throws. `start` resolves to a typed outcome that
+ * distinguishes a tracked run from an untracked one (flag off, unauthorized, or
+ * the backend unreachable/erroring) so the caller can surface a notice instead
+ * of failing silently; the post-start verbs (`stage`/`correction`/`finish`) stay
+ * silent no-ops. `/go` runs to completion regardless of the recording outcome.
+ *
+ * Mirrors the fetch-seam shape of {@link makeRecordEngineeringContextTool}
+ * (`baseUrl` + injectable `getToken` + `fetchImpl`) so it is unit-testable
+ * without a network and reuses the same auth convention.
+ */
+import { randomUUID } from "node:crypto";
+import { DEFAULT_FETCH_POLICY, METERED_POST_FETCH_POLICY, resilientFetch, } from "../resilientFetch.js";
+/** Map a failed POST's HTTP status onto a user-facing tracking-failure reason. */
+function failureReason(status) {
+    if (status === 404)
+        return "disabled";
+    if (status === 401 || status === 403)
+        return "unauthorized";
+    return "error";
+}
+/** Cap a debug body excerpt so a giant HTML/JSON error never floods the channel. */
+const MAX_DEBUG_BODY = 200;
+/**
+ * A token-free, capped `: <body>` suffix for a failed-response debug line. Reads
+ * the body only on the `!res.ok` branch (where `post` never reads it otherwise,
+ * so there is no double-consume with the ok-path `res.json()`), and swallows any
+ * read error so observability never breaks the fail-soft contract.
+ */
+async function bodyTail(res) {
+    try {
+        const t = (await res.text()).trim();
+        if (!t)
+            return "";
+        return `: ${t.length > MAX_DEBUG_BODY ? `${t.slice(0, MAX_DEBUG_BODY)} ...` : t}`;
+    }
+    catch {
+        return "";
+    }
+}
+export function makeRunSession(opts) {
+    const f = opts.fetchImpl ?? fetch;
+    let handle = null;
+    // Opt-in observability: the default sink writes to stderr, and the `YAGNI_CODE_DEBUG`
+    // gate governs an injected sink too, so callers that pass neither stay silent. The
+    // resolved sink is wrapped so it can NEVER throw out of `debug`: an injected sink
+    // that throws must not breach the fail-soft never-throw contract (in the `!res.ok`
+    // branch an unguarded throw would land in the surrounding catch and re-fire debug,
+    // escaping `post` and rejecting the recording call).
+    const sink = opts.debug ??
+        ((line) => {
+            try {
+                process.stderr.write(`${line}\n`);
+            }
+            catch {
+                /* never break recording */
+            }
+        });
+    const debug = (line) => {
+        try {
+            sink(line);
+        }
+        catch {
+            /* observability never breaks recording */
+        }
+    };
+    const debugOn = !!(opts.env ?? process.env).YAGNI_CODE_DEBUG;
+    // A run-open (`start`) is the one recording call worth retrying: if it is lost,
+    // the WHOLE run goes untracked. It is made replay-safe by an idempotency key (the
+    // server dedups a re-sent create), so it uses the retrying policy. Every other
+    // verb is append-only / terminal and stays single-attempt (METERED) so a recorded
+    // judgment (a correction) is never duplicated by a client replay.
+    const post = async (path, body, postOpts = {}) => {
+        try {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/${path}`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify(body),
+            }, {
+                fetchImpl: f,
+                policy: postOpts.retry ? DEFAULT_FETCH_POLICY : METERED_POST_FETCH_POLICY,
+                ...(opts.sleep ? { sleep: opts.sleep } : {}),
+                ...(opts.random ? { random: opts.random } : {}),
+            });
+            if (!res.ok) {
+                if (debugOn)
+                    debug(`[yagni-code] run-record ${path} -> HTTP ${res.status}${await bodyTail(res)}`);
+                return { ok: false, status: res.status };
+            }
+            return { ok: true, data: (await res.json()) };
+        }
+        catch (err) {
+            // fail-soft: recording must never break the pipeline (no status = unreachable
+            // after retries).
+            if (debugOn) {
+                debug(`[yagni-code] run-record ${path} unreachable: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return { ok: false };
+        }
+    };
+    return {
+        bind(h) {
+            handle = h;
+        },
+        async start(b) {
+            // One idempotency key per open attempt: resilientFetch replays the SAME
+            // request body across retries, so a create whose 201 was lost to a blip is
+            // deduped by the server (startCodeRun.findRunByIdempotencyKey) instead of
+            // opening a second run + a second free-text work item.
+            const r = await post("runs", { ...b, idempotencyKey: randomUUID() }, { retry: true });
+            if (!r.ok)
+                return { tracked: false, reason: failureReason(r.status) };
+            const data = r.data;
+            if (typeof data.runId === "string" && typeof data.workItemId === "string") {
+                handle = { runId: data.runId, workItemId: data.workItemId };
+                return {
+                    tracked: true,
+                    runId: handle.runId,
+                    workItemId: handle.workItemId,
+                    gated: data.gated === true,
+                    gatedReason: typeof data.gatedReason === "string" ? data.gatedReason : undefined,
+                };
+            }
+            // A 2xx with an unrecognized body: we can't bind a handle, so it's untracked.
+            if (debugOn)
+                debug("[yagni-code] run-record runs -> 2xx but body had no runId/workItemId");
+            return { tracked: false, reason: "error" };
+        },
+        async stage(b) {
+            if (!handle)
+                return;
+            await post(`runs/${handle.runId}/stages`, { ...b, workItemId: handle.workItemId });
+        },
+        async correction(b) {
+            if (!handle)
+                return;
+            await post(`runs/${handle.runId}/correction`, { ...b, workItemId: handle.workItemId });
+        },
+        async recordPlan(b) {
+            if (!handle)
+                return;
+            await post(`runs/${handle.runId}/plan`, { ...b, workItemId: handle.workItemId });
+        },
+        async heartbeat() {
+            if (!handle)
+                return;
+            await post(`runs/${handle.runId}/heartbeat`, { workItemId: handle.workItemId });
+        },
+        async finish(b) {
+            if (!handle)
+                return;
+            await post(`runs/${handle.runId}/finish`, { ...b, workItemId: handle.workItemId });
+        },
+    };
+}
+//# sourceMappingURL=runSession.js.map

package/dist/extension/pipeline/runState.d.ts ADDED Viewed

@@ -0,0 +1,158 @@
+/**
+ * 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.
+ */
+import type { ActivityLine, FeedStageId, JsonEvent, PipelineProgress, ReviewLens, StageTag, StopReason } from "./types.js";
+/** The fixed stage order shown by both surfaces (v1 stages + the post-loop FINISH row). */
+export declare const STAGE_ORDER: FeedStageId[];
+/**
+ * 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 declare const AGENT_ACTION_WINDOW = 40;
+export type AgentStatus = "pending" | "active" | "done" | "failed";
+export interface AgentAction {
+    toolCallId?: string;
+    text: string;
+    state: "running" | "done" | "error";
+}
+export interface AgentUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+    turns: number;
+}
+export interface AgentNode {
+    /**
+     * Stable across paints: the stage id, `review:<lens>:r<round>` for a lens
+     * child, or `fix:r<round>` for a per-round fix execution.
+     */
+    id: string;
+    stageId: FeedStageId;
+    lens?: ReviewLens;
+    round?: number;
+    status: AgentStatus;
+    summary: string;
+    startedAt?: number;
+    endedAt?: number;
+    actions: AgentAction[];
+    usage: AgentUsage;
+    /** Per-lens finding counts, attached when the round's parse loop resolves this lens. */
+    findings?: number;
+    blocking?: number;
+    /** Why this lens could not fully carry the round (spec §3e). */
+    degraded?: "failed" | "unparseable";
+}
+/**
+ * One completed round's finding tally, kept as history rather than overwritten:
+ * the trajectory (blocking 6 → 5 → 5) is what tells whether the loop converged.
+ */
+export interface RoundTally {
+    round: number;
+    findings: number;
+    blocking: number;
+}
+/**
+ * The wire record. Deliberately carries NO local-only fields — no worktree paths,
+ * no pids, no absolute paths — so it stays portable to a non-local executor at
+ * zero cost. The tab does not need them.
+ */
+export interface GoRunState {
+    v: 1;
+    runId: string;
+    ticket: string;
+    round: number;
+    findingsTotal: number;
+    findingsBlocking: number;
+    rounds: RoundTally[];
+    startedAt: number;
+    endedAt?: number;
+    stopReason?: StopReason;
+    agents: AgentNode[];
+}
+/**
+ * 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 declare function agentId(stageId: FeedStageId, lens?: ReviewLens, round?: number): string;
+export interface RunStateInit {
+    runId: string;
+    ticket: string;
+    startedAt: number;
+}
+export declare class RunState {
+    private readonly runId;
+    private readonly ticket;
+    private readonly startedAt;
+    private endedAt;
+    private stopReason;
+    private round;
+    private findingsTotal;
+    private findingsBlocking;
+    private readonly rounds;
+    private readonly agents;
+    constructor(init: RunStateInit);
+    /** The lens-less stage agent, or undefined for an unknown stage. */
+    private stageAgent;
+    /**
+     * 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.
+     */
+    private ensureAgent;
+    /** Fold a structured progress signal. `at` is only read by the desktop surface. */
+    applyProgress(p: PipelineProgress, at?: number): void;
+    /**
+     * 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: ActivityLine, tag: StageTag, at?: number): void;
+    /** Fold an assistant turn's usage into the emitting agent. Ignores everything else. */
+    applyUsage(ev: JsonEvent, tag: StageTag, at?: number): void;
+    /** Stamp the run's end. Separate from `done` because FINISH runs after the pipeline returns. */
+    markEnded(at: number): void;
+    /**
+     * 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(): AgentNode[];
+    header(): {
+        ticket: string;
+        round: number;
+        findingsTotal: number;
+        findingsBlocking: number;
+    };
+    /** Named `toJSON` so `JSON.stringify(run)` yields the wire shape directly. */
+    toJSON(): GoRunState;
+}
+//# sourceMappingURL=runState.d.ts.map

package/dist/extension/pipeline/runState.js ADDED Viewed

@@ -0,0 +1,264 @@
+/**
+ * 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;
+    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;
+    }
+    // ---- 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,
+        };
+    }
+}
+//# sourceMappingURL=runState.js.map

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

@@ -0,0 +1,79 @@
+/**
+ * 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;
+    /**
+     * 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