@yagni-app/code 0.1.0 → 0.2.0

package/dist/extension/pipeline/resume.js

@@ -0,0 +1,106 @@
+/**
+ * PURE resume-decision core — the analogue of `findings.ts#shouldStop`.
+ *
+ * Given the append-only checkpoint journal for a run key and a LIVE workspace
+ * snapshot, decide whether /go can safely resume the bounded review→fix loop,
+ * must warn about a partially-built / diverged tree, or should just run fresh.
+ *
+ * Safety boundary (the whole point): we only auto-resume the EXPENSIVE half (the
+ * review→fix loop) and only when the build half fully completed AND the live git
+ * tree still matches the boundary we checkpointed. A crash mid-build, or a tree
+ * that drifted since the checkpoint, would risk double-applying edits if we
+ * replayed — so those resolve to `warn_partial` (warn + run fresh), never a
+ * silent replay. Anything unknowable fails OPEN to `fresh` (mirrors
+ * `workspaceChanged`). The fold never throws.
+ */
+import { EMPTY_RUN_USAGE } from "./budget.js";
+/** Two snapshots match only when BOTH are present, tracked, and identical (HEAD + status). */
+function snapshotsMatch(a, b) {
+    return Boolean(a) && Boolean(b) && a.tracked && b.tracked && a.head === b.head && a.status === b.status;
+}
+/** The last record of a given kind, or undefined. */
+function lastOfKind(records, kind) {
+    for (let i = records.length - 1; i >= 0; i -= 1) {
+        if (records[i]?.kind === kind)
+            return records[i];
+    }
+    return undefined;
+}
+export function planResume(records, liveSnapshot) {
+    try {
+        if (!Array.isArray(records) || records.length === 0)
+            return { mode: "fresh" };
+        // A terminal run_finish means the run completed (even `round_cap`) — a
+        // completed run is NOT an interrupted one, so it is never resumable. A
+        // finish_done is equally terminal: the FINISH stage only runs after a clean
+        // stop, so a crash in the narrow window before run_finish lands must not
+        // read as "resumable" over a tree the FINISH commit has since moved.
+        if (records.some((r) => r?.kind === "run_finish" || r?.kind === "finish_done"))
+            return { mode: "fresh" };
+        const runStart = records.find((r) => r?.kind === "run_start");
+        if (!runStart)
+            return { mode: "fresh" }; // no anchor → nothing trustworthy to resume
+        const ticket = runStart.ticket;
+        const buildDone = lastOfKind(records, "build_done");
+        if (!buildDone) {
+            // Interrupted during the build half: the tree may hold partial edits, so
+            // replaying review against it would be wrong. Warn; the caller runs fresh.
+            return { mode: "warn_partial", reason: "build_interrupted", ticket };
+        }
+        const roundDones = records.filter((r) => r?.kind === "round_done");
+        const latest = roundDones.length > 0 ? maxByRound(roundDones) : buildDone;
+        // Unknowable tree (not a git work tree) → fail open to fresh rather than
+        // claim a resume we cannot verify.
+        if (!liveSnapshot?.tracked)
+            return { mode: "fresh" };
+        // The live tree must still be exactly where we checkpointed it; otherwise an
+        // orphaned child or a manual edit drifted it and replay is unsafe.
+        if (!snapshotsMatch(latest.snapshot, liveSnapshot)) {
+            return { mode: "warn_partial", reason: "tree_diverged", ticket };
+        }
+        if (roundDones.length === 0) {
+            // Build done, no round completed → resume at round 1 against implement output.
+            return {
+                mode: "resume_loop",
+                round: 1,
+                reviewInput: buildDone.reviewInput ?? "",
+                priorRounds: [],
+                priorUsage: buildDone.usage ?? EMPTY_RUN_USAGE,
+                ...handle(runStart),
+                ticket,
+            };
+        }
+        const maxRound = Math.max(...roundDones.map((r) => r.round ?? 0));
+        const lastRound = roundDones.find((r) => (r.round ?? 0) === maxRound) ?? buildDone;
+        const priorRounds = roundDones
+            .slice()
+            .sort((a, b) => (a.round ?? 0) - (b.round ?? 0))
+            .map((r) => ({ round: r.round ?? 0, lensResults: [], findings: r.findings ?? [] }));
+        return {
+            mode: "resume_loop",
+            round: maxRound + 1,
+            reviewInput: lastRound.reviewInput ?? "",
+            priorRounds,
+            priorUsage: lastRound.usage ?? buildDone.usage ?? EMPTY_RUN_USAGE,
+            ...handle(runStart),
+            ticket,
+        };
+    }
+    catch {
+        return { mode: "fresh" };
+    }
+}
+/** The record carrying the highest `round`. */
+function maxByRound(records) {
+    return records.reduce((a, b) => ((b.round ?? 0) >= (a.round ?? 0) ? b : a));
+}
+/** Pull the optional backend handle off the run_start record (omit undefined keys). */
+function handle(runStart) {
+    const out = {};
+    if (runStart.runId)
+        out.runId = runStart.runId;
+    if (runStart.workItemId)
+        out.workItemId = runStart.workItemId;
+    return out;
+}
+//# sourceMappingURL=resume.js.map

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

