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

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

@@ -0,0 +1,48 @@
+/**
+ * R3-b - run-level budget / turn ceiling, enforced orchestrator-side.
+ *
+ * The frontier harnesses bound a run with a turn/budget ceiling; /go had none, so
+ * a pathological loop could spend without limit. These PURE helpers aggregate the
+ * per-stage usage the runner already records (StageResult.usage) across the whole
+ * run (build stages + every review lens + each fix) and report when an aggregate
+ * crosses a ceiling. The orchestrator stops honestly with `budget_exceeded` rather
+ * than running on.
+ *
+ * The turn cap is enforced here via aggregated `usage.turns` (not a pi --max-turns
+ * flag, which is unverified in the pi flag set; that is on the upstream-pi
+ * wishlist). Ceilings are generous safety bounds, not tight budgets, so a normal
+ * run never trips them.
+ */
+import type { ReviewRound, StageResult } from "./types.js";
+/** Aggregated usage across a whole run. */
+export interface RunUsage {
+    turns: number;
+    cost: number;
+    input: number;
+    output: number;
+}
+/** The run-level ceilings. */
+export interface RunBudget {
+    /** Max aggregate assistant turns across all stages. */
+    maxTurns: number;
+    /** Max aggregate cost (same unit as StageUsage.cost). */
+    maxCost: number;
+    /** Max aggregate input+output tokens. */
+    maxTokens: number;
+}
+/**
+ * Generous default ceilings: a 3-round /go fans out review across 3 lenses on top
+ * of the build half, so dozens of turns and millions of tokens are normal; these
+ * only catch a runaway. Tunable per lane.
+ */
+export declare const DEFAULT_RUN_BUDGET: RunBudget;
+export declare const EMPTY_RUN_USAGE: RunUsage;
+export declare function addRunUsage(a: RunUsage, b: RunUsage): RunUsage;
+/** Sum usage across the build/fix stages AND every review lens result. */
+export declare function aggregateRunUsage(stages: StageResult[], rounds: ReviewRound[]): RunUsage;
+/**
+ * Return an honest reason string when an aggregate usage crosses any ceiling, else
+ * null. Checked at each stage boundary so the run stops at the first crossing.
+ */
+export declare function exceedsBudget(usage: RunUsage, budget: RunBudget): string | null;
+//# sourceMappingURL=budget.d.ts.map

package/dist/extension/pipeline/budget.js

