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

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

@@ -0,0 +1,48 @@
+/**
+ * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only).
+ *
+ * It runs the same ticket through the pipeline TWICE in isolated git worktrees
+ * (so the user's tree is never touched): once grounded (the real /go) and once
+ * blind (grounding tools stripped + grounding-free personas), scores each change
+ * for business fit against this company's recorded judgment via the grounded
+ * review_business_match endpoint, and prints a comparative report.
+ *
+ * The report is the deliverable; nothing here is wired to model selection or
+ * routing. The live double-run is dogfood (it spawns real children + models), so
+ * the handler takes an injectable `compare` and the default lane/scorer seams are
+ * fail-soft. The eval engine + report formatter (eval.ts) carry the unit tests.
+ */
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { type ComparisonReport, type Lane } from "./eval.js";
+import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
+/** Which two-lane comparison a /go-compare invocation runs. */
+export type CompareMode = "grounding" | "judgment";
+export interface RegisterGoCompareDeps {
+    /** The whole eval runner, injectable so the handler is unit-tested without spawning. */
+    compare?: (ticket: string, ctx: ExtensionCommandContext, mode: CompareMode) => Promise<ComparisonReport>;
+    baseUrl?: string;
+    getToken?: () => string | undefined;
+    runPipeline?: typeof defaultRunPipeline;
+    git?: GitCommand;
+}
+/**
+ * Parse the leading `--judgment` flag. PURE.
+ *
+ * Default stays `grounding` so the existing command is byte-identical for
+ * callers who pass only a ticket.
+ */
+export declare function parseCompareArgs(args: string): {
+    mode: CompareMode;
+    ticket: string;
+};
+/**
+ * The per-lane stage list.
+ *
+ * Grounding mode strips the grounding tools from the blind lane. Judgment mode
+ * runs BOTH lanes fully grounded and varies only the plan/review tier, so the
+ * delta isolates the judgment upgrade rather than confounding it with grounding.
+ */
+export declare function stagesForLane(lane: Lane): import("./types.js").PipelineStage[];
+export type GitCommand = (args: string[], cwd: string | undefined, signal?: AbortSignal) => Promise<string>;
+export declare function registerGoCompareCommand(pi: ExtensionAPI, deps?: RegisterGoCompareDeps): void;
+//# sourceMappingURL=goCompareCommand.d.ts.map

package/dist/extension/pipeline/goCompareCommand.js