@@ -0,0 +1,37 @@
+/**
+ * Task 8 (/go summary prints a per-stage, server-priced cost table): a pure
+ * formatter over `GET /api/yagni-code/spend?runId=`'s response (see
+ * costHud.ts's SpendResponse/SpendRow mirror for the shape this reads).
+ *
+ * Kept out of costHud.ts deliberately: that module's `formatServerCostLines`
+ * renders a SESSION's spend grouped by rate tier (for /cost); this renders ONE
+ * RUN's spend grouped by PIPELINE STAGE (for /go's end-of-run summary), and the
+ * grouping/merge rules below (fold the three review lenses into one line,
+ * mixed-tier tie-break) are specific enough to this call site that sharing a
+ * module would just make costHud.ts harder to read for its own surface.
+ *
+ * Caller labels are minted by runner.ts as `go:<stage.id>` (or
+ * `go:<stage.id>:<lens>` for the fanned-out review stage) — see
+ * `callerLabel` in runner.ts. This module's `stageKeyForCaller` is the inverse
+ * mapping back to a display row.
+ */
+import type { SpendResponse } from "../costHud.js";
+/**
+ * Render /go's end-of-run, server-priced cost table. Pure, no em-dashes,
+ * multi-line (joined with "\n"), leading space on the header/total lines so it
+ * reads as a continuation of the preceding recap sentence (matches
+ * runCostNote's own leading-space convention in goCommand.ts).
+ *
+ * Example:
+ * ```
+ *  Run cost (server):
+ *    map        standard    $0.05
+ *    plan       peak        $0.31
+ *    implement  standard    $0.12
+ *    review     peak        $0.34
+ *    fix        standard    $0.04
+ *  Run: $0.84 billed. $2.71 at frontier list. 69% saved.
+ * ```
+ */
+export declare function formatRunCostTable(spend: SpendResponse): string;
+//# sourceMappingURL=runCostTable.d.ts.map

package/dist/extension/pipeline/runCostTable.js