@@ -0,0 +1,68 @@
+/**
+ * R3-b - run-level budget / turn ceiling, enforced orchestrator-side.
+ *
+ * The frontier harnesses bound a run with a turn/budget ceiling; /go had none, so
+ * a pathological loop could spend without limit. These PURE helpers aggregate the
+ * per-stage usage the runner already records (StageResult.usage) across the whole
+ * run (build stages + every review lens + each fix) and report when an aggregate
+ * crosses a ceiling. The orchestrator stops honestly with `budget_exceeded` rather
+ * than running on.
+ *
+ * The turn cap is enforced here via aggregated `usage.turns` (not a pi --max-turns
+ * flag, which is unverified in the pi flag set; that is on the upstream-pi
+ * wishlist). Ceilings are generous safety bounds, not tight budgets, so a normal
+ * run never trips them.
+ */
+/**
+ * Generous default ceilings: a 3-round /go fans out review across 3 lenses on top
+ * of the build half, so dozens of turns and millions of tokens are normal; these
+ * only catch a runaway. Tunable per lane.
+ */
+export const DEFAULT_RUN_BUDGET = {
+    maxTurns: 400,
+    maxCost: 50,
+    maxTokens: 8_000_000,
+};
+export const EMPTY_RUN_USAGE = { turns: 0, cost: 0, input: 0, output: 0 };
+export function addRunUsage(a, b) {
+    return {
+        turns: a.turns + b.turns,
+        cost: a.cost + b.cost,
+        input: a.input + b.input,
+        output: a.output + b.output,
+    };
+}
+/** Sum usage across the build/fix stages AND every review lens result. */
+export function aggregateRunUsage(stages, rounds) {
+    const acc = { ...EMPTY_RUN_USAGE };
+    const add = (u) => {
+        acc.turns += u.turns;
+        acc.cost += u.cost;
+        acc.input += u.input;
+        acc.output += u.output;
+    };
+    for (const s of stages)
+        add(s.usage);
+    for (const r of rounds)
+        for (const l of r.lensResults)
+            add(l.usage);
+    return acc;
+}
+/**
+ * Return an honest reason string when an aggregate usage crosses any ceiling, else
+ * null. Checked at each stage boundary so the run stops at the first crossing.
+ */
+export function exceedsBudget(usage, budget) {
+    if (usage.turns > budget.maxTurns) {
+        return `turn ceiling reached (${usage.turns} of ${budget.maxTurns} model turns)`;
+    }
+    if (usage.cost > budget.maxCost) {
+        return `cost ceiling reached (${usage.cost.toFixed(2)} of ${budget.maxCost})`;
+    }
+    const tokens = usage.input + usage.output;
+    if (tokens > budget.maxTokens) {
+        return `token ceiling reached (${tokens} of ${budget.maxTokens} tokens)`;
+    }
+    return null;
+}
+//# sourceMappingURL=budget.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Fail-soft {@link CheckpointStore} implementations — the durable substrate
+ * behind /go resume.
+ *
+ * Three stores, all sharing the iron contract: NEVER throw, NEVER block /go.
+ *  - {@link makeFileCheckpointStore} — the durable PRIMARY. An append-only NDJSON
+ *    file at `~/.yagni-code/runs/<sha1(sessionKey)>.ndjson` (mkdir 0700, file
+ *    0600 — mirrors credentials.ts). Session-independent and auth-free, so a
+ *    LATER pi session (or one started after `/new`) can still read where /go
+ *    left off, even when the backend was unreachable. A torn final write is
+ *    harmless: load drops any unparseable line (the classic crash artifact).
+ *  - {@link makePiJournalCheckpointStore} — a MIRROR into pi's native append-only
+ *    session journal via `pi.appendEntry` / `sessionManager.getEntries`, the
+ *    pi-idiomatic persistence the user asked about. Constructed from function
+ *    seams so it is unit-testable without a pi process.
+ *  - {@link makeCombinedCheckpointStore} — writes to all stores; reads from the
+ *    first non-empty (file primary).
+ */
+import type { CheckpointStore } from "./types.js";
+export declare function _setCheckpointHomeForTest(dir: string | null): void;
+export declare function makeFileCheckpointStore(sessionKey: string): CheckpointStore;
+/** The pi customType under which checkpoint records live in the session journal. */
+export declare const PI_CHECKPOINT_CUSTOM_TYPE = "yagni-go-checkpoint";
+/** Function seams onto pi's ExtensionAPI/SessionManager (so this is testable without pi). */
+export interface PiJournalSeams {
+    appendEntry: (customType: string, data: unknown) => void;
+    getEntries: () => unknown[];
+}
+export declare function makePiJournalCheckpointStore(sessionKey: string, seams: PiJournalSeams): CheckpointStore;
+export declare function makeCombinedCheckpointStore(stores: CheckpointStore[]): CheckpointStore;
+//# sourceMappingURL=checkpoint.d.ts.map

package/dist/extension/pipeline/checkpoint.js

