@yagni-app/code-staging 0.1.0-staging.997.1 → 0.2.0-staging.1025.1

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

@@ -45,15 +45,32 @@ export declare const JUDGMENT_STAGE_IDS: readonly ["plan", "review"];
  * moves exactly one variable.
  */
 export declare function withJudgmentTier(stages: PipelineStage[] | undefined, tier: ModelTier): PipelineStage[];
+/**
+ * The map stage's model choice IS the map-tier decision. Kept as data,
+ * mirroring {@link JUDGMENT_STAGE_IDS}, so the transform below and any future
+ * lane agree on what "map tier" means. Currently a single stage, but an array
+ * so a future lane that widens "map" to more than one stage is a data change.
+ */
+export declare const MAP_STAGE_IDS: readonly ["map"];
+/**
+ * Set the map stage to a given tier, leaving every other stage untouched.
+ * PURE: returns new stage objects, mirroring {@link withJudgmentTier}'s shape.
+ *
+ * This is the seam for the Task 13 gate: does map on `standard` produce a
+ * meaningfully better repo brief than map on `efficient`, or is the cheaper
+ * tier good enough for a step whose job is compression, not judgment.
+ */
+export declare function withMapTier(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.
+ * Three comparisons ride this engine today: grounded-vs-blind (does grounding
+ * beat guessing), peak-vs-advanced judgment (does the stronger model on
+ * plan+review produce better changes), and standard-vs-efficient map (does
+ * the pricier tier on the map stage produce better changes). All 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";
+export type Lane = "grounded" | "blind" | "peak_judgment" | "advanced_judgment" | "map_standard" | "map_efficient";
 /** A lane's id plus how it is named in the report. */
 export interface LaneSpec {
     id: Lane;
@@ -81,6 +98,23 @@ export declare const JUDGMENT_LANES: {
         readonly label: "Advanced judgment";
     };
 };
+/**
+ * The map-tier question (Task 13): standard on map against efficient on map.
+ * `standard` is the treatment (the pricier, currently-shipped lane) so the
+ * verdict answers "does paying for standard over efficient on map pay off",
+ * matching how {@link JUDGMENT_LANES} always puts the more expensive lane in
+ * `treatment`.
+ */
+export declare const MAP_TIER_LANES: {
+    readonly treatment: {
+        readonly id: "map_standard";
+        readonly label: "Map standard";
+    };
+    readonly baseline: {
+        readonly id: "map_efficient";
+        readonly label: "Map efficient";
+    };
+};
 /**
  * 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
@@ -139,6 +173,7 @@ export interface ComparisonCopy {
 }
 export declare const GROUNDED_COPY: ComparisonCopy;
 export declare const JUDGMENT_COPY: ComparisonCopy;
+export declare const MAP_TIER_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
@@ -165,4 +200,6 @@ export declare function makeComparisonEval(seams: ComparisonSeams, lanes: {
 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>;
+/** The map-tier question: standard on map against efficient on map (Task 13). */
+export declare function makeMapTierEval(seams: ComparisonSeams): (ticket: string) => Promise<ComparisonReport>;
 //# sourceMappingURL=eval.d.ts.map

package/dist/extension/pipeline/eval.js

@@ -61,6 +61,25 @@ 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 map stage's model choice IS the map-tier decision. Kept as data,
+ * mirroring {@link JUDGMENT_STAGE_IDS}, so the transform below and any future
+ * lane agree on what "map tier" means. Currently a single stage, but an array
+ * so a future lane that widens "map" to more than one stage is a data change.
+ */
+export const MAP_STAGE_IDS = ["map"];
+/**
+ * Set the map stage to a given tier, leaving every other stage untouched.
+ * PURE: returns new stage objects, mirroring {@link withJudgmentTier}'s shape.
+ *
+ * This is the seam for the Task 13 gate: does map on `standard` produce a
+ * meaningfully better repo brief than map on `efficient`, or is the cheaper
+ * tier good enough for a step whose job is compression, not judgment.
+ */
+export function withMapTier(stages = selectStages("full"), tier) {
+    const mapStages = new Set(MAP_STAGE_IDS);
+    return stages.map((s) => (mapStages.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" },
@@ -71,6 +90,17 @@ export const JUDGMENT_LANES = {
     treatment: { id: "peak_judgment", label: "Peak judgment" },
     baseline: { id: "advanced_judgment", label: "Advanced judgment" },
 };
+/**
+ * The map-tier question (Task 13): standard on map against efficient on map.
+ * `standard` is the treatment (the pricier, currently-shipped lane) so the
+ * verdict answers "does paying for standard over efficient on map pay off",
+ * matching how {@link JUDGMENT_LANES} always puts the more expensive lane in
+ * `treatment`.
+ */
+export const MAP_TIER_LANES = {
+    treatment: { id: "map_standard", label: "Map standard" },
+    baseline: { id: "map_efficient", label: "Map efficient" },
+};
 export const GROUNDED_COPY = {
     title: "Grounded vs blind eval",
     deltaLabel: "FIT delta (blind conflicts minus grounded conflicts)",
@@ -91,6 +121,16 @@ export const JUDGMENT_COPY = {
             : "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.",
 };
+export const MAP_TIER_COPY = {
+    title: "Standard vs efficient map eval",
+    deltaLabel: "FIT delta (efficient-map conflicts minus standard-map conflicts)",
+    verdict: (favor) => favor > 0
+        ? `Standard on map REDUCED business-fit conflicts by ${favor} on this ticket.`
+        : favor < 0
+            ? `Standard on map showed ${Math.abs(favor)} MORE flagged conflict${Math.abs(favor) === 1 ? "" : "s"} on this ticket. The map tier upgrade did not pay for itself here.`
+            : "Standard and efficient map tied on flagged conflicts for this ticket.",
+    footer: "Report only. This comparison is never wired to model selection, tiers, or routing. Only the map stage differs between the lanes, so the delta isolates the map 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
@@ -179,4 +219,8 @@ export function makeGroundedVsBlindEval(seams) {
 export function makeJudgmentTierEval(seams) {
     return makeComparisonEval(seams, JUDGMENT_LANES, JUDGMENT_COPY);
 }
+/** The map-tier question: standard on map against efficient on map (Task 13). */
+export function makeMapTierEval(seams) {
+    return makeComparisonEval(seams, MAP_TIER_LANES, MAP_TIER_COPY);
+}
 //# sourceMappingURL=eval.js.map

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

@@ -58,6 +58,8 @@
  * is fail-soft, so recording can never break `/go`.
  */
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { SpendResponse } from "../costHud.js";
+import { type CrashReporter } from "../crashReport.js";
 import { runFinish as defaultRunFinish } from "./finish.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 import { makeRunSession as defaultMakeRunSession } from "./runSession.js";
@@ -97,12 +99,28 @@ export interface RegisterGoDeps {
     runFinish?: typeof defaultRunFinish;
     /** Injectable journal read for cross-process liveness (default: the file checkpoint store). */
     loadJournal?: (sessionKey: string) => CheckpointRecord[];
+    /**
+     * Task 8: fetch the server-authoritative per-stage spend for one /go run
+     * (`GET /api/yagni-code/spend?runId=`, wired in index.ts reusing Task 7's
+     * fetch machinery). Absent (no dep wired), throwing, or resolving null all
+     * fall back to the local `runCostNote` client estimate — see
+     * `resolveCostText` below. No default here: unlike every other network dep
+     * on this interface, index.ts is the ONLY real wiring (there is nothing
+     * sensible to default to without a baseUrl/token), and every test that
+     * cares injects its own fake.
+     */
+    fetchRunSpend?: (runId: string, signal?: AbortSignal) => Promise<SpendResponse | null>;
     /** Injectable fs existence check (worktree adoption on resume). */
     exists?: (path: string) => boolean;
     /** Clock seam for registry rows + staleness. */
     now?: () => number;
     baseUrl?: string;
     getToken?: () => string | undefined;
+    /**
+     * Crash reporter for the run's terminal catch (a THROWN error, not a
+     * verdict-shaped failure). Fail-soft and fire-and-forget by contract.
+     */
+    reportCrash?: CrashReporter;
 }
 /**
  * Per-run UI key prefix: the widget/status keys are `yagni-go:<runShortId>` so

package/dist/extension/pipeline/goCommand.js

@@ -65,8 +65,11 @@ import { eventToLine } from "./activity.js";
 import { ActivityFeed, SPINNER_FRAMES } from "./activityFeed.js";
 import { RunState } from "./runState.js";
 import { aggregateRunUsage } from "./budget.js";
+import { formatRunCostTable } from "./runCostTable.js";
 import { makeCombinedCheckpointStore, makeFileCheckpointStore, makePiJournalCheckpointStore, } from "./checkpoint.js";
 import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
+import { makeCrashReporter } from "../crashReport.js";
+import { scrubSecrets } from "./scrubSecrets.js";
 import { isDesktopSurface } from "../surface.js";
 import { runFinish as defaultRunFinish, verifyTrailerValue, } from "./finish.js";
 import { GO_USAGE, parseGoArgs } from "./goFlags.js";
@@ -75,6 +78,7 @@ 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 { recordSessionRun } from "../sessionRuns.js";
 import { resolveTicketBrief as defaultResolveTicketBrief } from "./ticketResolution.js";
 import { snapshotWorkspace as defaultSnapshotWorkspace } from "./workspace.js";
 import { parseChangedPaths } from "./verify.js";
@@ -168,9 +172,9 @@ function finishNote(result, finish) {
         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);
+/** Blocking-finding detail appended to the DURABLE handoff (spec: surface findings, not counts). `costText` — see `resolveCostText` (Task 8). */
+function formatHandoff(result, ticket, costText) {
+    const summary = formatSummaryForChat(result, costText);
     const degraded = `${degradedLensNote(result)}${verifyNote(result)}`;
     const blocking = result.findings.filter((f) => f.severity === "critical" || f.severity === "high");
     if (blocking.length === 0)
@@ -235,23 +239,41 @@ function outcomeFor(stopReason) {
         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) {
+/** Stop reason + the review tally, with NO cost segment and no prefix — the shared core of `recapBody`/`recapBodyForChat` below. */
+function tallyLine(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));
+        `${total} finding${total === 1 ? "" : "s"} (${blocking} blocking).`);
+}
+/**
+ * The bare "what was done" recap — stop reason + the review tally + the LOCAL
+ * cost estimate — with NO "YAGNI Code /go finished:" prefix. This is what
+ * rides `finish` as the `run_outcome` activity body (session.finish's
+ * `outcomeSummary`), which must stay synchronous: it is recorded as part of
+ * ending the run and must never wait on the Task 8 server spend fetch. The
+ * chat-facing summary (`recapBodyForChat`, below) is the one that prefers the
+ * server-priced table when it is available. The Work-page timeline already
+ * labels this beat "Run outcome", so prefixing here would double up into "Run
+ * outcome: YAGNI Code /go finished: ...". `formatSummaryForChat` re-adds the
+ * prefix for the standalone toast + scrollback line, where the context is
+ * useful on its own.
+ */
+function recapBody(result) {
+    return `${tallyLine(result)}${runCostNote(result)}`;
+}
+/**
+ * Chat-facing recap: the same tally as `recapBody`, but the cost segment is
+ * `costText` — precomputed by `resolveCostText` (Task 8), which is either the
+ * multi-line server-priced table or the labeled local-estimate fallback.
+ * Kept distinct from `recapBody` because `costText` requires an async fetch
+ * that `recapBody`'s caller (session.finish's outcomeSummary) cannot wait on.
+ */
+function recapBodyForChat(result, costText) {
+    return `${tallyLine(result)}${costText}`;
 }
 /**
  * What the run actually cost.
@@ -271,14 +293,62 @@ function runCostNote(result) {
     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.
+ * Task 8: resolve the cost segment for the CHAT-FACING summary (the toast +
+ * the durable handoff) — the server-priced per-stage table
+ * (`formatRunCostTable`) when this run is tracked and the fetch succeeds,
+ * else today's local `runCostNote` estimate, explicitly labeled "(client
+ * estimate)" so it is never mistaken for the priced total. Mirrors
+ * `registerCostCommand`'s own fail-soft preference order in costHud.ts.
+ *
+ * Never throws and never blocks long: `fetchRunSpend` (index.ts) already
+ * carries its own request timeout (same 5s ceiling as /cost's fetches), and
+ * this wraps the ENTIRE body — not just the fetch — in try/catch. That is
+ * deliberate, not belt-and-braces: the caller (see `runToCompletion` below)
+ * starts this promise and leaves it un-awaited for a while so session.finish
+ * never waits on it, so a throw ANYWHERE in here between promise creation and
+ * that later `await` — including from `runCostNote`/`formatRunCostTable` on a
+ * malformed result, not just from the fetch itself — would otherwise surface
+ * as a guaranteed unhandled rejection during that gap, independent of
+ * whatever the caller does with the eventual value.
+ *
+ * An empty-rows response is treated the same as "unavailable" (mirrors
+ * registerCostCommand's `serverLooksStale` guard): a run that billed real
+ * spend but whose rows have not landed yet would otherwise render a
+ * misleading "$0.00 (server)" table instead of the honest local estimate.
  */
-function formatSummary(result) {
-    return `YAGNI Code /go finished: ${recapBody(result)}`;
+async function resolveCostText(result, runId, fetchRunSpend, signal) {
+    try {
+        if (runId && fetchRunSpend) {
+            try {
+                const spend = await fetchRunSpend(runId, signal);
+                if (spend && spend.rows.length > 0)
+                    return formatRunCostTable(spend);
+            }
+            catch {
+                /* fail-soft: fall through to the local client estimate below */
+            }
+        }
+        const local = runCostNote(result);
+        return local ? `${local} (client estimate)` : "";
+    }
+    catch {
+        // Truly can't say anything honest (even the local estimate blew up):
+        // no cost text at all, matching runCostNote's own "nothing to report" ""
+        // convention rather than fabricating a number.
+        return "";
+    }
+}
+/**
+ * One-line-or-more, 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. `costText`
+ * carries the Task 8 cost segment (`resolveCostText`'s result: the
+ * server-priced table, or its labeled local-estimate fallback).
+ */
+function formatSummaryForChat(result, costText) {
+    return `YAGNI Code /go finished: ${recapBodyForChat(result, costText)}`;
 }
 /**
  * User-facing notice when a /go run is NOT being recorded on the Work page.
@@ -351,8 +421,17 @@ export function registerGoCommand(pi, deps = {}) {
     const loadJournal = deps.loadJournal ?? ((sessionKey) => makeFileCheckpointStore(sessionKey).load());
     const exists = deps.exists ?? existsSync;
     const now = deps.now ?? Date.now;
+    // Task 8: no default — see the RegisterGoDeps doc comment for why (only
+    // index.ts's real wiring makes sense here; absent, `resolveCostText` falls
+    // back to the local client estimate).
+    const fetchRunSpend = deps.fetchRunSpend;
     const resolveTicketBrief = deps.resolveTicketBrief ??
         ((rawArg) => defaultResolveTicketBrief({ baseUrl: deps.baseUrl ?? resolveBaseUrl(), getToken: deps.getToken ?? defaultGetToken }, rawArg));
+    const reportCrash = deps.reportCrash ??
+        makeCrashReporter({
+            baseUrl: deps.baseUrl ?? resolveBaseUrl(),
+            getToken: deps.getToken ?? defaultGetToken,
+        });
     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) => {
@@ -667,6 +746,22 @@ export function registerGoCommand(pi, deps = {}) {
                 ...(repoCtx.repo ? { repo: repoCtx.repo } : {}),
                 ...(repoCtx.branch ? { branch: repoCtx.branch } : {}),
             };
+            // YAG-383: this run's dispatches bill under handle.runId, not this
+            // driver session's id (see attributionHeaders in config.ts), so /cost's
+            // server-authoritative spend fetch would never see them without being
+            // told this run id explicitly. Record it the moment it is known (same
+            // gate as the attribution header above: only when the run is tracked).
+            if (handle.runId)
+                recordSessionRun(handle.runId);
+            // Desktop parity (Task 9): the desktop's /spend join needs this same
+            // server UUID (`run.runId` on the wire record is the LOCAL 8-char short
+            // id used for widget/status keys, never the join key). Stamp it the
+            // moment it is known and paint IMMEDIATELY — not the trailing-edge
+            // debounce — so a fast-finishing run's last few paints still carry it.
+            if (handle.runId && run) {
+                run.setServerRunId(handle.runId);
+                paint(true);
+            }
             // 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.
@@ -892,8 +987,9 @@ export function registerGoCommand(pi, deps = {}) {
                     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.
+                    // timeline labels that beat "Run outcome"); the prefixed
+                    // `formatSummaryForChat` 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.)
@@ -902,7 +998,13 @@ export function registerGoCommand(pi, deps = {}) {
                     // 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);
+                    // Task 8: START the server-priced fetch here but do NOT await it —
+                    // session.finish (the durable finish POST) and everything gated on
+                    // it below (recordRunFinish's journal write, settleRun clearing the
+                    // in-flight guard) must land regardless of how long this fetch
+                    // takes. Only the chat-facing summary/handoff, built after, needs
+                    // the resolved value (awaited just below, right before it is used).
+                    const costTextPromise = resolveCostText(finalResult, handle.runId, fetchRunSpend, ctx.signal);
                     await session.finish({
                         outcome,
                         stopReason: outcome === "completed" ? undefined : STOP_REASON_COPY[finalResult.stopReason],
@@ -919,15 +1021,26 @@ export function registerGoCommand(pi, deps = {}) {
                         ...(runCommitSha ? { commitSha: runCommitSha } : {}),
                         ...(finishInfo?.prUrl ? { prUrl: finishInfo.prUrl } : {}),
                     });
+                    // Only the chat-facing summary/handoff waits on the cost fetch,
+                    // now that the durable finish above has already landed.
+                    const costText = await costTextPromise;
+                    const summary = formatSummaryForChat(finalResult, costText);
                     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));
+                    await deliverHandoff(`${formatHandoff(finalResult, ticket, costText)}${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 });
+                    // A THROWN error ending the run is crash-shaped (verdict failures
+                    // return results instead) — report it, fire-and-forget. The default
+                    // reporter never rejects; the catch guards an injected one.
+                    void reportCrash(err, "go", runCwd).catch(() => { });
+                    // The stopReason travels to the backend run record; scrub it like
+                    // every other captured text (a raw error can echo a connection
+                    // string or key).
+                    await session.finish({ outcome: "failed", stopReason: scrubSecrets(message) });
                     recordRunFinish("failed");
                     const wipSha = await preserveWip("failed");
                     settleRun(runId, { status: "failed", ...(wipSha ? { commitSha: wipSha } : {}) });

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

@@ -1,11 +1,15 @@
 /**
- * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only).
+ * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only),
+ * plus two opt-in tier lanes: `--judgment` (peak vs advanced on plan+review) and
+ * `--map-tier` (standard vs efficient on map).
  *
  * It runs the same ticket through the pipeline TWICE in isolated git worktrees
  * (so the user's tree is never touched): once grounded (the real /go) and once
  * blind (grounding tools stripped + grounding-free personas), scores each change
  * for business fit against this company's recorded judgment via the grounded
- * review_business_match endpoint, and prints a comparative report.
+ * review_business_match endpoint, and prints a comparative report. The
+ * `--judgment` and `--map-tier` modes instead run both lanes fully grounded and
+ * vary only their one stage's tier, isolating that upgrade's fit delta.
  *
  * The report is the deliverable; nothing here is wired to model selection or
  * routing. The live double-run is dogfood (it spawns real children + models), so
@@ -16,7 +20,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { type ComparisonReport, type Lane } from "./eval.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 /** Which two-lane comparison a /go-compare invocation runs. */
-export type CompareMode = "grounding" | "judgment";
+export type CompareMode = "grounding" | "judgment" | "map-tier";
 export interface RegisterGoCompareDeps {
     /** The whole eval runner, injectable so the handler is unit-tested without spawning. */
     compare?: (ticket: string, ctx: ExtensionCommandContext, mode: CompareMode) => Promise<ComparisonReport>;
@@ -26,10 +30,15 @@ export interface RegisterGoCompareDeps {
     git?: GitCommand;
 }
 /**
- * Parse the leading `--judgment` flag. PURE.
+ * Parse the leading `--judgment` / `--map-tier` flag. PURE.
  *
  * Default stays `grounding` so the existing command is byte-identical for
- * callers who pass only a ticket.
+ * callers who pass only a ticket. The two flags are mutually exclusive in
+ * practice (only one is ever passed); if both appear, `--judgment` wins, but
+ * BOTH regexes are stripped unconditionally regardless of which one decided
+ * the mode, so the losing flag can never leak into the ticket ref (e.g.
+ * `--judgment --map-tier YAG-1` must yield ticket `"YAG-1"`, not
+ * `"--map-tier YAG-1"`).
  */
 export declare function parseCompareArgs(args: string): {
     mode: CompareMode;
@@ -38,9 +47,10 @@ export declare function parseCompareArgs(args: string): {
 /**
  * The per-lane stage list.
  *
- * Grounding mode strips the grounding tools from the blind lane. Judgment mode
- * runs BOTH lanes fully grounded and varies only the plan/review tier, so the
- * delta isolates the judgment upgrade rather than confounding it with grounding.
+ * Grounding mode strips the grounding tools from the blind lane. Judgment and
+ * map-tier modes run BOTH lanes fully grounded and vary only their one tier
+ * (plan/review for judgment, map for map-tier), so the delta isolates that one
+ * upgrade rather than confounding it with grounding.
  */
 export declare function stagesForLane(lane: Lane): import("./types.js").PipelineStage[];
 export type GitCommand = (args: string[], cwd: string | undefined, signal?: AbortSignal) => Promise<string>;

package/dist/extension/pipeline/goCompareCommand.js

@@ -1,11 +1,15 @@
 /**
- * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only).
+ * Registers `/go-compare <ticket>` - the M6 grounded-vs-blind eval (report-only),
+ * plus two opt-in tier lanes: `--judgment` (peak vs advanced on plan+review) and
+ * `--map-tier` (standard vs efficient on map).
  *
  * It runs the same ticket through the pipeline TWICE in isolated git worktrees
  * (so the user's tree is never touched): once grounded (the real /go) and once
  * blind (grounding tools stripped + grounding-free personas), scores each change
  * for business fit against this company's recorded judgment via the grounded
- * review_business_match endpoint, and prints a comparative report.
+ * review_business_match endpoint, and prints a comparative report. The
+ * `--judgment` and `--map-tier` modes instead run both lanes fully grounded and
+ * vary only their one stage's tier, isolating that upgrade's fit delta.
  *
  * The report is the deliverable; nothing here is wired to model selection or
  * routing. The live double-run is dogfood (it spawns real children + models), so
@@ -17,32 +21,38 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
-import { blindStages, makeGroundedVsBlindEval, makeJudgmentTierEval, reportOnlyStages, withJudgmentTier, } from "./eval.js";
+import { blindStages, makeGroundedVsBlindEval, makeJudgmentTierEval, makeMapTierEval, reportOnlyStages, withJudgmentTier, withMapTier, } from "./eval.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 /**
- * Parse the leading `--judgment` flag. PURE.
+ * Parse the leading `--judgment` / `--map-tier` flag. PURE.
  *
  * Default stays `grounding` so the existing command is byte-identical for
- * callers who pass only a ticket.
+ * callers who pass only a ticket. The two flags are mutually exclusive in
+ * practice (only one is ever passed); if both appear, `--judgment` wins, but
+ * BOTH regexes are stripped unconditionally regardless of which one decided
+ * the mode, so the losing flag can never leak into the ticket ref (e.g.
+ * `--judgment --map-tier YAG-1` must yield ticket `"YAG-1"`, not
+ * `"--map-tier YAG-1"`).
  */
 export function parseCompareArgs(args) {
-    let rest = args.trim();
-    let mode = "grounding";
-    // Accept the flag anywhere leading, so `/go-compare --judgment YAG-1` and
+    const trimmed = args.trim();
+    // Accept either flag anywhere leading, so `/go-compare --judgment YAG-1` and
     // `/go-compare YAG-1 --judgment` both work.
-    const flag = /(^|\s)--judgment(\s|$)/;
-    if (flag.test(rest)) {
-        mode = "judgment";
-        rest = rest.replace(flag, " ").trim();
-    }
-    return { mode, ticket: rest };
+    const judgmentFlag = /(^|\s)--judgment(\s|$)/;
+    const mapTierFlag = /(^|\s)--map-tier(\s|$)/;
+    const hasJudgment = judgmentFlag.test(trimmed);
+    const hasMapTier = mapTierFlag.test(trimmed);
+    const mode = hasJudgment ? "judgment" : hasMapTier ? "map-tier" : "grounding";
+    const ticket = trimmed.replace(judgmentFlag, " ").replace(mapTierFlag, " ").trim();
+    return { mode, ticket };
 }
 /**
  * The per-lane stage list.
  *
- * Grounding mode strips the grounding tools from the blind lane. Judgment mode
- * runs BOTH lanes fully grounded and varies only the plan/review tier, so the
- * delta isolates the judgment upgrade rather than confounding it with grounding.
+ * Grounding mode strips the grounding tools from the blind lane. Judgment and
+ * map-tier modes run BOTH lanes fully grounded and vary only their one tier
+ * (plan/review for judgment, map for map-tier), so the delta isolates that one
+ * upgrade rather than confounding it with grounding.
  */
 export function stagesForLane(lane) {
     switch (lane) {
@@ -52,6 +62,10 @@ export function stagesForLane(lane) {
             return withJudgmentTier(reportOnlyStages(), "peak");
         case "advanced_judgment":
             return withJudgmentTier(reportOnlyStages(), "advanced");
+        case "map_standard":
+            return withMapTier(reportOnlyStages(), "standard");
+        case "map_efficient":
+            return withMapTier(reportOnlyStages(), "efficient");
         default:
             return reportOnlyStages();
     }
@@ -94,8 +108,9 @@ function defaultCompare(deps) {
                 const result = await runPipeline(ticket, {
                     cwd: tree,
                     signal: ctx.signal,
-                    // Only the blind lane runs ungrounded. Both judgment lanes stay
-                    // grounded so the delta isolates the tier, not the grounding.
+                    // Only the blind lane runs ungrounded. Both judgment lanes and both
+                    // map-tier lanes stay grounded so the delta isolates the one tier
+                    // under test, not the grounding.
                     grounded: lane !== "blind",
                     stages: stagesForLane(lane),
                     childEnv: evalEnv,
@@ -144,14 +159,16 @@ function defaultCompare(deps) {
         };
         const evalRunner = mode === "judgment"
             ? makeJudgmentTierEval({ runLane, scoreFit })
-            : makeGroundedVsBlindEval({ runLane, scoreFit });
+            : mode === "map-tier"
+                ? makeMapTierEval({ runLane, scoreFit })
+                : makeGroundedVsBlindEval({ runLane, scoreFit });
         return evalRunner(ticket);
     };
 }
 export function registerGoCompareCommand(pi, deps = {}) {
     const compare = deps.compare ?? defaultCompare(deps);
     pi.registerCommand("go-compare", {
-        description: "Eval only: run a ticket through two lane configurations in isolated worktrees and report the business-fit delta. Default compares grounded vs grounding-suppressed; --judgment compares peak vs advanced on plan+review. Never affects routing.",
+        description: "Eval only: run a ticket through two lane configurations in isolated worktrees and report the business-fit delta. Default compares grounded vs grounding-suppressed; --judgment compares peak vs advanced on plan+review; --map-tier compares standard vs efficient on map. Never affects routing.",
         handler: async (args, ctx) => {
             const notify = (message, type) => {
                 if (ctx.hasUI)
@@ -159,7 +176,7 @@ export function registerGoCompareCommand(pi, deps = {}) {
             };
             const { mode, ticket } = parseCompareArgs(args);
             if (!ticket) {
-                notify("Usage: /go-compare [--judgment] <ticket>", "warning");
+                notify("Usage: /go-compare [--judgment | --map-tier] <ticket>", "warning");
                 return;
             }
             if (!ctx.isIdle()) {
@@ -168,7 +185,9 @@ export function registerGoCompareCommand(pi, deps = {}) {
             }
             notify(mode === "judgment"
                 ? "Running the peak vs advanced judgment eval (two isolated passes). This takes a while."
-                : "Running the grounded vs blind eval (two isolated passes). This takes a while.", "info");
+                : mode === "map-tier"
+                    ? "Running the standard vs efficient map eval (two isolated passes). This takes a while."
+                    : "Running the grounded vs blind eval (two isolated passes). This takes a while.", "info");
             try {
                 const out = await compare(ticket, ctx, mode);
                 await pi.sendUserMessage(out.report);