@@ -0,0 +1,184 @@
+/**
+ * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only).
+ *
+ * It runs the same ticket through the pipeline TWICE in isolated git worktrees
+ * (so the user's tree is never touched): once grounded (the real /go) and once
+ * blind (grounding tools stripped + grounding-free personas), scores each change
+ * for business fit against this company's recorded judgment via the grounded
+ * review_business_match endpoint, and prints a comparative report.
+ *
+ * The report is the deliverable; nothing here is wired to model selection or
+ * routing. The live double-run is dogfood (it spawns real children + models), so
+ * the handler takes an injectable `compare` and the default lane/scorer seams are
+ * fail-soft. The eval engine + report formatter (eval.ts) carry the unit tests.
+ */
+import { execFile } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
+import { blindStages, makeGroundedVsBlindEval, makeJudgmentTierEval, reportOnlyStages, withJudgmentTier, } from "./eval.js";
+import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
+/**
+ * Parse the leading `--judgment` flag. PURE.
+ *
+ * Default stays `grounding` so the existing command is byte-identical for
+ * callers who pass only a ticket.
+ */
+export function parseCompareArgs(args) {
+    let rest = args.trim();
+    let mode = "grounding";
+    // Accept the flag anywhere leading, so `/go-compare --judgment YAG-1` and
+    // `/go-compare YAG-1 --judgment` both work.
+    const flag = /(^|\s)--judgment(\s|$)/;
+    if (flag.test(rest)) {
+        mode = "judgment";
+        rest = rest.replace(flag, " ").trim();
+    }
+    return { mode, ticket: rest };
+}
+/**
+ * The per-lane stage list.
+ *
+ * Grounding mode strips the grounding tools from the blind lane. Judgment mode
+ * runs BOTH lanes fully grounded and varies only the plan/review tier, so the
+ * delta isolates the judgment upgrade rather than confounding it with grounding.
+ */
+export function stagesForLane(lane) {
+    switch (lane) {
+        case "blind":
+            return blindStages(reportOnlyStages());
+        case "peak_judgment":
+            return withJudgmentTier(reportOnlyStages(), "peak");
+        case "advanced_judgment":
+            return withJudgmentTier(reportOnlyStages(), "advanced");
+        default:
+            return reportOnlyStages();
+    }
+}
+/** Run a required git command in `cwd`, resolving to trimmed stdout or rejecting with stderr. */
+function defaultGit(args, cwd, signal) {
+    return new Promise((resolve, reject) => {
+        execFile("git", args, { cwd, signal, maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                const detail = stderr.toString().trim() || err.message;
+                reject(new Error(`git ${args.join(" ")} failed: ${detail}`));
+                return;
+            }
+            resolve(stdout.toString().trim());
+        });
+    });
+}
+let worktreeCounter = 0;
+/**
+ * The default eval: each lane runs in a throwaway detached worktree off HEAD, so
+ * neither pass can clobber the user's working tree or each other. The lane's diff
+ * is captured before teardown and scored by the GROUNDED review_business_match
+ * (both lanes judged by the same recorded judgment). Every step is fail-soft.
+ */
+function defaultCompare(deps) {
+    const runPipeline = deps.runPipeline ?? defaultRunPipeline;
+    const baseUrl = deps.baseUrl ?? resolveBaseUrl();
+    const getToken = deps.getToken ?? defaultGetToken;
+    const git = deps.git ?? defaultGit;
+    return (ticket, ctx, mode) => {
+        const diffs = {};
+        const evalEnv = { ...process.env, YAGNI_CODE_EVAL_MODE: "1" };
+        const runLane = async (lane) => {
+            const root = await git(["rev-parse", "--show-toplevel"], ctx.cwd, ctx.signal);
+            const base = mkdtempSync(join(tmpdir(), `yagni-eval-${lane}-${process.pid}-${worktreeCounter++}-`));
+            const tree = join(base, "wt");
+            // Detached worktree off the current HEAD; isolated from the live tree.
+            await git(["worktree", "add", "--detach", tree, "HEAD"], root, ctx.signal);
+            try {
+                const result = await runPipeline(ticket, {
+                    cwd: tree,
+                    signal: ctx.signal,
+                    // Only the blind lane runs ungrounded. Both judgment lanes stay
+                    // grounded so the delta isolates the tier, not the grounding.
+                    grounded: lane !== "blind",
+                    stages: stagesForLane(lane),
+                    childEnv: evalEnv,
+                });
+                try {
+                    diffs[lane] = await git(["diff", "HEAD"], tree, ctx.signal);
+                }
+                catch {
+                    diffs[lane] = "";
+                }
+                return result;
+            }
+            finally {
+                await git(["worktree", "remove", "--force", tree], root, ctx.signal);
+                try {
+                    rmSync(base, { recursive: true, force: true });
+                }
+                catch {
+                    /* fail-soft */
+                }
+            }
+        };
+        const scoreFit = async (lane) => {
+            const diff = (diffs[lane] ?? "").trim();
+            if (!diff)
+                return { review: "", citations: 0, conflicts: 0, note: "no diff produced by this lane" };
+            try {
+                const res = await fetch(`${baseUrl}/api/yagni-code/review`, {
+                    method: "POST",
+                    signal: ctx.signal,
+                    headers: { "content-type": "application/json", authorization: `Bearer ${getToken() ?? ""}` },
+                    body: JSON.stringify({ diff, ticket, summary: `${mode} eval (${lane} lane)` }),
+                });
+                if (!res.ok)
+                    return { review: "", citations: 0, conflicts: 0, note: `review HTTP ${res.status}` };
+                const data = (await res.json());
+                const review = typeof data.review === "string" ? data.review : "";
+                const citations = Array.isArray(data.citations) ? data.citations.length : 0;
+                // Coarse conflict signal from the prose verdict (the text is the real signal).
+                const conflicts = (review.match(/\b(conflict|contradict|mismatch|violat)/gi) ?? []).length;
+                return { review, citations, conflicts };
+            }
+            catch {
+                return { review: "", citations: 0, conflicts: 0, note: "review endpoint unreachable" };
+            }
+        };
+        const evalRunner = mode === "judgment"
+            ? makeJudgmentTierEval({ runLane, scoreFit })
+            : makeGroundedVsBlindEval({ runLane, scoreFit });
+        return evalRunner(ticket);
+    };
+}
+export function registerGoCompareCommand(pi, deps = {}) {
+    const compare = deps.compare ?? defaultCompare(deps);
+    pi.registerCommand("go-compare", {
+        description: "Eval only: run a ticket through two lane configurations in isolated worktrees and report the business-fit delta. Default compares grounded vs grounding-suppressed; --judgment compares peak vs advanced on plan+review. Never affects routing.",
+        handler: async (args, ctx) => {
+            const notify = (message, type) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, type);
+            };
+            const { mode, ticket } = parseCompareArgs(args);
+            if (!ticket) {
+                notify("Usage: /go-compare [--judgment] <ticket>", "warning");
+                return;
+            }
+            if (!ctx.isIdle()) {
+                notify("YAGNI Code is busy; wait for the current turn to finish before running /go-compare.", "warning");
+                return;
+            }
+            notify(mode === "judgment"
+                ? "Running the peak vs advanced judgment eval (two isolated passes). This takes a while."
+                : "Running the grounded vs blind eval (two isolated passes). This takes a while.", "info");
+            try {
+                const out = await compare(ticket, ctx, mode);
+                await pi.sendUserMessage(out.report);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                notify(`/go-compare failed: ${message}`, "error");
+                await pi.sendUserMessage(`/go-compare failed: ${message}`);
+            }
+        },
+    });
+}
+//# sourceMappingURL=goCompareCommand.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * PURE /go flag parsing (spec §3a — the prerequisite for detached worktree runs).
+ *
+ * There was no flag parser before this module (`/go` treated the whole remainder
+ * as the ticket). `parseGoArgs` strips the three known flags — `--here` (legacy
+ * in-place run), `--fg` (blocking foreground run), `--pr` (opt-in push + PR at
+ * FINISH) — and collects any OTHER `--flag`-shaped token as unknown so the
+ * handler can refuse with a usage warning instead of silently folding a typo'd
+ * flag into the ticket text. Everything downstream (ticket resolution,
+ * sessionKey, registry, run-row arg, ActivityFeed header, handoff copy) receives
+ * the FLAG-FREE ticket.
+ *
+ * A free-text ticket that legitimately mentions a `--something` token is the
+ * accepted trade-off: flags are only recognized in the `--word` shape, and the
+ * usage warning names the offending token so the user can rephrase.
+ */
+/** The three /go run-mode flags. All default false (worktree, detached, no PR). */
+export interface GoFlags {
+    /** Run in place in the current tree (legacy behavior) instead of a run worktree. */
+    here: boolean;
+    /** Block the prompt until the run finishes (legacy behavior) instead of detaching. */
+    fg: boolean;
+    /** Opt-in: push the run branch + open a PR at the FINISH stage. */
+    pr: boolean;
+}
+/** The parse outcome: the flag-free ticket, the flags, and any unknown --tokens. */
+export interface ParsedGoArgs {
+    ticket: string;
+    flags: GoFlags;
+    unknownFlags: string[];
+}
+/** One-line usage copy shared by the empty-ticket and unknown-flag warnings. */
+export declare const GO_USAGE = "Usage: /go <ticket> [--here] [--fg] [--pr]";
+/**
+ * Parse the raw /go remainder into the flag-free ticket + flags. Duplicate flags
+ * are idempotent; token order is irrelevant; non-flag tokens are rejoined with
+ * single spaces (the ticket is free text, not a byte-exact echo).
+ */
+export declare function parseGoArgs(raw: string): ParsedGoArgs;
+//# sourceMappingURL=goFlags.d.ts.map

