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

package/dist/extension/pipeline/goCommand.js

@@ -0,0 +1,972 @@
+/**
+ * Registers the `/go <ticket>` entry point (spec decision §5 — NOT `/run` or
+ * `/work`, which collide with the Run and Work concepts), plus its companions
+ * `/go-status` and `/go-clean` (registered from this same pipeline registration
+ * path — src/index.ts only ever calls registerGoCommand).
+ *
+ * A `registerCommand` (not a static chain prompt) is used because the review→fix
+ * LOOP needs a runtime condition a markdown chain cannot express. The handler
+ * parses the remainder through the flag parser (`--here` in-place, `--fg`
+ * blocking, `--pr` push + PR at FINISH; unknown flags are refused with
+ * a usage warning), guards on `ctx.isIdle()` plus the run registry (same-ticket
+ * in-flight refusal, MAX_CONCURRENT_RUNS), and runs the pipeline. Everything
+ * downstream — ticket resolution, sessionKey, registry, run-row arg, the
+ * ActivityFeed header, and the handoff copy — receives the FLAG-FREE ticket.
+ *
+ * FINISH STAGE (spec §3c): when the review loop stops `clean`, the handler runs
+ * the deterministic FINISH stage (finish.ts): commit the run's work (worktree
+ * mode always; --here only when the pre-run baseline was verifiably clean) with
+ * a conventional subject + plan summary + the provenance trailer, and — with
+ * `--pr` — push the run branch and open a PR under the user's own gh auth. A
+ * FINISH failure NEVER flips a clean run to failed and never fakes a commit
+ * (§0.1): every skip/failure is an honest note on the handoff. The commit/PR
+ * land on `PipelineResult.finish`, `session.finish`, the registry row, a
+ * `finish_done` checkpoint record, and a `finish` row in the activity feed.
+ *
+ * WORKTREE BY DEFAULT (spec §3b): the run gets its own worktree + branch FIRST
+ * (`git worktree add -b yagni/<slug>-<shortId> ~/.yagni-code/worktrees/<shortId>
+ * HEAD`), and repoCtx, sessionKey, the checkpoint journal, and every resume
+ * snapshot are resolved against the WORKTREE path — fresh runs and
+ * registry-driven resumes agree on the same tree, so the same run always maps to
+ * the same sha1(sessionKey) journal file. A best-effort bootstrap installs
+ * dependencies (fail-open with an honest note; verify's infra-failure
+ * classification covers the rest). `--here` opts back into the legacy in-place
+ * behavior: dirty-tree guard + no-op guard unchanged, sessionKey from ctx.cwd,
+ * and never a WIP commit. If worktree creation itself fails, default /go stops
+ * before mutating the user's tree; `--here` is the explicit in-place escape
+ * hatch.
+ *
+ * DETACHED BY DEFAULT: /go returns the prompt as soon as the run session opens;
+ * the pipeline promise is tracked in the module-scoped run registry (mirrored to
+ * ~/.yagni-code/registry.ndjson) and completion delivers the existing handoff
+ * via `pi.sendUserMessage(handoff, { deliverAs: "followUp" })` (try/catch with a
+ * notify fallback — pi requires deliverAs when the agent is streaming). `--fg`
+ * restores blocking. On a NON-clean terminal outcome in worktree mode the run's
+ * work is preserved as a clearly-marked `wip(yagni): <ticket> - <stopReason>`
+ * commit on the run branch, so nothing is lost and /go-clean can remove the tree.
+ *
+ * When the session has a UI, it also paints a live activity feed in an
+ * `aboveEditor` widget (spec §1) under a PER-RUN key (`yagni-go:<runShortId>`) so
+ * two concurrent runs never flicker-fight one widget and one run's clearUI only
+ * removes its own panel. Every UI call is guarded behind `ctx.hasUI` and
+ * optional-chained so headless runs degrade gracefully. `runPipeline` is
+ * injected so the handler is unit-testable without spawning.
+ *
+ * Run tracking: the handler opens a tracked run session (a `runs` row visible on
+ * the Work page) around the pipeline — `start` before, `stage` for each pipeline
+ * boundary, and `finish` with an honest outcome afterwards. Every session call
+ * is fail-soft, so recording can never break `/go`.
+ */
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { eventToLine } from "./activity.js";
+import { ActivityFeed, SPINNER_FRAMES } from "./activityFeed.js";
+import { RunState } from "./runState.js";
+import { aggregateRunUsage } from "./budget.js";
+import { makeCombinedCheckpointStore, makeFileCheckpointStore, makePiJournalCheckpointStore, } from "./checkpoint.js";
+import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
+import { isDesktopSurface } from "../surface.js";
+import { runFinish as defaultRunFinish, verifyTrailerValue, } from "./finish.js";
+import { GO_USAGE, parseGoArgs } from "./goFlags.js";
+import { registerGoStatusCommands } from "./goStatusCommands.js";
+import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
+import { planResume } from "./resume.js";
+import { activeRunCount, beginRun, classifyRunLiveness, findActiveRunByTicket, isRunInFlight, isTerminalStatus, lastJournalTs, loadRegistryRows, MAX_CONCURRENT_RUNS, settleRun, trackRunPromise, worktreesDir, } from "./runRegistry.js";
+import { makeRunSession as defaultMakeRunSession } from "./runSession.js";
+import { resolveTicketBrief as defaultResolveTicketBrief } from "./ticketResolution.js";
+import { snapshotWorkspace as defaultSnapshotWorkspace } from "./workspace.js";
+import { parseChangedPaths } from "./verify.js";
+import { bootstrapWorktree as defaultBootstrapWorktree, commitWip as defaultCommitWip, createRunWorktree as defaultCreateRunWorktree, runBranchName, wipCommitMessage, } from "./worktree.js";
+/** The resume run key: the same ticket in the same worktree/branch resumes itself. */
+function makeSessionKey(ticket, cwd, repo, branch) {
+    return [ticket, cwd ?? "", repo ?? "", branch ?? ""].join("::");
+}
+/**
+ * The default durable journal: a session-independent local NDJSON file (primary)
+ * plus, when the pi build exposes them, a mirror into pi's native append-only
+ * session journal (`pi.appendEntry` / `ctx.sessionManager.getEntries`). The
+ * mirror is skipped gracefully on a pi build (or a test mock) lacking those.
+ */
+function defaultMakeCheckpointStore(sessionKey, pi, ctx) {
+    const stores = [makeFileCheckpointStore(sessionKey)];
+    const piAny = pi;
+    const ctxAny = ctx;
+    const appendEntry = piAny.appendEntry;
+    const sm = ctxAny.sessionManager;
+    if (typeof appendEntry === "function" && typeof sm?.getEntries === "function") {
+        stores.push(makePiJournalCheckpointStore(sessionKey, {
+            appendEntry: (t, d) => appendEntry.call(pi, t, d),
+            getEntries: () => sm.getEntries.call(sm),
+        }));
+    }
+    return makeCombinedCheckpointStore(stores);
+}
+/** Warning copy when a journal exists but the run is NOT safe to auto-resume. */
+const WARN_PARTIAL_COPY = {
+    build_interrupted: "An earlier /go here was interrupted during the build stage; the working tree may hold partial changes. Starting fresh — check `git status` first.",
+    tree_diverged: "An earlier /go here was interrupted, and the working tree has changed since. Starting fresh rather than resuming onto a diverged tree — check `git status` first.",
+};
+/**
+ * Honest note for any review lens skipped because it failed (R2 partial-failure
+ * tolerance). Without this, a degraded round (the review ran on the survivors)
+ * would look identical to a full review, so the user never learns a lens was
+ * skipped. Empty when every round ran every lens. Uniqued across rounds.
+ */
+function degradedLensNote(result) {
+    const skipped = new Set();
+    for (const r of result.rounds)
+        for (const lens of r.degradedLenses ?? [])
+            skipped.add(lens);
+    if (skipped.size === 0)
+        return "";
+    const list = [...skipped].join(", ");
+    const lensClause = skipped.size === 1 ? `a review lens (${list}) was` : `${skipped.size} review lenses (${list}) were`;
+    return `\n\nNote: ${lensClause} skipped after failing; the review proceeded on the surviving lenses.`;
+}
+/**
+ * Honest note when the P4 verify gate could not give a verdict (no build/test
+ * command detected, unrunnable, or timed out), so the user knows "clean" rested
+ * on the LLM review alone this run rather than an enforced build. Empty when the
+ * gate produced a verdict. No em-dashes (house copy rule).
+ */
+function verifyNote(result) {
+    if (!result.verifyNote)
+        return "";
+    // The gate RAN (verifyCommand present) but part of it could not — e.g. the
+    // §3d test half's "tests could not run" / "tests skipped" notes. The note is
+    // already self-explanatory prose; surface it verbatim rather than wrapping it
+    // in the contradictory "did not run" copy below.
+    if (result.verifyCommand) {
+        return `\n\nNote: ${result.verifyNote}`;
+    }
+    return `\n\nNote: the build/test verify gate did not run (${result.verifyNote}), so "clean" reflects the review only. Add a verify command (package.json script or .yagni-code/verify) to enforce it.`;
+}
+/** Where the run's work lives, appended to the handoff for a worktree run. */
+function worktreeNote(worktreePath, branch) {
+    if (!worktreePath)
+        return "";
+    return `\n\nThe run's work is on branch ${branch ?? "(unknown)"} in its worktree: ${worktreePath}`;
+}
+/**
+ * The FINISH stage's contribution to the handoff: the commit (+ PR) that landed,
+ * and every honest skip/failure note verbatim (§0.1 — a FINISH problem is a note
+ * on a still-successful run, never a laundered success or a hidden failure).
+ */
+function finishNote(result, finish) {
+    const parts = [];
+    if (result.finish?.commitSha) {
+        const sha = result.finish.commitSha.slice(0, 7);
+        const branch = result.finish.branch ? ` on ${result.finish.branch}` : "";
+        const pr = result.finish.prUrl ? ` PR: ${result.finish.prUrl}` : "";
+        parts.push(`Committed ${sha}${branch}.${pr}`);
+    }
+    for (const note of finish?.notes ?? [])
+        parts.push(note);
+    if (parts.length === 0)
+        return "";
+    return `\n\n${parts.join("\n")}`;
+}
+/** Blocking-finding detail appended to the DURABLE handoff (spec: surface findings, not counts). */
+function formatHandoff(result, ticket) {
+    const summary = formatSummary(result);
+    const degraded = `${degradedLensNote(result)}${verifyNote(result)}`;
+    const blocking = result.findings.filter((f) => f.severity === "critical" || f.severity === "high");
+    if (blocking.length === 0)
+        return `${summary}${degraded}`;
+    const lines = blocking.map((f) => {
+        const loc = f.file ? `${f.file}${f.line != null ? `:${f.line}` : ""}` : "(no location)";
+        return `  • ${f.severity} | ${loc} | ${f.message} (${f.lens})`;
+    });
+    const next = result.stopReason === "round_cap" || result.stopReason === "failed"
+        ? `\n\nNext: address the finding${blocking.length === 1 ? "" : "s"} above (edit + commit), or re-run /go ${ticket} for another pass.`
+        : "";
+    return `${summary}\n\nUnresolved blocking finding${blocking.length === 1 ? "" : "s"}:\n${lines.join("\n")}${next}${degraded}`;
+}
+/**
+ * Per-run UI key prefix: the widget/status keys are `yagni-go:<runShortId>` so
+ * two concurrent runs each own their panel and clearUI removes only its own.
+ */
+export const STATUS_KEY_PREFIX = "yagni-go:";
+/**
+ * Per-run key for the desktop's structured state record. Distinct from
+ * STATUS_KEY_PREFIX so the app routes by key rather than sniffing content.
+ */
+export const STATE_KEY_PREFIX = "yagni-go:state:";
+/** Trailing-edge debounce window: coalesce bursty event paints to one per ~80ms. */
+const PAINT_DEBOUNCE_MS = 80;
+/**
+ * Steady animation cadence. The pipeline only emits events at stage/tool
+ * boundaries, so between them nothing would repaint and the spinner (and elapsed
+ * clock) freeze. A steady interval re-paints on its own, and the spinner frame is
+ * derived from wall-clock time so it advances smoothly no matter what triggered
+ * the paint. `setInterval` (not a self-rescheduling `setTimeout`) keeps the
+ * existing setTimeout-only mock-timer tests green: a real, immediately-cleared
+ * interval never fires inside those synchronous runs.
+ */
+export const ANIMATION_INTERVAL_MS = 120;
+const SPINNER_TICK_MS = 120;
+/**
+ * Wall-clock liveness interval. /go pings POST /runs/:id/heartbeat on this
+ * cadence for the whole run so the server-side reaper (which fails a run idle
+ * past STALE_RUN_MS = 30 min) never reaps a legitimately-long run mid-flight —
+ * even a single quiet stage that emits no NDJSON for many minutes. Comfortably
+ * under the reaper window; fail-soft and unref'd so it never holds the process
+ * (or a test worker) open.
+ */
+const HEARTBEAT_INTERVAL_MS = 5 * 60_000;
+const STOP_REASON_COPY = {
+    clean: "clean, no blocking findings remain",
+    round_cap: "round cap reached, blocking findings remain",
+    aborted: "aborted before the review completed",
+    failed: "a review or fix stage failed before completing",
+    no_changes: "no changes were produced. The implement stage finished without writing any code, often because the plan it received was incomplete. Nothing was committed, re-run /go to retry",
+    budget_exceeded: "the run hit its budget ceiling (turns, cost, or tokens) and stopped before finishing. Review the partial change, then re-run /go to continue",
+    partial: "a build or fix stage stopped before finishing (a timeout or transient error once it had already begun editing). The partial changes are in your working tree, uncommitted. Review them, or re-run /go to retry",
+};
+/** Map the pipeline's stop reason onto the run-session outcome enum. */
+function outcomeFor(stopReason) {
+    // `partial` is a preserved-but-incomplete run (work is in the tree), so it is a
+    // `stopped`, never a `failed` (which would imply nothing usable was produced).
+    if (stopReason === "aborted" || stopReason === "budget_exceeded" || stopReason === "partial")
+        return "stopped";
+    if (stopReason === "failed")
+        return "failed";
+    return "completed"; // clean | round_cap are both real completions
+}
+/**
+ * The bare "what was done" recap — stop reason + the review tally — with NO
+ * "YAGNI Code /go finished:" prefix. This is what rides `finish` as the
+ * `run_outcome` activity body. The Work-page timeline already labels that beat
+ * "Run outcome", so prefixing here would double up into "Run outcome: YAGNI
+ * Code /go finished: ...". `formatSummary` re-adds the prefix for the standalone
+ * toast + scrollback line, where the context is useful on its own.
+ */
+function recapBody(result) {
+    const rounds = result.rounds.length;
+    const total = result.findings.length;
+    const blocking = result.findings.filter((f) => f.severity === "critical" || f.severity === "high").length;
+    const reason = STOP_REASON_COPY[result.stopReason];
+    return (`${reason}. ` +
+        `${rounds} review round${rounds === 1 ? "" : "s"}, ` +
+        `${total} finding${total === 1 ? "" : "s"} (${blocking} blocking).` +
+        runCostNote(result));
+}
+/**
+ * What the run actually cost.
+ *
+ * The number was already being computed every round to enforce
+ * `DEFAULT_RUN_BUDGET` and then discarded, so reporting it is nearly free. It
+ * matters more now that plan and review run on `peak`: without this line a /go
+ * run's entire spend is invisible, because `/cost` accumulates off the parent
+ * session's `turn_end` and every stage runs in a child process. YAG-383 is the
+ * server-authoritative fix; this is the honest number we already hold.
+ */
+function runCostNote(result) {
+    const usage = aggregateRunUsage(result.stages, result.rounds);
+    if (usage.cost <= 0 && usage.input === 0 && usage.output === 0)
+        return "";
+    const tokens = (usage.input + usage.output).toLocaleString("en-US");
+    return ` Run cost: $${usage.cost.toFixed(2)} over ${tokens} tokens.`;
+}
+/**
+ * One-line, human-readable outcome for the session + a UI toast. This is the
+ * DURABLE record (sent via `sendUserMessage`, fired even on headless runs where
+ * no `ActivityFeed` is constructed), so it is intentionally kept separate from
+ * `ActivityFeed.finalLine` (the feed's compact, UI-only outcome glyph-line)
+ * rather than the two sharing one outcome-copy source.
+ */
+function formatSummary(result) {
+    return `YAGNI Code /go finished: ${recapBody(result)}`;
+}
+/**
+ * User-facing notice when a /go run is NOT being recorded on the Work page.
+ * Without this, a flag-off / unauthorized / unreachable backend fails silently
+ * (the run-session swallows it) and the run vanishes with no explanation.
+ */
+const UNTRACKED_NOTICE = {
+    disabled: "Run tracking is off for this workspace, so this /go run won't appear on the Work page.",
+    unauthorized: "Run tracking is unauthorized. Run `yagni login` to refresh your token so runs appear on the Work page.",
+    error: "Couldn't reach YAGNI to record this run, so it won't appear on the Work page. The pipeline ran anyway.",
+};
+/** Toast severity for an outcome: clean is good, round_cap warns, abort/fail are errors. */
+function summaryTone(stopReason) {
+    if (stopReason === "clean")
+        return "info";
+    if (stopReason === "round_cap" ||
+        stopReason === "no_changes" ||
+        stopReason === "budget_exceeded" ||
+        stopReason === "partial")
+        return "warning";
+    return "error";
+}
+/** A stage transition / completion should paint immediately; findings can ride the debounce. */
+function isTransition(p) {
+    return p.kind !== "findings";
+}
+/** The cheap status-line fallback for terminals where the widget is unavailable. */
+function shortLabel(p) {
+    switch (p.kind) {
+        case "stage_start":
+            return p.round ? `${p.stageId} (round ${p.round})…` : `${p.stageId}…`;
+        case "findings":
+            return `round ${p.round}: ${p.total} finding${p.total === 1 ? "" : "s"}`;
+        default:
+            return undefined;
+    }
+}
+/** Best-effort `git` in `cwd`; resolves to undefined on any failure. */
+function git(args, cwd, signal) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, signal, maxBuffer: 1024 * 1024 }, (err, stdout) => resolve(err ? undefined : stdout.trim() || undefined));
+    });
+}
+/** Parse `owner/name` from an origin remote URL (ssh or https). */
+function parseRepo(remote) {
+    if (!remote)
+        return undefined;
+    const m = remote.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+    return m ? m[1] : undefined;
+}
+/** Default cwd-derived git context (branch, commit, owner/name); all best-effort. */
+async function defaultResolveRepoContext(cwd, signal) {
+    const [branch, commitSha, remote] = await Promise.all([
+        git(["rev-parse", "--abbrev-ref", "HEAD"], cwd, signal),
+        git(["rev-parse", "HEAD"], cwd, signal),
+        git(["config", "--get", "remote.origin.url"], cwd, signal),
+    ]);
+    return { repo: parseRepo(remote), branch, commitSha };
+}
+export function registerGoCommand(pi, deps = {}) {
+    const runPipeline = deps.runPipeline ?? defaultRunPipeline;
+    const makeRunSession = deps.makeRunSession ?? defaultMakeRunSession;
+    const resolveRepoContext = deps.resolveRepoContext ?? defaultResolveRepoContext;
+    const makeCheckpointStore = deps.makeCheckpointStore ?? defaultMakeCheckpointStore;
+    const resolveSnapshot = deps.resolveSnapshot ?? defaultSnapshotWorkspace;
+    const createWorktree = deps.createWorktree ?? defaultCreateRunWorktree;
+    const bootstrap = deps.bootstrap ?? defaultBootstrapWorktree;
+    const commitWipFn = deps.commitWip ?? defaultCommitWip;
+    const runFinishFn = deps.runFinish ?? defaultRunFinish;
+    const loadJournal = deps.loadJournal ?? ((sessionKey) => makeFileCheckpointStore(sessionKey).load());
+    const exists = deps.exists ?? existsSync;
+    const now = deps.now ?? Date.now;
+    const resolveTicketBrief = deps.resolveTicketBrief ??
+        ((rawArg) => defaultResolveTicketBrief({ baseUrl: deps.baseUrl ?? resolveBaseUrl(), getToken: deps.getToken ?? defaultGetToken }, rawArg));
+    pi.registerCommand("go", {
+        description: "Run the grounded multi-agent pipeline (map → plan → implement → review → fix) on a ticket and produce a reviewed change.",
+        handler: async (args, ctx) => {
+            const notify = (message, type) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, type);
+            };
+            // Flags first (spec §3a): everything downstream gets the FLAG-FREE ticket.
+            const parsed = parseGoArgs(args);
+            if (parsed.unknownFlags.length > 0) {
+                notify(`Unknown flag${parsed.unknownFlags.length === 1 ? "" : "s"}: ${parsed.unknownFlags.join(", ")}. ${GO_USAGE}`, "warning");
+                return;
+            }
+            const ticket = parsed.ticket;
+            if (!ticket) {
+                notify(GO_USAGE, "warning");
+                return;
+            }
+            if (!ctx.isIdle()) {
+                notify("YAGNI Code is busy; wait for the current turn to finish before running /go.", "warning");
+                return;
+            }
+            // In-flight guards: the same ticket never runs twice at once in this
+            // process, and at most MAX_CONCURRENT_RUNS runs are in flight.
+            if (findActiveRunByTicket(ticket)) {
+                notify(`/go ${ticket} is already running - see /go-status.`, "warning");
+                return;
+            }
+            if (activeRunCount() >= MAX_CONCURRENT_RUNS) {
+                notify(`${MAX_CONCURRENT_RUNS} /go runs are already in flight; wait for one to finish (see /go-status).`, "warning");
+                return;
+            }
+            // --- Run tree resolution: worktree by default; --here = legacy in-place.
+            // The worktree + run branch are created FIRST so repoCtx, sessionKey, the
+            // journal, and every snapshot resolve against the WORKTREE path.
+            let runId = randomUUID();
+            let runCwd = ctx.cwd;
+            let worktreeMode = false;
+            let worktreePath;
+            // True when this run reuses an INTERRUPTED prior run's worktree. On a
+            // resume_loop that tree is intentionally kept (it holds the completed
+            // build); on a warn_partial we run fresh and must first clear the abandoned
+            // partial edits so review + FINISH see only THIS run's work (see below).
+            let adoptedWorktree = false;
+            if (!parsed.flags.here) {
+                // Registry-driven resume: a prior run of this ticket that is non-terminal
+                // AND not in flight is a resume candidate; a journal quiet for > 30 min
+                // means its process died (interrupted), while recent activity means it is
+                // probably still running in ANOTHER session — refuse rather than fork it.
+                let adopted;
+                const candidates = loadRegistryRows().filter((r) => r.ticket === ticket && !isTerminalStatus(r.status) && !!r.worktreePath);
+                if (candidates.length > 0) {
+                    const baseRepo = (await resolveRepoContext(ctx.cwd, ctx.signal)).repo;
+                    for (const row of candidates.slice().sort((a, b) => b.startedAt - a.startedAt)) {
+                        if (baseRepo && row.repo && row.repo !== baseRepo)
+                            continue;
+                        let journal = [];
+                        try {
+                            journal = loadJournal(row.sessionKey) ?? [];
+                        }
+                        catch {
+                            journal = [];
+                        }
+                        const liveness = classifyRunLiveness(row, {
+                            inFlight: isRunInFlight(row.runId),
+                            lastJournalTs: lastJournalTs(journal) || undefined,
+                            now: now(),
+                        });
+                        if (liveness === "in_flight" || liveness === "active_elsewhere") {
+                            notify(`/go ${ticket} appears to be running already (its journal is still active) - see /go-status.`, "warning");
+                            return;
+                        }
+                        if (liveness === "interrupted" && row.worktreePath && exists(row.worktreePath)) {
+                            adopted = row;
+                            break;
+                        }
+                    }
+                }
+                if (adopted?.worktreePath) {
+                    // Resume INTO the interrupted run's worktree: same tree => same
+                    // sessionKey => same journal file, so planResume sees the checkpoints.
+                    runId = adopted.runId;
+                    worktreePath = adopted.worktreePath;
+                    worktreeMode = true;
+                    runCwd = adopted.worktreePath;
+                    adoptedWorktree = true;
+                    notify(`Found an interrupted /go for "${ticket}"; picking it up in its worktree (${worktreePath}).`, "info");
+                }
+                else {
+                    const shortId = runId.slice(0, 8);
+                    const path = join(worktreesDir(), shortId);
+                    const branch = runBranchName(ticket, shortId);
+                    try {
+                        await createWorktree({ repoCwd: ctx.cwd, worktreePath: path, branch, signal: ctx.signal });
+                        worktreeMode = true;
+                        worktreePath = path;
+                        runCwd = path;
+                        // Best-effort bootstrap (fail-open): without node_modules every
+                        // verify/typecheck would exit `command not found`.
+                        const boot = await bootstrap(path, { signal: ctx.signal });
+                        if (boot.note)
+                            notify(boot.note, "warning");
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        notify(`Couldn't create a run worktree (${msg}). Stopping before mutating your working tree; re-run /go ${ticket} --here to run in place intentionally.`, "error");
+                        return;
+                    }
+                }
+            }
+            const runShortId = runId.slice(0, 8);
+            const uiKey = `${STATUS_KEY_PREFIX}${runShortId}`;
+            // Live feed state. Only constructed (and painted) when there is a UI, and
+            // exactly one of the two exists: the surfaces are mutually exclusive.
+            // `feed` renders the terminal's ANSI panel; `run` is the structured record
+            // the desktop renders itself from.
+            const desktop = isDesktopSurface();
+            const feed = ctx.hasUI && !desktop ? new ActivityFeed(ticket) : undefined;
+            const startedAt = Date.now();
+            const run = ctx.hasUI && desktop ? new RunState({ runId: runShortId, ticket, startedAt }) : undefined;
+            const stateKey = `${STATE_KEY_PREFIX}${runShortId}`;
+            let paintTimer;
+            let animationTimer;
+            let heartbeatTimer;
+            const elapsed = () => `${Math.max(0, Math.round((Date.now() - startedAt) / 1000))}s`;
+            const doPaint = () => {
+                if (!ctx.hasUI)
+                    return;
+                if (run) {
+                    // One line, no ANSI, no line caps: RPC mode forwards widgetLines
+                    // verbatim, so the interactive 10-line cap does not apply here.
+                    ctx.ui.setWidget?.(stateKey, [JSON.stringify(run)], { placement: "aboveEditor" });
+                    return;
+                }
+                if (!feed)
+                    return;
+                const theme = ctx.ui.theme;
+                if (!theme)
+                    return; // no theme -> rely on the status-line fallback only
+                // Time-based frame: advances on the wall clock, so the steady ticker keeps
+                // the spinner moving between pipeline events instead of freezing on one glyph.
+                const frame = SPINNER_FRAMES[Math.floor((Date.now() - startedAt) / SPINNER_TICK_MS) % SPINNER_FRAMES.length];
+                ctx.ui.setWidget?.(uiKey, feed.render(theme, elapsed(), frame), { placement: "aboveEditor" });
+            };
+            const paint = (immediate = false) => {
+                if (!ctx.hasUI || (!feed && !run))
+                    return;
+                if (immediate) {
+                    if (paintTimer) {
+                        clearTimeout(paintTimer);
+                        paintTimer = undefined;
+                    }
+                    doPaint();
+                    return;
+                }
+                // Trailing-edge: one pending paint per window; it renders the latest state.
+                if (paintTimer)
+                    return;
+                paintTimer = setTimeout(() => {
+                    paintTimer = undefined;
+                    doPaint();
+                }, PAINT_DEBOUNCE_MS);
+                paintTimer.unref?.();
+            };
+            // Per-run clearUI: only ever touches THIS run's widget/status keys, so a
+            // concurrent run's panel is never cleared by this run finishing.
+            const clearUI = () => {
+                // Stamp and paint the terminal state BEFORE the timers go, so the
+                // desktop's last record carries the outcome rather than being cut off
+                // by the pending-paint cancellation below. Both exit paths (success and
+                // catch) converge here, which is why the stamp lives inside clearUI.
+                if (run) {
+                    run.markEnded(Date.now());
+                    doPaint();
+                }
+                if (animationTimer) {
+                    clearInterval(animationTimer);
+                    animationTimer = undefined;
+                }
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = undefined;
+                }
+                if (paintTimer) {
+                    clearTimeout(paintTimer);
+                    paintTimer = undefined;
+                }
+                if (ctx.hasUI && !desktop) {
+                    // The desktop keeps its finished run visible: it is a monitor you can
+                    // look back at, and the last record already carries the stop reason.
+                    // Only the terminal's transient panel and status chip are torn down.
+                    ctx.ui.setWidget?.(uiKey, undefined);
+                    ctx.ui.setStatus?.(uiKey, undefined);
+                }
+            };
+            // Open the tracked run session (fail-soft — never blocks /go).
+            const session = makeRunSession({
+                baseUrl: deps.baseUrl ?? resolveBaseUrl(),
+                getToken: deps.getToken ?? defaultGetToken,
+            });
+            const repoCtx = await resolveRepoContext(runCwd, ctx.signal);
+            // Durable resilience journal, keyed by the RUN tree (the worktree path for
+            // a default run; ctx.cwd for --here). Detect an interrupted prior /go for
+            // this ticket+tree and either resume the (expensive) review loop or warn.
+            // The whole block is fail-soft: any error degrades to a normal fresh run.
+            const sessionKey = makeSessionKey(ticket, runCwd, repoCtx.repo, repoCtx.branch);
+            const store = makeCheckpointStore(sessionKey, pi, ctx);
+            let plan = { mode: "fresh" };
+            let snapshot;
+            // Whether this exact ticket+tree already has a /go journal. A dirty tree that
+            // belongs to this ticket's own prior pass (a round_cap / partial re-run) is NOT
+            // foreign, so the dirty-tree notice below is suppressed for it.
+            let priorRunExists = false;
+            try {
+                snapshot = await resolveSnapshot(runCwd, ctx.signal);
+                const records = store.load();
+                priorRunExists = records.length > 0;
+                plan = planResume(records, snapshot);
+            }
+            catch {
+                plan = { mode: "fresh" };
+            }
+            // The --here FINISH commit gate (spec §3c): an agent commit may only fold
+            // in the run's own work, so in-place commits require a verifiably-CLEAN
+            // pre-run baseline. Unknowable (untracked / snapshot failed) is treated as
+            // not-clean — FINISH then skips with an honest note rather than guessing.
+            // Worktree mode ignores this (a fresh worktree starts clean by construction).
+            const hereBaseline = !snapshot?.tracked
+                ? "unknown"
+                : snapshot.status.trim().length === 0
+                    ? "clean"
+                    : "dirty";
+            // Pre-flight dirty-tree notice (journal-aware, warn-and-proceed) — IN-PLACE
+            // runs only (a fresh worktree starts clean, so it is moot there). The review
+            // half is diff-driven (each reviewer runs `git diff`), so a FRESH /go over a
+            // tree that already holds uncommitted changes folds them into what it reviews.
+            // We WARN loudly + durably and PROCEED rather than block: a hard stop (and a
+            // headless abort) would break the documented "re-run /go to continue" after a
+            // round_cap / partial stop, where the tree is legitimately dirty with THIS
+            // ticket's own prior pass. So we stay silent when a prior /go on this same ticket
+            // explains the dirt (planResume reports a completed prior run as `fresh`), and
+            // only flag genuinely-foreign changes. A resume / warn_partial run is expected to
+            // be dirty and is never `fresh`. Fails open when no snapshot was resolved.
+            if (!worktreeMode &&
+                plan.mode === "fresh" &&
+                !priorRunExists &&
+                snapshot?.tracked &&
+                snapshot.status.trim().length > 0) {
+                const notice = `Heads up: your working tree already has uncommitted changes. /go reviews the working-tree diff, ` +
+                    `so it will include them in what it reviews for ${ticket}. If they are unrelated, stop and commit ` +
+                    `or stash them, then re-run /go ${ticket}.`;
+                notify(notice, "warning");
+                await pi.sendUserMessage(notice);
+            }
+            // Open or re-adopt the backend run row. A fresh run calls start(); a resume
+            // re-binds the original run (no duplicate row) when it was tracked.
+            const openFreshRun = async () => {
+                const started = await session.start({ arg: ticket, repo: repoCtx.repo, branch: repoCtx.branch });
+                if (started.tracked) {
+                    if (started.gated) {
+                        notify("This ticket needs approval in the YAGNI app before it shows as executing.", "warning");
+                    }
+                    return { runId: started.runId, workItemId: started.workItemId };
+                }
+                // Recording skipped (flag off) or failed (unauthorized / unreachable):
+                // tell the user the run won't show on the Work page rather than swallowing it.
+                notify(UNTRACKED_NOTICE[started.reason], "warning");
+                return {};
+            };
+            let resumeFrom;
+            let handle = {};
+            if (plan.mode === "resume_loop") {
+                notify(`Resuming /go for "${ticket}" from review round ${plan.round} — picking up the interrupted run instead of starting over.`, "info");
+                await pi.sendUserMessage(`Resuming an interrupted /go for "${ticket}" at review round ${plan.round}. The build is already in ${worktreeMode ? "the run worktree" : "your working tree"}; continuing the review loop.`);
+                resumeFrom = plan;
+                // Open a FRESH run attempt rather than re-binding the original handle.
+                // An interrupted run that slept past the reaper window is already a
+                // terminal 'failed' server-side, and binding it would strand THIS
+                // completed resume as a permanent phantom failure (failed is terminal —
+                // finish can't promote it). A fresh attempt records the resumed pass
+                // honestly; the original crashed attempt settles on its own (reaper).
+                handle = await openFreshRun();
+            }
+            else {
+                if (plan.mode === "warn_partial") {
+                    notify(WARN_PARTIAL_COPY[plan.reason], "warning");
+                    // We are DISCARDING the interrupted run's context (fresh journal, no
+                    // resumeFrom). If we adopted its worktree, its abandoned partial edits
+                    // are still in the tree — the diff-driven review would fold them in and
+                    // FINISH's worktree `git add -A` would commit them under a clean
+                    // provenance trailer (the "clean by construction" assumption is false
+                    // here). Preserve that residue as a WIP commit on the run branch so the
+                    // tree returns to its committed baseline before the fresh run: review
+                    // and FINISH then see only THIS run's work, and nothing is lost.
+                    if (adoptedWorktree && worktreeMode) {
+                        try {
+                            await commitWipFn(runCwd, wipCommitMessage(ticket, "interrupted-residue"));
+                        }
+                        catch {
+                            /* fail-soft: an uncommittable residue just stays; the warn stands */
+                        }
+                    }
+                }
+                // Fresh run: drop any stale/partial journal so the new run writes clean.
+                store.clear();
+                handle = await openFreshRun();
+            }
+            const checkpointMeta = {
+                sessionKey,
+                ...(handle.runId ? { runId: handle.runId } : {}),
+                ...(handle.workItemId ? { workItemId: handle.workItemId } : {}),
+                ...(repoCtx.repo ? { repo: repoCtx.repo } : {}),
+                ...(repoCtx.branch ? { branch: repoCtx.branch } : {}),
+            };
+            // Mark the journal terminal (fail-soft). A run_finish makes the key read as
+            // a COMPLETED run (so the next /go starts fresh, not a bogus resume); its
+            // absence is exactly what marks a crashed run resumable.
+            const recordRunFinish = (stopReason) => {
+                try {
+                    store.record({
+                        v: 1,
+                        kind: "run_finish",
+                        sessionKey,
+                        ts: Date.now(),
+                        ticket,
+                        ...(handle.runId ? { runId: handle.runId } : {}),
+                        ...(handle.workItemId ? { workItemId: handle.workItemId } : {}),
+                        stopReason: stopReason,
+                    });
+                }
+                catch {
+                    /* fail-soft */
+                }
+            };
+            // The run registry row (the LOCAL run identity — the backend handle lives
+            // on the checkpoint meta). Registered before the run detaches so the
+            // in-flight guards and /go-status see it immediately.
+            const registryRow = {
+                runId,
+                ticket,
+                sessionKey,
+                ...(repoCtx.repo ? { repo: repoCtx.repo } : {}),
+                ...(worktreePath ? { worktreePath } : {}),
+                ...(repoCtx.branch ? { branch: repoCtx.branch } : {}),
+                status: "running",
+                startedAt: now(),
+            };
+            // Wall-clock liveness heartbeat for the whole run; cleared in clearUI. Each
+            // tick is fail-soft and no-ops until the run is bound. Unref'd so it never
+            // keeps the process (or a test worker) alive.
+            heartbeatTimer = setInterval(() => void session.heartbeat(), HEARTBEAT_INTERVAL_MS);
+            heartbeatTimer.unref?.();
+            // Deliver the durable end-of-run handoff. A detached run completes while
+            // the agent may be mid-turn, so pi requires deliverAs; a delivery failure
+            // falls back to a notify (and /go-status remains the pull path).
+            const deliverHandoff = async (text, tone) => {
+                try {
+                    await pi.sendUserMessage(text, { deliverAs: "followUp" });
+                }
+                catch {
+                    try {
+                        notify(text, tone);
+                    }
+                    catch {
+                        /* the pull path (/go-status) still has the outcome */
+                    }
+                }
+            };
+            // Preserve a non-clean terminal outcome's work as a clearly-marked WIP
+            // commit on the run branch (worktree mode only — NEVER in --here, where the
+            // tree is the user's own). Fail-soft: an uncommittable tree just stays
+            // dirty and /go-clean reports it honestly.
+            const preserveWip = async (stopReason) => {
+                if (!worktreeMode)
+                    return undefined;
+                try {
+                    return await commitWipFn(runCwd, wipCommitMessage(ticket, stopReason));
+                }
+                catch {
+                    return undefined;
+                }
+            };
+            const runToCompletion = async () => {
+                try {
+                    // Steady animation ticker: keeps the spinner + elapsed clock live between
+                    // pipeline events. UI-only, self-unref'd so it never holds the loop open,
+                    // and cleared in clearUI on every exit path.
+                    if (ctx.hasUI && feed) {
+                        animationTimer = setInterval(doPaint, ANIMATION_INTERVAL_MS);
+                        animationTimer.unref?.();
+                    }
+                    // Resolve the ticket reference to its REAL brief (verbatim title + body) so
+                    // the agents plan on the actual ticket, not the bare "YAG-234". Fail-soft:
+                    // null keeps the raw arg (the honest blind fallback). The raw `ticket` stays
+                    // the session key, the run row's arg, and the handoff/re-run copy.
+                    const ticketBrief = await resolveTicketBrief(ticket);
+                    // The plan stage's output, captured off the onStage boundary for the
+                    // FINISH commit message's 2-3 sentence summary (absent on a resume).
+                    let planText;
+                    // Baseline dirt at pipeline start (post-bootstrap, post-adopt-cleanup):
+                    // anything already changed here is NOT the run's own work (a lockfile a
+                    // fresh-worktree install rewrote, or — in --here — the user's tree). FINISH
+                    // excludes these paths so the provenance commit holds only the run's diff.
+                    // Fail-soft: an unreadable snapshot ⇒ no exclusions (git add -A as before).
+                    let finishBaselinePaths = [];
+                    try {
+                        const baseSnap = await resolveSnapshot(runCwd, ctx.signal);
+                        if (baseSnap.tracked)
+                            finishBaselinePaths = parseChangedPaths(baseSnap.status);
+                    }
+                    catch {
+                        /* fail-soft: leave baseline empty */
+                    }
+                    const result = await runPipeline(ticket, {
+                        cwd: runCwd,
+                        signal: ctx.signal,
+                        ...(ticketBrief ? { ticketBrief } : {}),
+                        onProgress: (p) => {
+                            feed?.applyProgress(p);
+                            run?.applyProgress(p, Date.now());
+                            // The ribbon replaces the status chip on the desktop, so the chip is
+                            // only set for the terminal's status-line fallback.
+                            if (ctx.hasUI && !desktop) {
+                                const label = shortLabel(p);
+                                if (label !== undefined)
+                                    ctx.ui.setStatus?.(uiKey, label);
+                            }
+                            paint(isTransition(p));
+                        },
+                        onEvent: (ev, tag) => {
+                            if (!feed && !run)
+                                return;
+                            const at = Date.now();
+                            // Usage folds per agent regardless of whether this event also
+                            // produces a curated line, so per-lens token counts stay honest.
+                            run?.applyUsage(ev, tag, at);
+                            const line = eventToLine(ev, tag);
+                            if (line) {
+                                feed?.applyEvent(line, tag);
+                                run?.applyLine(line, tag, at);
+                            }
+                            else if (!run) {
+                                return;
+                            }
+                            paint(false);
+                        },
+                        onStage: (s) => {
+                            // The plan text rides ONLY the plan-finish boundary; strip it from the
+                            // stage beat (which never carries full text) and record the plan onto
+                            // the work item instead. Both calls are fail-soft inside the session.
+                            const { output, ...stageArgs } = s;
+                            void session.stage(stageArgs);
+                            if (s.stage === "plan" && s.phase === "finish" && output) {
+                                planText = output;
+                                void session.recordPlan({ stage: "plan", body: output });
+                            }
+                        },
+                        checkpoint: store,
+                        checkpointMeta,
+                        ...(resumeFrom ? { resumeFrom } : {}),
+                    });
+                    // FINISH stage (spec §3c): ONLY on a clean stop. Commit the run's work
+                    // (worktree always; --here only over a clean pre-run baseline) with the
+                    // provenance trailer, and push + PR when --pr asked for it. Iron
+                    // invariant (§0.1): a FINISH failure never flips the clean run to
+                    // failed and never fakes a commit — runFinish never throws, and the
+                    // belt-and-braces catch below degrades to an honest note anyway.
+                    let finish;
+                    if (result.stopReason === "clean") {
+                        feed?.applyProgress({ kind: "stage_start", stageId: "finish" });
+                        run?.applyProgress({ kind: "stage_start", stageId: "finish" }, Date.now());
+                        if (ctx.hasUI && !desktop)
+                            ctx.ui.setStatus?.(uiKey, "finish…");
+                        paint(true);
+                        void session.stage({ stage: "finish", phase: "start" });
+                        try {
+                            finish = await runFinishFn({
+                                cwd: runCwd,
+                                worktreeMode,
+                                hereBaseline,
+                                ...(repoCtx.branch ? { branch: repoCtx.branch } : {}),
+                                ticket,
+                                ...(ticketBrief ? { ticketBrief } : {}),
+                                ...(planText ? { planText } : {}),
+                                runId,
+                                verify: verifyTrailerValue(result),
+                                decisionsRecorded: result.decisionsRecorded ?? 0,
+                                rounds: result.rounds.length,
+                                openPr: parsed.flags.pr,
+                                remainingFindings: result.findings.filter((f) => f.severity === "medium" || f.severity === "low"),
+                                ...(finishBaselinePaths.length > 0 ? { baselinePaths: finishBaselinePaths } : {}),
+                                ...(ctx.signal ? { signal: ctx.signal } : {}),
+                            });
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            finish = {
+                                committed: false,
+                                notes: [`FINISH failed: ${msg}. The run itself is still clean; the changes are left in ${runCwd}.`],
+                            };
+                        }
+                        void session.stage({ stage: "finish", phase: "finish" });
+                        feed?.applyProgress({ kind: "stage_done", stageId: "finish" });
+                        run?.applyProgress({ kind: "stage_done", stageId: "finish" }, Date.now());
+                        paint(true);
+                        // Durable finish_done boundary (fail-soft, like every journal write).
+                        try {
+                            store.record({
+                                v: 1,
+                                kind: "finish_done",
+                                sessionKey,
+                                ts: Date.now(),
+                                ticket,
+                                ...(handle.runId ? { runId: handle.runId } : {}),
+                                ...(handle.workItemId ? { workItemId: handle.workItemId } : {}),
+                                ...(finish.commitSha ? { commitSha: finish.commitSha } : {}),
+                                ...(finish.prUrl ? { prUrl: finish.prUrl } : {}),
+                            });
+                        }
+                        catch {
+                            /* fail-soft */
+                        }
+                    }
+                    clearUI();
+                    // Fold what FINISH landed onto a NEW result (never mutate the pipeline's
+                    // return). `finish` is present ONLY when a commit really happened (§0.1).
+                    const finishBranch = finish?.branch ?? repoCtx.branch;
+                    const finishInfo = finish?.commitSha
+                        ? {
+                            commitSha: finish.commitSha,
+                            ...(finishBranch ? { branch: finishBranch } : {}),
+                            ...(finish.prUrl ? { prUrl: finish.prUrl } : {}),
+                            ...(finish.prNumber != null ? { prNumber: finish.prNumber } : {}),
+                        }
+                        : undefined;
+                    const finalResult = { ...result, ...(finishInfo ? { finish: finishInfo } : {}) };
+                    const outcome = outcomeFor(finalResult.stopReason);
+                    // The end-of-run recap: "what was done" (rounds, findings, stop reason).
+                    // The bare `recapBody` rides `finish` as the run_outcome activity (the
+                    // timeline labels that beat "Run outcome"); the prefixed `formatSummary`
+                    // is the standalone toast + scrollback line shown to the user below.
+                    // Non-clean terminal outcome in worktree mode: preserve the work as a
+                    // WIP commit so it is never lost and the worktree becomes removable.
+                    // (A clean outcome's commit is the FINISH stage's, captured above.)
+                    // Computed BEFORE session.finish so the run reports the sha that actually
+                    // holds its work — not the pre-run base HEAD (a base-HEAD fallback would
+                    // both misattribute the commit and spuriously advance a work-less run).
+                    const wipSha = finalResult.stopReason === "clean" ? undefined : await preserveWip(finalResult.stopReason);
+                    const runCommitSha = finishInfo?.commitSha ?? wipSha;
+                    const summary = formatSummary(finalResult);
+                    await session.finish({
+                        outcome,
+                        stopReason: outcome === "completed" ? undefined : STOP_REASON_COPY[finalResult.stopReason],
+                        branch: finishInfo?.branch ?? repoCtx.branch,
+                        ...(runCommitSha ? { commitSha: runCommitSha } : {}),
+                        ...(finishInfo?.prUrl ? { prUrl: finishInfo.prUrl } : {}),
+                        ...(finishInfo?.prNumber != null ? { prNumber: finishInfo.prNumber } : {}),
+                        rounds: finalResult.rounds.length,
+                        outcomeSummary: recapBody(finalResult),
+                    });
+                    recordRunFinish(finalResult.stopReason);
+                    settleRun(runId, {
+                        status: finalResult.stopReason,
+                        ...(runCommitSha ? { commitSha: runCommitSha } : {}),
+                        ...(finishInfo?.prUrl ? { prUrl: finishInfo.prUrl } : {}),
+                    });
+                    notify(summary, summaryTone(finalResult.stopReason));
+                    // The DURABLE record surfaces the unresolved blocking findings IN FULL
+                    // (file:line + message), so a later turn never has to rediscover them.
+                    await deliverHandoff(`${formatHandoff(finalResult, ticket)}${finishNote(finalResult, finish)}${worktreeNote(worktreePath, repoCtx.branch)}`, summaryTone(finalResult.stopReason));
+                }
+                catch (err) {
+                    clearUI();
+                    const message = err instanceof Error ? err.message : String(err);
+                    await session.finish({ outcome: "failed", stopReason: message });
+                    recordRunFinish("failed");
+                    const wipSha = await preserveWip("failed");
+                    settleRun(runId, { status: "failed", ...(wipSha ? { commitSha: wipSha } : {}) });
+                    notify(`/go failed: ${message}`, "error");
+                    await deliverHandoff(`/go failed: ${message}`, "error");
+                }
+            };
+            beginRun(registryRow);
+            if (parsed.flags.fg) {
+                // --fg: the legacy blocking behavior — the prompt returns when the run does.
+                await runToCompletion();
+                return;
+            }
+            // Detached by default: the prompt returns now; the tracked promise settles
+            // the registry row and delivers the handoff as a followUp when it lands.
+            // The backstop catch keeps a detached rejection from ever going unhandled
+            // (runToCompletion's own catch already reports honestly).
+            const done = runToCompletion().catch(() => {
+                try {
+                    settleRun(runId, { status: "failed" });
+                }
+                catch {
+                    /* fail-soft */
+                }
+            });
+            trackRunPromise(runId, done);
+            notify(`/go ${ticket} started in the background [${runShortId}]${worktreeMode ? ` on ${repoCtx.branch ?? "its run branch"} (worktree ${worktreePath})` : " (in place)"}. The handoff will arrive here when it finishes; /go-status to check on it.`, "info");
+        },
+    });
+    // The pull-path companions ride the same registration path (index.ts never
+    // changes): /go-status lists registry rows, /go-clean removes clean worktrees.
+    registerGoStatusCommands(pi, {
+        ...(deps.loadJournal ? { loadJournal: deps.loadJournal } : {}),
+        ...(deps.exists ? { exists: deps.exists } : {}),
+        ...(deps.now ? { now: deps.now } : {}),
+        ...(deps.resolveSnapshot ? { snapshot: deps.resolveSnapshot } : {}),
+        // /go-clean is per-repo: reuse this command's own git resolver so it only
+        // removes worktrees created from the current repo (fail-soft to no filter).
+        resolveRepo: (cwd, signal) => resolveRepoContext(cwd, signal).then((c) => c.repo).catch(() => undefined),
+    });
+}
+//# sourceMappingURL=goCommand.js.map