@@ -0,0 +1,165 @@
+/**
+ * Task 8 (/go summary prints a per-stage, server-priced cost table): a pure
+ * formatter over `GET /api/yagni-code/spend?runId=`'s response (see
+ * costHud.ts's SpendResponse/SpendRow mirror for the shape this reads).
+ *
+ * Kept out of costHud.ts deliberately: that module's `formatServerCostLines`
+ * renders a SESSION's spend grouped by rate tier (for /cost); this renders ONE
+ * RUN's spend grouped by PIPELINE STAGE (for /go's end-of-run summary), and the
+ * grouping/merge rules below (fold the three review lenses into one line,
+ * mixed-tier tie-break) are specific enough to this call site that sharing a
+ * module would just make costHud.ts harder to read for its own surface.
+ *
+ * Caller labels are minted by runner.ts as `go:<stage.id>` (or
+ * `go:<stage.id>:<lens>` for the fanned-out review stage) — see
+ * `callerLabel` in runner.ts. This module's `stageKeyForCaller` is the inverse
+ * mapping back to a display row.
+ */
+import { usd } from "../costHud.js";
+import { PIPELINE_V1 } from "./stages.js";
+/**
+ * Pipeline stages in the order /go actually runs them, DERIVED from
+ * PIPELINE_V1 (stages.ts's single source of truth) rather than a hand-copied
+ * list — a future stage added there self-registers here in order, with
+ * nothing in this file to update or drift out of sync.
+ */
+const STAGE_ORDER = PIPELINE_V1.map((s) => s.id);
+/**
+ * Map a `GET /spend` caller label onto its display stage, or undefined for a
+ * caller this table does not recognize (surfaced instead as its own row,
+ * verbatim, after the known stages — see {@link buildRows}). `go:review` and
+ * every `go:review:<lens>` caller fold onto the single "review" row: the three
+ * adversarial lenses are one conceptual review pass, and a per-lens
+ * breakdown would just be noise in an end-of-run summary.
+ *
+ * Derives the mapping from STAGE_ORDER (advisor is the one non-pipeline
+ * exception, matched exactly) rather than hand-listing each `go:<id>`
+ * caller, so a stage added to PIPELINE_V1 needs no update here either: strip
+ * the `go:` prefix, take the first `:`-delimited segment (folds `go:review`
+ * and every `go:review:<lens>` onto the same "review" segment), and check it
+ * against the known stage ids.
+ */
+function stageKeyForCaller(caller) {
+    if (caller === "advisor")
+        return "advisor";
+    if (!caller.startsWith("go:"))
+        return undefined;
+    const segment = caller.slice(3).split(":")[0];
+    return STAGE_ORDER.includes(segment) ? segment : undefined;
+}
+const sumSell = (rows) => rows.reduce((acc, r) => acc + r.sellMillicents, 0);
+/**
+ * The tier shown for a (possibly multi-row) line: the rows' COMMON tier when
+ * they all billed under the same one, else the tier of whichever contributing
+ * row spent the most (a re-ask retry on `efficient`, or a server-side reroute,
+ * can leave one caller split across two tiers — the biggest-spend tier is the
+ * more honest single label than an arbitrary first-seen one).
+ */
+function bucketTier(rows) {
+    const first = rows[0];
+    if (!first)
+        return "";
+    if (rows.every((r) => r.rateTier === first.rateTier))
+        return first.rateTier;
+    let biggest = first;
+    for (const r of rows) {
+        if (r.sellMillicents > biggest.sellMillicents)
+            biggest = r;
+    }
+    return biggest.rateTier;
+}
+/**
+ * Group spend rows into display rows: known pipeline stages (in pipeline
+ * order, review merged), then advisor when present, then every unrecognized
+ * caller (e.g. `subagent:foo`, `unattributed`, a bare `driver`) as its own
+ * row, sorted by spend descending (ties broken alphabetically, so output is
+ * deterministic). A stage with zero recorded dispatches is omitted rather
+ * than shown at $0.00: /go always runs map/plan/implement, but review/fix are
+ * absent on a run that stopped before reaching them (e.g. `no_changes`).
+ */
+function buildRows(spendRows) {
+    const known = new Map();
+    const unknown = new Map();
+    for (const row of spendRows) {
+        const key = stageKeyForCaller(row.caller);
+        const bucket = key ?? row.caller;
+        const target = key ? known : unknown;
+        const list = target.get(bucket) ?? [];
+        list.push(row);
+        target.set(bucket, list);
+    }
+    const rows = [];
+    for (const stage of STAGE_ORDER) {
+        const stageRows = known.get(stage);
+        if (!stageRows || stageRows.length === 0)
+            continue;
+        rows.push({ label: stage, tier: bucketTier(stageRows), sellMillicents: sumSell(stageRows) });
+    }
+    const advisorRows = known.get("advisor");
+    if (advisorRows && advisorRows.length > 0) {
+        rows.push({ label: "advisor", tier: bucketTier(advisorRows), sellMillicents: sumSell(advisorRows) });
+    }
+    const unknownRows = [...unknown.entries()]
+        .map(([caller, r]) => ({ label: caller, tier: bucketTier(r), sellMillicents: sumSell(r) }))
+        .sort((a, b) => b.sellMillicents - a.sellMillicents || a.label.localeCompare(b.label));
+    rows.push(...unknownRows);
+    return rows;
+}
+/**
+ * `Run: $A billed. $B at frontier list. NN% saved.` — the "at frontier
+ * list" + savings clause only renders when `savingsPercent` resolved (typeof
+ * guard, matching formatServerCostLines's own malformed-response caution: a
+ * network response is untyped at runtime).
+ *
+ * `counterfactualIncomplete` and a numeric `savingsPercent` are MUTUALLY
+ * EXCLUSIVE by construction on the server (yagniCodeSpend.ts sets
+ * `savingsPercent` null whenever `counterfactualIncomplete` is true — there is
+ * no honest percentage to report when some billed spend fell on a tier with no
+ * Anthropic list-price counterfactual). So `counterfactualIncomplete` is
+ * checked on the non-number branch, not as a caveat appended to the number
+ * branch (that would be unreachable dead code, and would silently drop the
+ * whole savings clause on a partial counterfactual with no explanation).
+ */
+function totalLine(spend) {
+    const billed = `$${usd(spend.totalSellMillicents)} billed.`;
+    if (typeof spend.savingsPercent !== "number") {
+        return spend.counterfactualIncomplete
+            ? ` Run: ${billed} Savings not shown: some spend billed on an unpriced tier.`
+            : ` Run: ${billed}`;
+    }
+    return ` Run: ${billed} $${usd(spend.totalCounterfactualMillicents)} at frontier list. ${spend.savingsPercent}% saved.`;
+}
+/**
+ * Render /go's end-of-run, server-priced cost table. Pure, no em-dashes,
+ * multi-line (joined with "\n"), leading space on the header/total lines so it
+ * reads as a continuation of the preceding recap sentence (matches
+ * runCostNote's own leading-space convention in goCommand.ts).
+ *
+ * Example:
+ * ```
+ *  Run cost (server):
+ *    map        standard    $0.05
+ *    plan       peak        $0.31
+ *    implement  standard    $0.12
+ *    review     peak        $0.34
+ *    fix        standard    $0.04
+ *  Run: $0.84 billed. $2.71 at frontier list. 69% saved.
+ * ```
+ */
+export function formatRunCostTable(spend) {
+    const rows = buildRows(spend.rows);
+    const labelWidth = rows.reduce((m, r) => Math.max(m, r.label.length), 0);
+    const tierWidth = rows.reduce((m, r) => Math.max(m, r.tier.length), 0);
+    const lines = [" Run cost (server):"];
+    for (const r of rows) {
+        lines.push(`   ${r.label.padEnd(labelWidth + 2)}${r.tier.padEnd(tierWidth + 2)}$${usd(r.sellMillicents)}`);
+    }
+    lines.push(totalLine(spend));
+    if (spend.unbilledSellMillicents > 0) {
+        // Matches formatServerCostLines' + YagniCodeUsageView.tsx's wording for
+        // the same figure.
+        lines.push(`   Includes $${usd(spend.unbilledSellMillicents)} not yet billed (insufficient credits or a billing error).`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=runCostTable.js.map

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

@@ -0,0 +1,112 @@
+/**
+ * The /go run registry (spec §3b — detached-by-default).
+ *
+ * Detached runs outlive the prompt that started them, so /go needs one place
+ * that answers "what is running / finished / interrupted?": a module-scoped
+ * IN-MEMORY registry (the live truth for THIS process: in-flight guard,
+ * MAX_CONCURRENT_RUNS, the completion promise) mirrored to an append-only
+ * NDJSON file at `~/.yagni-code/registry.ndjson` (dir 0700, file 0600 —
+ * mirrors checkpoint.ts) so a LATER session can list finished runs, spot an
+ * interrupted one, and resume into its worktree.
+ *
+ * The mirror is append-only and torn-line-tolerant (same crash model as
+ * checkpoint.ts): every state change appends the FULL row again and readers
+ * fold last-write-wins by runId, so a torn final write costs at most the last
+ * update, never the file. All writes are fail-soft — registry bookkeeping must
+ * never break /go.
+ *
+ * Liveness is decided by the PURE {@link classifyRunLiveness}: a non-terminal
+ * row is `in_flight` when this process holds it, otherwise the run's checkpoint
+ * journal decides — recent activity (< 30 min) means it is probably running in
+ * another process (`active_elsewhere`), stale means `interrupted` (a resume
+ * candidate).
+ */
+import type { CheckpointRecord, StopReason } from "./types.js";
+/** Bound on simultaneously in-flight /go runs in one process (spec §3b). */
+export declare const MAX_CONCURRENT_RUNS = 3;
+/**
+ * A non-terminal row whose journal has been quiet this long is treated as
+ * INTERRUPTED (its process died) rather than still running elsewhere. Sits
+ * comfortably past the 5-min run heartbeat and the server reaper's 30-min
+ * staleness window so the two views agree.
+ */
+export declare const JOURNAL_STALE_MS: number;
+/**
+ * One registry row (the spec's frozen shape). `status` is `running` until the
+ * run reaches a terminal outcome, then the honest stop reason; `cleaned` marks
+ * a terminal row whose worktree /go-clean has removed. `runId` is the LOCAL
+ * run identity (minted before the backend run row exists — the worktree dir and
+ * UI key derive from its first 8 chars), not the backend runs-row id.
+ */
+export interface RunRegistryRow {
+    runId: string;
+    ticket: string;
+    sessionKey: string;
+    repo?: string;
+    /** Absent for an in-place (--here) run. */
+    worktreePath?: string;
+    branch?: string;
+    status: RunRegistryStatus;
+    startedAt: number;
+    commitSha?: string;
+    prUrl?: string;
+}
+export type RunRegistryStatus = "running" | "cleaned" | StopReason;
+/** Everything except `running` is terminal (the run is not in flight anywhere). */
+export declare function isTerminalStatus(status: RunRegistryStatus): boolean;
+/** How a registry row relates to live execution right now. */
+export type RunLiveness = "in_flight" | "active_elsewhere" | "interrupted" | "terminal";
+/**
+ * PURE liveness verdict for one row. `inFlight` is this process's in-memory
+ * truth; `lastJournalTs` is the newest checkpoint-journal timestamp for the
+ * row's sessionKey (fall back to `startedAt` when the run never journaled).
+ */
+export declare function classifyRunLiveness(row: RunRegistryRow, opts: {
+    inFlight: boolean;
+    lastJournalTs?: number;
+    now: number;
+}): RunLiveness;
+/** The newest checkpoint timestamp in a run's journal (0 when empty). */
+export declare function lastJournalTs(records: CheckpointRecord[]): number;
+/**
+ * Fold raw NDJSON mirror lines into rows, last-write-wins by runId, preserving
+ * first-seen order. Pure + torn-line-tolerant: unparseable or shape-less lines
+ * are dropped (the classic crash artifact), never fatal.
+ */
+export declare function foldRegistryLines(lines: string[]): RunRegistryRow[];
+export declare function _setRegistryHomeForTest(dir: string | null): void;
+/** The append-only NDJSON mirror file. */
+export declare function registryFile(): string;
+/** Where detached run worktrees live (never inside the repo — spec §6). */
+export declare function worktreesDir(): string;
+/** Test seam: clear the in-memory half (simulates a process restart; the mirror survives). */
+export declare function _resetRunRegistryForTest(): void;
+/** Mark a run in-flight in this process and mirror the row. Never throws. */
+export declare function beginRun(row: RunRegistryRow): void;
+/** Attach the detached completion promise to an in-flight run (fail-soft no-op when absent). */
+export declare function trackRunPromise(runId: string, promise: Promise<void>): void;
+/**
+ * Settle an in-flight run: merge the terminal patch, drop it from the in-memory
+ * active set, and mirror the final row. Safe to call for an unknown runId: the
+ * patch lands against the last known mirror row when one exists, or against the
+ * patch itself when the caller supplied a full row (the /go-clean path, whose
+ * rows may come through an injected registry read).
+ */
+export declare function settleRun(runId: string, patch: Partial<RunRegistryRow> & {
+    status: RunRegistryStatus;
+}): void;
+/** How many runs this process currently has in flight. */
+export declare function activeRunCount(): number;
+/** The in-flight row for a ticket in THIS process, if any (the same-ticket guard). */
+export declare function findActiveRunByTicket(ticket: string): RunRegistryRow | undefined;
+/** Is this runId in flight in THIS process? */
+export declare function isRunInFlight(runId: string): boolean;
+/** Test seam: await every in-flight run's completion promise. */
+export declare function _awaitActiveRunsForTest(): Promise<void>;
+/**
+ * The merged registry view: the NDJSON mirror folded last-write-wins, with this
+ * process's in-memory rows overlaid (they are the fresher truth when a mirror
+ * write was lost). Never throws; an unreadable mirror yields the in-memory rows.
+ */
+export declare function loadRegistryRows(): RunRegistryRow[];
+//# sourceMappingURL=runRegistry.d.ts.map

package/dist/extension/pipeline/runRegistry.js

@@ -0,0 +1,202 @@
+/**
+ * The /go run registry (spec §3b — detached-by-default).
+ *
+ * Detached runs outlive the prompt that started them, so /go needs one place
+ * that answers "what is running / finished / interrupted?": a module-scoped
+ * IN-MEMORY registry (the live truth for THIS process: in-flight guard,
+ * MAX_CONCURRENT_RUNS, the completion promise) mirrored to an append-only
+ * NDJSON file at `~/.yagni-code/registry.ndjson` (dir 0700, file 0600 —
+ * mirrors checkpoint.ts) so a LATER session can list finished runs, spot an
+ * interrupted one, and resume into its worktree.
+ *
+ * The mirror is append-only and torn-line-tolerant (same crash model as
+ * checkpoint.ts): every state change appends the FULL row again and readers
+ * fold last-write-wins by runId, so a torn final write costs at most the last
+ * update, never the file. All writes are fail-soft — registry bookkeeping must
+ * never break /go.
+ *
+ * Liveness is decided by the PURE {@link classifyRunLiveness}: a non-terminal
+ * row is `in_flight` when this process holds it, otherwise the run's checkpoint
+ * journal decides — recent activity (< 30 min) means it is probably running in
+ * another process (`active_elsewhere`), stale means `interrupted` (a resume
+ * candidate).
+ */
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { codeStateHome } from "../stateHome.js";
+/** Bound on simultaneously in-flight /go runs in one process (spec §3b). */
+export const MAX_CONCURRENT_RUNS = 3;
+/**
+ * A non-terminal row whose journal has been quiet this long is treated as
+ * INTERRUPTED (its process died) rather than still running elsewhere. Sits
+ * comfortably past the 5-min run heartbeat and the server reaper's 30-min
+ * staleness window so the two views agree.
+ */
+export const JOURNAL_STALE_MS = 30 * 60_000;
+/** Everything except `running` is terminal (the run is not in flight anywhere). */
+export function isTerminalStatus(status) {
+    return status !== "running";
+}
+/**
+ * PURE liveness verdict for one row. `inFlight` is this process's in-memory
+ * truth; `lastJournalTs` is the newest checkpoint-journal timestamp for the
+ * row's sessionKey (fall back to `startedAt` when the run never journaled).
+ */
+export function classifyRunLiveness(row, opts) {
+    if (isTerminalStatus(row.status))
+        return "terminal";
+    if (opts.inFlight)
+        return "in_flight";
+    const last = opts.lastJournalTs ?? row.startedAt;
+    return opts.now - last > JOURNAL_STALE_MS ? "interrupted" : "active_elsewhere";
+}
+/** The newest checkpoint timestamp in a run's journal (0 when empty). */
+export function lastJournalTs(records) {
+    let max = 0;
+    for (const r of records) {
+        if (typeof r?.ts === "number" && r.ts > max)
+            max = r.ts;
+    }
+    return max;
+}
+/**
+ * Fold raw NDJSON mirror lines into rows, last-write-wins by runId, preserving
+ * first-seen order. Pure + torn-line-tolerant: unparseable or shape-less lines
+ * are dropped (the classic crash artifact), never fatal.
+ */
+export function foldRegistryLines(lines) {
+    const byId = new Map();
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            if (!row || typeof row.runId !== "string" || typeof row.ticket !== "string")
+                continue;
+            if (typeof row.sessionKey !== "string" || typeof row.status !== "string")
+                continue;
+            byId.set(row.runId, row);
+        }
+        catch {
+            /* torn/garbage line — drop it, keep the rest */
+        }
+    }
+    return [...byId.values()];
+}
+// ---------------------------------------------------------------------------
+// State-dir seams (mirrors checkpoint.ts `_setCheckpointHomeForTest`).
+// ---------------------------------------------------------------------------
+let homeOverride = null;
+export function _setRegistryHomeForTest(dir) {
+    homeOverride = dir;
+}
+function registryHome() {
+    return codeStateHome(homeOverride);
+}
+/** The append-only NDJSON mirror file. */
+export function registryFile() {
+    return join(registryHome(), "registry.ndjson");
+}
+/** Where detached run worktrees live (never inside the repo — spec §6). */
+export function worktreesDir() {
+    return join(registryHome(), "worktrees");
+}
+const active = new Map();
+/** Test seam: clear the in-memory half (simulates a process restart; the mirror survives). */
+export function _resetRunRegistryForTest() {
+    active.clear();
+}
+/** Fail-soft append of one full row to the mirror (self-heals a torn previous write). */
+function appendRow(row) {
+    try {
+        mkdirSync(registryHome(), { recursive: true, mode: 0o700 });
+        const file = registryFile();
+        let prefix = "";
+        try {
+            const existing = readFileSync(file);
+            if (existing.length > 0 && existing[existing.length - 1] !== 0x0a)
+                prefix = "\n";
+        }
+        catch {
+            /* no file yet — nothing to heal */
+        }
+        appendFileSync(file, `${prefix}${JSON.stringify(row)}\n`, { mode: 0o600 });
+    }
+    catch {
+        /* fail-soft: registry bookkeeping must never break /go */
+    }
+}
+/** Mark a run in-flight in this process and mirror the row. Never throws. */
+export function beginRun(row) {
+    active.set(row.runId, { row });
+    appendRow(row);
+}
+/** Attach the detached completion promise to an in-flight run (fail-soft no-op when absent). */
+export function trackRunPromise(runId, promise) {
+    const entry = active.get(runId);
+    if (entry)
+        entry.promise = promise;
+}
+/**
+ * Settle an in-flight run: merge the terminal patch, drop it from the in-memory
+ * active set, and mirror the final row. Safe to call for an unknown runId: the
+ * patch lands against the last known mirror row when one exists, or against the
+ * patch itself when the caller supplied a full row (the /go-clean path, whose
+ * rows may come through an injected registry read).
+ */
+export function settleRun(runId, patch) {
+    const entry = active.get(runId);
+    const base = entry?.row ??
+        loadRegistryRows().find((r) => r.runId === runId) ??
+        (isFullRow(patch) ? patch : undefined);
+    active.delete(runId);
+    if (!base)
+        return;
+    appendRow({ ...base, ...patch, runId: base.runId ?? runId });
+}
+/** Does a settle patch carry the whole row shape (usable as its own base)? */
+function isFullRow(patch) {
+    return (typeof patch.runId === "string" &&
+        typeof patch.ticket === "string" &&
+        typeof patch.sessionKey === "string" &&
+        typeof patch.startedAt === "number");
+}
+/** How many runs this process currently has in flight. */
+export function activeRunCount() {
+    return active.size;
+}
+/** The in-flight row for a ticket in THIS process, if any (the same-ticket guard). */
+export function findActiveRunByTicket(ticket) {
+    for (const entry of active.values()) {
+        if (entry.row.ticket === ticket)
+            return entry.row;
+    }
+    return undefined;
+}
+/** Is this runId in flight in THIS process? */
+export function isRunInFlight(runId) {
+    return active.has(runId);
+}
+/** Test seam: await every in-flight run's completion promise. */
+export async function _awaitActiveRunsForTest() {
+    await Promise.all([...active.values()].map((e) => e.promise ?? Promise.resolve()));
+}
+/**
+ * The merged registry view: the NDJSON mirror folded last-write-wins, with this
+ * process's in-memory rows overlaid (they are the fresher truth when a mirror
+ * write was lost). Never throws; an unreadable mirror yields the in-memory rows.
+ */
+export function loadRegistryRows() {
+    let rows = [];
+    try {
+        rows = foldRegistryLines(readFileSync(registryFile(), "utf8").split("\n"));
+    }
+    catch {
+        rows = [];
+    }
+    const byId = new Map(rows.map((r) => [r.runId, r]));
+    for (const entry of active.values())
+        byId.set(entry.row.runId, entry.row);
+    return [...byId.values()];
+}
+//# sourceMappingURL=runRegistry.js.map