package/dist/extension/pipeline/goFlags.js

@@ -0,0 +1,46 @@
+/**
+ * PURE /go flag parsing (spec §3a — the prerequisite for detached worktree runs).
+ *
+ * There was no flag parser before this module (`/go` treated the whole remainder
+ * as the ticket). `parseGoArgs` strips the three known flags — `--here` (legacy
+ * in-place run), `--fg` (blocking foreground run), `--pr` (opt-in push + PR at
+ * FINISH) — and collects any OTHER `--flag`-shaped token as unknown so the
+ * handler can refuse with a usage warning instead of silently folding a typo'd
+ * flag into the ticket text. Everything downstream (ticket resolution,
+ * sessionKey, registry, run-row arg, ActivityFeed header, handoff copy) receives
+ * the FLAG-FREE ticket.
+ *
+ * A free-text ticket that legitimately mentions a `--something` token is the
+ * accepted trade-off: flags are only recognized in the `--word` shape, and the
+ * usage warning names the offending token so the user can rephrase.
+ */
+/** One-line usage copy shared by the empty-ticket and unknown-flag warnings. */
+export const GO_USAGE = "Usage: /go <ticket> [--here] [--fg] [--pr]";
+/** A token is flag-shaped when it looks like `--word` (letters/digits/dashes). */
+const FLAG_SHAPE = /^--[A-Za-z][\w-]*$/;
+/**
+ * Parse the raw /go remainder into the flag-free ticket + flags. Duplicate flags
+ * are idempotent; token order is irrelevant; non-flag tokens are rejoined with
+ * single spaces (the ticket is free text, not a byte-exact echo).
+ */
+export function parseGoArgs(raw) {
+    const flags = { here: false, fg: false, pr: false };
+    const unknownFlags = [];
+    const ticketTokens = [];
+    for (const token of raw.trim().split(/\s+/)) {
+        if (!token)
+            continue;
+        if (token === "--here")
+            flags.here = true;
+        else if (token === "--fg")
+            flags.fg = true;
+        else if (token === "--pr")
+            flags.pr = true;
+        else if (FLAG_SHAPE.test(token))
+            unknownFlags.push(token);
+        else
+            ticketTokens.push(token);
+    }
+    return { ticket: ticketTokens.join(" "), flags, unknownFlags };
+}
+//# sourceMappingURL=goFlags.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * `/go-status` and `/go-clean` — the pull-path companions to detached /go runs
+ * (spec §3b). Registered from the pipeline's registration path (goCommand.ts
+ * calls {@link registerGoStatusCommands} with the same pi object; src/index.ts
+ * is never edited for these).
+ *
+ *  - `/go-status` lists every registry row with an honest liveness verdict:
+ *    active runs show their stage/round straight from the checkpoint journal,
+ *    finished runs show outcome + branch + commit/PR, interrupted runs say
+ *    "resumable, re-run /go <ticket>". It is the always-available fallback when
+ *    a detached completion message could not be delivered.
+ *
+ *  - `/go-clean` removes ONLY worktrees that are verifiably CLEAN (everything
+ *    committed — the WIP-commit on non-clean terminal outcomes exists exactly
+ *    so this is normally true). A dirty or unverifiable worktree is SKIPPED
+ *    with an honest note + path, never force-removed: /go-clean must be safe to
+ *    run reflexively.
+ *
+ * The line formatting is pure ({@link describeRunRow}, {@link describeJournalStage});
+ * the impure seams (registry, journal, git snapshot, worktree removal, fs
+ * exists) are injectable for tests.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type RunLiveness, type RunRegistryRow } from "./runRegistry.js";
+import type { CheckpointRecord, WorkspaceSnapshot } from "./types.js";
+export interface RegisterGoStatusDeps {
+    /** Injectable registry read (default: the module-scoped registry + mirror). */
+    loadRows?: () => RunRegistryRow[];
+    /** Injectable per-run journal read (default: the file checkpoint store). */
+    loadJournal?: (sessionKey: string) => CheckpointRecord[];
+    /** Injectable in-process liveness (default: the module-scoped registry). */
+    isInFlight?: (runId: string) => boolean;
+    /** Injectable git snapshot for the clean check (default: real git). */
+    snapshot?: (cwd: string, signal?: AbortSignal) => Promise<WorkspaceSnapshot>;
+    /** Injectable worktree removal (default: `git worktree remove`). */
+    removeWorktree?: (worktreePath: string, repoCwd: string, signal?: AbortSignal) => Promise<void>;
+    /**
+     * Resolve the current tree's repo identity (same value stored on a run row's
+     * `repo`), so /go-clean only touches THIS repo's worktrees — `git worktree
+     * remove` is per-repo and rejects a foreign path. Injected by goCommand with
+     * its own git resolver; the default returns undefined (no filter, so an
+     * un-wired caller keeps the prior global behavior).
+     */
+    resolveRepo?: (cwd: string, signal?: AbortSignal) => Promise<string | undefined>;
+    exists?: (path: string) => boolean;
+    now?: () => number;
+}
+/**
+ * PURE: where an in-flight/interrupted run got to, read off its checkpoint
+ * journal. The journal is append-only, so the latest applicable boundary wins.
+ */
+export declare function describeJournalStage(records: CheckpointRecord[]): string;
+/**
+ * PURE: one status line per registry row. No em-dashes (house copy rule);
+ * pieces that do not exist for a row are simply omitted.
+ */
+export declare function describeRunRow(row: RunRegistryRow, liveness: RunLiveness, journal: CheckpointRecord[], now: number): string;
+export declare function registerGoStatusCommands(pi: ExtensionAPI, deps?: RegisterGoStatusDeps): void;
+//# sourceMappingURL=goStatusCommands.d.ts.map