@@ -0,0 +1,176 @@
+/**
+ * Fail-soft {@link CheckpointStore} implementations — the durable substrate
+ * behind /go resume.
+ *
+ * Three stores, all sharing the iron contract: NEVER throw, NEVER block /go.
+ *  - {@link makeFileCheckpointStore} — the durable PRIMARY. An append-only NDJSON
+ *    file at `~/.yagni-code/runs/<sha1(sessionKey)>.ndjson` (mkdir 0700, file
+ *    0600 — mirrors credentials.ts). Session-independent and auth-free, so a
+ *    LATER pi session (or one started after `/new`) can still read where /go
+ *    left off, even when the backend was unreachable. A torn final write is
+ *    harmless: load drops any unparseable line (the classic crash artifact).
+ *  - {@link makePiJournalCheckpointStore} — a MIRROR into pi's native append-only
+ *    session journal via `pi.appendEntry` / `sessionManager.getEntries`, the
+ *    pi-idiomatic persistence the user asked about. Constructed from function
+ *    seams so it is unit-testable without a pi process.
+ *  - {@link makeCombinedCheckpointStore} — writes to all stores; reads from the
+ *    first non-empty (file primary).
+ */
+import { appendFileSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { codeStateHome } from "../stateHome.js";
+/**
+ * Test seam mirroring credentials.ts `_setYagniCodeHomeForTest`: when set, the
+ * runs dir roots here instead of `~/.yagni-code`, so tests hit a tmpdir. Pass
+ * `null` to restore.
+ */
+let homeOverride = null;
+export function _setCheckpointHomeForTest(dir) {
+    homeOverride = dir;
+}
+function checkpointHome() {
+    return codeStateHome(homeOverride);
+}
+function runsDir() {
+    return join(checkpointHome(), "runs");
+}
+/** One file per run key; the key is hashed so arbitrary ticket text is path-safe. */
+function keyFile(sessionKey) {
+    const hash = createHash("sha1").update(sessionKey).digest("hex");
+    return join(runsDir(), `${hash}.ndjson`);
+}
+export function makeFileCheckpointStore(sessionKey) {
+    return {
+        record(rec) {
+            try {
+                mkdirSync(runsDir(), { recursive: true, mode: 0o700 });
+                const file = keyFile(sessionKey);
+                // Self-heal a torn previous write: if the file ends mid-line (a crash
+                // dropped the trailing newline), prefix one so OUR record lands on its
+                // own line. Otherwise an append would glue onto the torn fragment and
+                // load() would drop BOTH as one unparseable line. The fragment itself is
+                // still dropped on load; only the next record is protected.
+                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(rec)}\n`, { mode: 0o600 });
+            }
+            catch {
+                /* fail-soft: a checkpoint write must never break /go */
+            }
+        },
+        load() {
+            try {
+                const raw = readFileSync(keyFile(sessionKey), "utf8");
+                const out = [];
+                for (const line of raw.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const obj = JSON.parse(line);
+                        // Drop garbage/torn lines; defensively re-check the key.
+                        if (obj && obj.sessionKey === sessionKey)
+                            out.push(obj);
+                    }
+                    catch {
+                        /* unparseable (torn final write) — drop this line, keep the rest */
+                    }
+                }
+                return out;
+            }
+            catch {
+                return []; // missing/unreadable → fresh run
+            }
+        },
+        clear() {
+            try {
+                rmSync(keyFile(sessionKey), { force: true });
+            }
+            catch {
+                /* fail-soft */
+            }
+        },
+    };
+}
+/** The pi customType under which checkpoint records live in the session journal. */
+export const PI_CHECKPOINT_CUSTOM_TYPE = "yagni-go-checkpoint";
+export function makePiJournalCheckpointStore(sessionKey, seams) {
+    return {
+        record(rec) {
+            try {
+                seams.appendEntry(PI_CHECKPOINT_CUSTOM_TYPE, rec);
+            }
+            catch {
+                /* fail-soft */
+            }
+        },
+        load() {
+            try {
+                const entries = seams.getEntries() ?? [];
+                const out = [];
+                for (const e of entries) {
+                    const entry = e;
+                    if (entry?.type === "custom" &&
+                        entry.customType === PI_CHECKPOINT_CUSTOM_TYPE &&
+                        entry.data?.sessionKey === sessionKey) {
+                        out.push(entry.data);
+                    }
+                }
+                return out;
+            }
+            catch {
+                return [];
+            }
+        },
+        clear() {
+            // pi's journal is append-only — it cannot delete. The caller writes a
+            // terminal `run_finish` record via record() on completion, which already
+            // makes this key read as non-resumable, so clear() is a no-op here.
+        },
+    };
+}
+export function makeCombinedCheckpointStore(stores) {
+    return {
+        record(rec) {
+            for (const s of stores) {
+                try {
+                    s.record(rec);
+                }
+                catch {
+                    /* fail-soft */
+                }
+            }
+        },
+        load() {
+            for (const s of stores) {
+                try {
+                    const recs = s.load();
+                    if (recs.length > 0)
+                        return recs;
+                }
+                catch {
+                    /* try the next store */
+                }
+            }
+            return [];
+        },
+        clear() {
+            for (const s of stores) {
+                try {
+                    s.clear();
+                }
+                catch {
+                    /* fail-soft */
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=checkpoint.js.map

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

@@ -0,0 +1,168 @@
+/**
+ * M6 - the grounded-vs-blind eval engine (REPORT-ONLY).
+ *
+ * The Phase-1 grounding GATE: run the SAME ticket twice, once grounded (the real
+ * /go) and once blind (grounding tools stripped + grounding-free personas), then
+ * score each lane's change for business fit against this company's recorded
+ * judgment and report the delta. It validates the entire only-YAGNI thesis: does
+ * the weaker grounded model out-ship the stronger guessing one?
+ *
+ * CRITICAL: this is strictly report-only. Its output is NEVER wired to model
+ * selection, the opaque tiers, or any routing decision (FIT auto-routing is an
+ * explicitly cut item). It is meaningful only on a context-rich real workspace
+ * with real decisions/corrections, so the live run is dogfood, not CI; this module
+ * is the pure engine + report formatter, exercised in tests with injected seams.
+ *
+ * `blindStages` and `formatComparisonReport` are PURE. `makeGroundedVsBlindEval`
+ * orchestrates two injected lane runs + an injected fit scorer, so it is unit
+ * tested without spawning a child or touching the network.
+ */
+import type { ModelTier, PipelineResult, PipelineStage } from "./types.js";
+/** The grounding tools the blind lane must not be able to call. */
+export declare const GROUNDING_TOOLS: readonly ["ask_yagni", "record_decision", "review_business_match"];
+/** Capture/write-back tools are never exposed in report-only eval lanes. */
+export declare const CAPTURE_TOOLS: readonly ["record_decision", "record_engineering_context"];
+/**
+ * Strip the grounding tools from every stage. The blind lane then runs without
+ * this company's judgment or retrieved context.
+ */
+export declare function blindStages(stages?: PipelineStage[]): PipelineStage[];
+/** Strip capture/write-back tools so eval lanes can only produce the report. */
+export declare function reportOnlyStages(stages?: PipelineStage[]): PipelineStage[];
+/**
+ * The stages whose model choice IS the judgment-tier decision: decide-what
+ * (plan) and catch-wrong (review). Kept as data so the transform below and any
+ * future lane agree on what "judgment" means.
+ */
+export declare const JUDGMENT_STAGE_IDS: readonly ["plan", "review"];
+/**
+ * Set the judgment stages to a given tier, leaving execution stages untouched.
+ * PURE: returns new stage objects.
+ *
+ * This is the seam for answering the question YAG-380 actually poses — not "is
+ * K3 good" but "does K3 on plan+review produce better changes than GLM 5.2
+ * does". Because it only touches plan and review, a comparison built on it
+ * moves exactly one variable.
+ */
+export declare function withJudgmentTier(stages: PipelineStage[] | undefined, tier: ModelTier): PipelineStage[];
+/**
+ * Which lane an outcome belongs to.
+ *
+ * Two comparisons ride this engine today: grounded-vs-blind (does grounding
+ * beat guessing) and peak-vs-advanced judgment (does the stronger model on
+ * plan+review produce better changes). Both are two-lane A/Bs scored the same
+ * way, so the lane is DATA rather than a hardcoded union.
+ */
+export type Lane = "grounded" | "blind" | "peak_judgment" | "advanced_judgment";
+/** A lane's id plus how it is named in the report. */
+export interface LaneSpec {
+    id: Lane;
+    label: string;
+}
+/** The grounding GATE: the real /go against a grounding-suppressed twin. */
+export declare const GROUNDED_LANES: {
+    readonly treatment: {
+        readonly id: "grounded";
+        readonly label: "Grounded";
+    };
+    readonly baseline: {
+        readonly id: "blind";
+        readonly label: "Blind";
+    };
+};
+/** The judgment-tier question: peak on plan+review against advanced on plan+review. */
+export declare const JUDGMENT_LANES: {
+    readonly treatment: {
+        readonly id: "peak_judgment";
+        readonly label: "Peak judgment";
+    };
+    readonly baseline: {
+        readonly id: "advanced_judgment";
+        readonly label: "Advanced judgment";
+    };
+};
+/**
+ * A lane's business-fit score, produced by running the GROUNDED
+ * review_business_match against that lane's final diff (so both lanes are judged
+ * by the same recorded company judgment). The /review endpoint returns prose +
+ * citations rather than a number, so the qualitative `review` text is the real
+ * signal; `conflicts` and `citations` are coarse comparable counts.
+ */
+export interface LaneFit {
+    /** review_business_match prose verdict on this lane's diff. */
+    review: string;
+    /** Count of cited decisions/conventions the review surfaced. */
+    citations: number;
+    /** Count of flagged conflicts with recorded judgment (lower is better fit). */
+    conflicts: number;
+    /** Honest note when scoring could not run (fail-soft). */
+    note?: string;
+}
+/** One lane's full outcome: the pipeline result plus its fit score. */
+export interface LaneOutcome {
+    lane: LaneSpec;
+    result: PipelineResult;
+    fit: LaneFit;
+}
+/** The full comparison handed back to the command (and rendered into the report). */
+export interface ComparisonReport {
+    ticket: string;
+    /** The lane under test (grounded / peak judgment). */
+    treatment: LaneOutcome;
+    /** The lane it is measured against (blind / advanced judgment). */
+    baseline: LaneOutcome;
+    /** treatment.conflicts - baseline.conflicts; negative means the treatment reduced conflicts. */
+    conflictDelta: number;
+    /** Rendered markdown report (no em-dashes). */
+    report: string;
+}
+/** Injectable seams so the engine is unit-tested without spawning or network. */
+export interface ComparisonSeams {
+    /** Run one lane's pipeline end to end and return its result. */
+    runLane: (lane: Lane, ticket: string) => Promise<PipelineResult>;
+    /** Score one lane's change for business fit against recorded judgment. */
+    scoreFit: (lane: Lane, result: PipelineResult) => Promise<LaneFit>;
+}
+/**
+ * Per-comparison wording. The engine and the arithmetic are shared, but a
+ * grounding result and a judgment-tier result mean different things, so each
+ * gets copy that says what its number actually shows.
+ */
+export interface ComparisonCopy {
+    title: string;
+    /** Labels the headline number, e.g. "FIT delta (blind conflicts minus grounded conflicts)". */
+    deltaLabel: string;
+    /** Renders the verdict from the signed delta, where positive favours the treatment. */
+    verdict: (favor: number) => string;
+    /** Closing honesty note about what the report is and is not. */
+    footer: string;
+}
+export declare const GROUNDED_COPY: ComparisonCopy;
+export declare const JUDGMENT_COPY: ComparisonCopy;
+/**
+ * Render the comparative report a human reads. Leads with the headline conflict
+ * delta (the GATE number), then each lane's stop reason, finding tally, and fit
+ * verdict. States plainly that this is report-only and never wired to routing.
+ *
+ * The arithmetic is shared across comparisons; `copy` supplies the wording so a
+ * grounding result and a judgment-tier result each say what their number means.
+ */
+export declare function formatComparisonReport(input: Omit<ComparisonReport, "report">, copy?: ComparisonCopy): string;
+/**
+ * Build a two-lane eval runner. Runs the treatment lane, then the baseline lane,
+ * scores each, and returns the comparison + rendered report. Both lane runs and
+ * the scorer are injected, so this is fully deterministic in tests.
+ *
+ * Lanes run SEQUENTIALLY on purpose: each spawns a full /go pipeline over a real
+ * worktree, and running them concurrently would contend for the same machine and
+ * muddy any latency signal.
+ */
+export declare function makeComparisonEval(seams: ComparisonSeams, lanes: {
+    treatment: LaneSpec;
+    baseline: LaneSpec;
+}, copy: ComparisonCopy): (ticket: string) => Promise<ComparisonReport>;
+/** The grounding GATE, named for what it measures. */
+export declare function makeGroundedVsBlindEval(seams: ComparisonSeams): (ticket: string) => Promise<ComparisonReport>;
+/** The judgment-tier question: peak on plan+review against advanced (YAG-380). */
+export declare function makeJudgmentTierEval(seams: ComparisonSeams): (ticket: string) => Promise<ComparisonReport>;
+//# sourceMappingURL=eval.d.ts.map

package/dist/extension/pipeline/eval.js

@@ -0,0 +1,182 @@
+/**
+ * M6 - the grounded-vs-blind eval engine (REPORT-ONLY).
+ *
+ * The Phase-1 grounding GATE: run the SAME ticket twice, once grounded (the real
+ * /go) and once blind (grounding tools stripped + grounding-free personas), then
+ * score each lane's change for business fit against this company's recorded
+ * judgment and report the delta. It validates the entire only-YAGNI thesis: does
+ * the weaker grounded model out-ship the stronger guessing one?
+ *
+ * CRITICAL: this is strictly report-only. Its output is NEVER wired to model
+ * selection, the opaque tiers, or any routing decision (FIT auto-routing is an
+ * explicitly cut item). It is meaningful only on a context-rich real workspace
+ * with real decisions/corrections, so the live run is dogfood, not CI; this module
+ * is the pure engine + report formatter, exercised in tests with injected seams.
+ *
+ * `blindStages` and `formatComparisonReport` are PURE. `makeGroundedVsBlindEval`
+ * orchestrates two injected lane runs + an injected fit scorer, so it is unit
+ * tested without spawning a child or touching the network.
+ */
+import { selectStages } from "./stages.js";
+/** The grounding tools the blind lane must not be able to call. */
+export const GROUNDING_TOOLS = ["ask_yagni", "record_decision", "review_business_match"];
+/** Capture/write-back tools are never exposed in report-only eval lanes. */
+export const CAPTURE_TOOLS = ["record_decision", "record_engineering_context"];
+/**
+ * Strip selected tools from every stage's `--tools` whitelist. The child pi may
+ * still have a tool registered, but a tool absent from the stage whitelist cannot
+ * be called. Pure: returns new stage objects, leaves the input untouched.
+ */
+function stripStageTools(stages, tools) {
+    const drop = new Set(tools);
+    return stages.map((s) => ({ ...s, tools: s.tools.filter((t) => !drop.has(t)) }));
+}
+/**
+ * Strip the grounding tools from every stage. The blind lane then runs without
+ * this company's judgment or retrieved context.
+ */
+export function blindStages(stages = selectStages("full")) {
+    return stripStageTools(stages, GROUNDING_TOOLS);
+}
+/** Strip capture/write-back tools so eval lanes can only produce the report. */
+export function reportOnlyStages(stages = selectStages("full")) {
+    return stripStageTools(stages, CAPTURE_TOOLS);
+}
+/**
+ * The stages whose model choice IS the judgment-tier decision: decide-what
+ * (plan) and catch-wrong (review). Kept as data so the transform below and any
+ * future lane agree on what "judgment" means.
+ */
+export const JUDGMENT_STAGE_IDS = ["plan", "review"];
+/**
+ * Set the judgment stages to a given tier, leaving execution stages untouched.
+ * PURE: returns new stage objects.
+ *
+ * This is the seam for answering the question YAG-380 actually poses — not "is
+ * K3 good" but "does K3 on plan+review produce better changes than GLM 5.2
+ * does". Because it only touches plan and review, a comparison built on it
+ * moves exactly one variable.
+ */
+export function withJudgmentTier(stages = selectStages("full"), tier) {
+    const judgment = new Set(JUDGMENT_STAGE_IDS);
+    return stages.map((s) => (judgment.has(s.id) ? { ...s, model: tier } : s));
+}
+/** The grounding GATE: the real /go against a grounding-suppressed twin. */
+export const GROUNDED_LANES = {
+    treatment: { id: "grounded", label: "Grounded" },
+    baseline: { id: "blind", label: "Blind" },
+};
+/** The judgment-tier question: peak on plan+review against advanced on plan+review. */
+export const JUDGMENT_LANES = {
+    treatment: { id: "peak_judgment", label: "Peak judgment" },
+    baseline: { id: "advanced_judgment", label: "Advanced judgment" },
+};
+export const GROUNDED_COPY = {
+    title: "Grounded vs blind eval",
+    deltaLabel: "FIT delta (blind conflicts minus grounded conflicts)",
+    verdict: (favor) => favor > 0
+        ? `Grounding REDUCED business-fit conflicts by ${favor} on this ticket.`
+        : favor < 0
+            ? `Grounding showed ${Math.abs(favor)} MORE flagged conflict${Math.abs(favor) === 1 ? "" : "s"} on this ticket (investigate: a thin or noisy corpus can do this).`
+            : "Grounding and blind tied on flagged conflicts for this ticket.",
+    footer: "Report only. This comparison is never wired to model selection, tiers, or routing. Run it on a context-rich workspace with real recorded decisions for a meaningful number.",
+};
+export const JUDGMENT_COPY = {
+    title: "Peak vs advanced judgment eval",
+    deltaLabel: "FIT delta (advanced-judgment conflicts minus peak-judgment conflicts)",
+    verdict: (favor) => favor > 0
+        ? `Peak on plan and review REDUCED business-fit conflicts by ${favor} on this ticket.`
+        : favor < 0
+            ? `Peak on plan and review showed ${Math.abs(favor)} MORE flagged conflict${Math.abs(favor) === 1 ? "" : "s"} on this ticket. The judgment upgrade did not pay for itself here.`
+            : "Peak and advanced judgment tied on flagged conflicts for this ticket.",
+    footer: "Report only. This comparison is never wired to model selection, tiers, or routing. Only plan and review differ between the lanes, so the delta isolates the judgment tier. One ticket is an anecdote; run several before concluding.",
+};
+const blocking = (findings) => findings.filter((f) => f.severity === "critical" || f.severity === "high").length;
+/**
+ * Render the comparative report a human reads. Leads with the headline conflict
+ * delta (the GATE number), then each lane's stop reason, finding tally, and fit
+ * verdict. States plainly that this is report-only and never wired to routing.
+ *
+ * The arithmetic is shared across comparisons; `copy` supplies the wording so a
+ * grounding result and a judgment-tier result each say what their number means.
+ */
+export function formatComparisonReport(input, copy = GROUNDED_COPY) {
+    const { ticket, treatment, baseline, conflictDelta } = input;
+    const lane = (o) => {
+        const total = o.result.findings.length;
+        const block = blocking(o.result.findings);
+        const fit = o.fit.note
+            ? `fit scoring skipped (${o.fit.note})`
+            : `${o.fit.conflicts} fit conflict${o.fit.conflicts === 1 ? "" : "s"}, ${o.fit.citations} citation${o.fit.citations === 1 ? "" : "s"}`;
+        return [
+            `### ${o.lane.label} lane`,
+            `- stop reason: ${o.result.stopReason}`,
+            `- findings: ${total} (${block} blocking)`,
+            `- business fit: ${fit}`,
+            o.fit.review.trim() ? `\n${o.fit.review.trim()}` : "",
+        ]
+            .filter(Boolean)
+            .join("\n");
+    };
+    // baseline minus treatment: positive favors the treatment. Show an explicit
+    // sign, but never render "+0" (a tie reads as 0).
+    const favor = -conflictDelta;
+    const signed = `${favor > 0 ? "+" : ""}${favor}`;
+    return [
+        `## ${copy.title}: ${ticket}`,
+        "",
+        `${copy.deltaLabel}: ${signed}. ${copy.verdict(favor)}`,
+        "",
+        lane(treatment),
+        "",
+        lane(baseline),
+        "",
+        copy.footer,
+    ].join("\n");
+}
+/**
+ * Build a two-lane eval runner. Runs the treatment lane, then the baseline lane,
+ * scores each, and returns the comparison + rendered report. Both lane runs and
+ * the scorer are injected, so this is fully deterministic in tests.
+ *
+ * Lanes run SEQUENTIALLY on purpose: each spawns a full /go pipeline over a real
+ * worktree, and running them concurrently would contend for the same machine and
+ * muddy any latency signal.
+ */
+export function makeComparisonEval(seams, lanes, copy) {
+    return async function compare(ticket) {
+        const treatmentResult = await seams.runLane(lanes.treatment.id, ticket);
+        const baselineResult = await seams.runLane(lanes.baseline.id, ticket);
+        const [treatmentFit, baselineFit] = await Promise.all([
+            seams.scoreFit(lanes.treatment.id, treatmentResult),
+            seams.scoreFit(lanes.baseline.id, baselineResult),
+        ]);
+        const treatment = {
+            lane: lanes.treatment,
+            result: treatmentResult,
+            fit: treatmentFit,
+        };
+        const baseline = {
+            lane: lanes.baseline,
+            result: baselineResult,
+            fit: baselineFit,
+        };
+        const conflictDelta = treatmentFit.conflicts - baselineFit.conflicts;
+        return {
+            ticket,
+            treatment,
+            baseline,
+            conflictDelta,
+            report: formatComparisonReport({ ticket, treatment, baseline, conflictDelta }, copy),
+        };
+    };
+}
+/** The grounding GATE, named for what it measures. */
+export function makeGroundedVsBlindEval(seams) {
+    return makeComparisonEval(seams, GROUNDED_LANES, GROUNDED_COPY);
+}
+/** The judgment-tier question: peak on plan+review against advanced (YAG-380). */
+export function makeJudgmentTierEval(seams) {
+    return makeComparisonEval(seams, JUDGMENT_LANES, JUDGMENT_COPY);
+}
+//# sourceMappingURL=eval.js.map