package/dist/extension/pipeline/goStatusCommands.js

@@ -0,0 +1,188 @@
+/**
+ * `/go-status` and `/go-clean` — the pull-path companions to detached /go runs
+ * (spec §3b). Registered from the pipeline's registration path (goCommand.ts
+ * calls {@link registerGoStatusCommands} with the same pi object; src/index.ts
+ * is never edited for these).
+ *
+ *  - `/go-status` lists every registry row with an honest liveness verdict:
+ *    active runs show their stage/round straight from the checkpoint journal,
+ *    finished runs show outcome + branch + commit/PR, interrupted runs say
+ *    "resumable, re-run /go <ticket>". It is the always-available fallback when
+ *    a detached completion message could not be delivered.
+ *
+ *  - `/go-clean` removes ONLY worktrees that are verifiably CLEAN (everything
+ *    committed — the WIP-commit on non-clean terminal outcomes exists exactly
+ *    so this is normally true). A dirty or unverifiable worktree is SKIPPED
+ *    with an honest note + path, never force-removed: /go-clean must be safe to
+ *    run reflexively.
+ *
+ * The line formatting is pure ({@link describeRunRow}, {@link describeJournalStage});
+ * the impure seams (registry, journal, git snapshot, worktree removal, fs
+ * exists) are injectable for tests.
+ */
+import { existsSync } from "node:fs";
+import { makeFileCheckpointStore } from "./checkpoint.js";
+import { classifyRunLiveness, isRunInFlight, isTerminalStatus, lastJournalTs, loadRegistryRows, settleRun, } from "./runRegistry.js";
+import { removeWorktree as defaultRemoveWorktree } from "./worktree.js";
+import { snapshotWorkspace as defaultSnapshotWorkspace } from "./workspace.js";
+/**
+ * PURE: where an in-flight/interrupted run got to, read off its checkpoint
+ * journal. The journal is append-only, so the latest applicable boundary wins.
+ */
+export function describeJournalStage(records) {
+    let maxRound = 0;
+    let sawBuildDone = false;
+    let sawAnything = false;
+    for (const r of records) {
+        if (!r)
+            continue;
+        sawAnything = true;
+        if (r.kind === "build_done")
+            sawBuildDone = true;
+        if (r.kind === "round_done" && typeof r.round === "number" && r.round > maxRound)
+            maxRound = r.round;
+    }
+    if (maxRound > 0)
+        return `review round ${maxRound + 1}`;
+    if (sawBuildDone)
+        return "review round 1";
+    if (sawAnything)
+        return "building (map/plan/implement)";
+    return "starting";
+}
+/** Compact "Xm ago" for status lines. */
+function agoMinutes(ts, now) {
+    return `${Math.max(0, Math.round((now - ts) / 60_000))}m ago`;
+}
+/**
+ * PURE: one status line per registry row. No em-dashes (house copy rule);
+ * pieces that do not exist for a row are simply omitted.
+ */
+export function describeRunRow(row, liveness, journal, now) {
+    const id = `[${row.runId.slice(0, 8)}] ${row.ticket}`;
+    if (liveness === "in_flight") {
+        return `${id}: running, ${describeJournalStage(journal)} (started ${agoMinutes(row.startedAt, now)})`;
+    }
+    if (liveness === "active_elsewhere") {
+        const seen = lastJournalTs(journal) || row.startedAt;
+        return `${id}: running in another session? ${describeJournalStage(journal)} (journal active ${agoMinutes(seen, now)})`;
+    }
+    if (liveness === "interrupted") {
+        return `${id}: interrupted at ${describeJournalStage(journal)}; resumable, re-run /go ${row.ticket}`;
+    }
+    const parts = [`${id}: ${row.status === "cleaned" ? "cleaned (worktree removed)" : row.status}`];
+    if (row.branch)
+        parts.push(`branch ${row.branch}`);
+    if (row.commitSha)
+        parts.push(`commit ${row.commitSha.slice(0, 7)}`);
+    if (row.prUrl)
+        parts.push(`PR ${row.prUrl}`);
+    if (row.worktreePath && row.status !== "cleaned")
+        parts.push(`worktree ${row.worktreePath}`);
+    return parts.join(" | ");
+}
+export function registerGoStatusCommands(pi, deps = {}) {
+    const loadRows = deps.loadRows ?? loadRegistryRows;
+    const loadJournal = deps.loadJournal ?? ((sessionKey) => makeFileCheckpointStore(sessionKey).load());
+    const inFlight = deps.isInFlight ?? isRunInFlight;
+    const snapshot = deps.snapshot ?? defaultSnapshotWorkspace;
+    const remove = deps.removeWorktree ?? defaultRemoveWorktree;
+    const resolveRepo = deps.resolveRepo ?? (async () => undefined);
+    const exists = deps.exists ?? existsSync;
+    const now = deps.now ?? Date.now;
+    pi.registerCommand("go-status", {
+        description: "List /go runs: active (stage/round), finished (outcome + branch/commit/PR), and interrupted (resumable).",
+        handler: async (_args, ctx) => {
+            const rows = loadRows()
+                .slice()
+                .sort((a, b) => b.startedAt - a.startedAt);
+            if (rows.length === 0) {
+                if (ctx.hasUI)
+                    ctx.ui.notify("No /go runs recorded yet.", "info");
+                else
+                    await pi.sendUserMessage("No /go runs recorded yet.");
+                return;
+            }
+            const lines = rows.map((row) => {
+                const journal = safeJournal(loadJournal, row.sessionKey);
+                const liveness = classifyRunLiveness(row, {
+                    inFlight: inFlight(row.runId),
+                    lastJournalTs: lastJournalTs(journal) || undefined,
+                    now: now(),
+                });
+                return describeRunRow(row, liveness, journal, now());
+            });
+            await pi.sendUserMessage(`/go runs (newest first):\n${lines.join("\n")}`);
+        },
+    });
+    pi.registerCommand("go-clean", {
+        description: "Remove finished /go run worktrees that are fully committed; dirty worktrees are skipped with a note.",
+        handler: async (_args, ctx) => {
+            // `git worktree remove` is per-repo, so only THIS repo's worktrees are
+            // removable from here; scoping to the current repo keeps /go-clean from
+            // failing on (and noisily reporting) every OTHER repo's run worktrees.
+            let baseRepo;
+            try {
+                baseRepo = await resolveRepo(ctx.cwd, ctx.signal);
+            }
+            catch {
+                baseRepo = undefined; // can't resolve ours → don't filter (safe fallback)
+            }
+            const candidates = loadRows().filter((row) => isTerminalStatus(row.status) &&
+                row.status !== "cleaned" &&
+                !!row.worktreePath &&
+                !inFlight(row.runId) &&
+                // Keep rows with no recorded repo (legacy), or when we couldn't resolve
+                // ours, so nothing becomes permanently un-cleanable; otherwise match.
+                (!baseRepo || !row.repo || row.repo === baseRepo));
+            if (candidates.length === 0) {
+                if (ctx.hasUI)
+                    ctx.ui.notify("No finished /go worktrees to clean.", "info");
+                else
+                    await pi.sendUserMessage("No finished /go worktrees to clean.");
+                return;
+            }
+            let removed = 0;
+            const notes = [];
+            for (const row of candidates) {
+                const path = row.worktreePath;
+                const label = `[${row.runId.slice(0, 8)}] ${row.ticket}`;
+                if (!exists(path)) {
+                    // Already gone (a manual rm): record it so it stops showing up.
+                    settleRun(row.runId, { ...row, status: "cleaned" });
+                    continue;
+                }
+                try {
+                    const snap = await snapshot(path, ctx.signal);
+                    if (!snap.tracked) {
+                        notes.push(`${label}: skipped, could not verify the worktree is clean (not a readable git tree): ${path}`);
+                        continue;
+                    }
+                    if (snap.status.trim().length > 0) {
+                        notes.push(`${label}: skipped, worktree has uncommitted changes (left in place): ${path}`);
+                        continue;
+                    }
+                    await remove(path, ctx.cwd, ctx.signal);
+                    settleRun(row.runId, { ...row, status: "cleaned" });
+                    removed += 1;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    notes.push(`${label}: skipped, removal failed (${msg}): ${path}`);
+                }
+            }
+            const summary = [`/go-clean: removed ${removed} clean worktree${removed === 1 ? "" : "s"}.`, ...notes].join("\n");
+            await pi.sendUserMessage(summary);
+        },
+    });
+}
+/** Journal read that never throws (an unreadable journal reads as empty). */
+function safeJournal(loadJournal, sessionKey) {
+    try {
+        return loadJournal(sessionKey) ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=goStatusCommands.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * PURE child-invocation builder — the direct analogue of yagni-code-cli's
+ * `buildLaunch` (no spawn, no fs).
+ *
+ * `buildStageInvocation` produces the per-stage pi PASSTHROUGH argv exactly as
+ * the subagent example assembles it (runSingleAgent L294-330):
+ *   --mode json -p --no-session --model <tier> --tools <csv>
+ *   --append-system-prompt <file> 'Task: <rendered>'
+ *
+ * `groundedChildArgv` prepends the grounding pi-args the yagni-code launcher
+ * would otherwise add (`-e <self> --provider yagni`) because v1 spawns pi
+ * directly, NOT the yagni-code bin, to avoid a yagni-code-cli ↔ pi-extension-yagni
+ * circular dependency (token / base-url / agent-dir are inherited from the
+ * parent's env, not re-built here).
+ *
+ * `renderTemplate` does the {ticket}/{previous} substitution, mirroring the
+ * chain's `step.task.replace(/{previous}/g, …)`.
+ */
+import type { PipelineStage, ReviewLens } from "./types.js";
+/** Fill {ticket}/{previous}; an absent var renders as empty string. */
+export declare function renderTemplate(tmpl: string, vars: {
+    ticket?: string;
+    previous?: string;
+}): string;
+/**
+ * Build the pi passthrough argv for one stage (from `--mode` onward). The
+ * positional rendered prompt is always the last arg, prefixed `Task: `.
+ */
+export declare function buildStageInvocation(stage: PipelineStage, ctx: {
+    ticket: string;
+    previous?: string;
+    promptFilePath: string;
+    lens?: ReviewLens;
+}): string[];
+/**
+ * Prepend the grounding args (the pi cli script, our extension, and the default
+ * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
+ * `userChoseProvider` guard so a passthrough that already chose a provider is
+ * left untouched.
+ */
+export declare function groundedChildArgv(stageArgv: string[], opts: {
+    piCli: string;
+    extensionPath: string;
+}): string[];
+//# sourceMappingURL=invocation.d.ts.map