@yagni-app/code-staging 1.2.10-staging.2108.1 → 1.2.10-staging.2111.1

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

@@ -0,0 +1,85 @@
+/**
+ * The one rule for "did this change cause this failure?", as the session's
+ * verify gate reads it (`verify.ts`). This package does not depend on
+ * `@yagni/shared`, so the region between the markers below is a byte-for-byte
+ * copy of the same region of `packages/shared/src/checkAttribution.ts`, where
+ * the rule is written out; `test/pipeline/checkAttribution.test.ts` fails when
+ * the two differ, and both packages' tests read one corpus,
+ * `test/fixtures/checkAttribution.json`. Change the shared file and copy the
+ * region here.
+ *
+ * Copied rather than bundled: the extension is built by `tsc` alone and
+ * shipped inside the CLI's own package, and the identical copy keeps that so
+ * while the test keeps one rule.
+ */
+/**
+ * A command as two lists compare it: the same words, whatever spaces sit
+ * between them, and a package manager's script named the one way it runs,
+ * so `yarn test` and `yarn run test`, `npm test` and `npm run test`, `pnpm
+ * lint` and `pnpm run lint` are one check. Only the leading form: a
+ * manager's flags before the script leave the command as it is. Both
+ * packages' tests read one corpus,
+ * pi-extension-yagni/test/fixtures/equivalentCheckCommands.json.
+ */
+export declare function canonicalCheckCommand(command: string): string;
+/**
+ * One check's identity across the change's run and the base's, and across
+ * sessions: the folder it runs in, relative to the repository root, and its
+ * command as {@link canonicalCheckCommand} reads it.
+ */
+export declare function checkId(command: string, cwd: string): string;
+/** A failing test's key: its name, without the duration a runner prints after it. */
+export declare function testKey(name: string): string;
+/** A located diagnostic's key: its file and message, never its line, which a change above it moves. */
+export declare function diagKey(file: string, message: string): string;
+/** A check annotation's key: its path and message, never its line. */
+export declare function annotationKey(path: string, message: string): string;
+/**
+ * What the change did to a failure: `caused` it (nothing of it was on the
+ * base), found it `preexisting` (every key was on the base at least as many
+ * times), `partly` caused it (some keys were, some were not), or there is
+ * `no_baseline` to compare with, and it counts as the change's.
+ */
+export type FailureAttribution = "caused" | "preexisting" | "partly" | "no_baseline";
+/**
+ * One run of a check as the rule reads it: its failure keys, null for a
+ * failure that names nothing, and the step that failed when the runner says.
+ * A run that passed has no keys.
+ */
+export interface FailureRun {
+    keys: ReadonlyArray<string | null>;
+    step?: string | null;
+}
+/**
+ * The rule. `excused` is index for index with `head.keys`: true where the
+ * base already had that failure, each base key excusing one head key at most.
+ * Pure.
+ */
+export declare function attributeFailure(head: FailureRun, base: FailureRun | null | undefined): {
+    verdict: FailureAttribution;
+    excused: boolean[];
+};
+/** What one check did on the base: it passed, or it failed with these keys. */
+export interface BaseMeasurement {
+    id: string;
+    outcome: "passed" | "failed";
+    keys: string[];
+}
+/** The file the session writes beside its `result.json`, and the bounds both sides keep. */
+export declare const BASE_MEASUREMENTS_FILE_NAME = "base-measurements.json";
+export declare const MAX_BASE_MEASUREMENTS = 100;
+export declare const MAX_BASE_KEYS = 1000;
+export declare const MAX_BASE_KEY_CHARS = 500;
+/**
+ * One measurement within the bounds: a key longer than the bound is left
+ * out, and keys past the count bound are dropped. Either only makes fewer
+ * failures excused, never more.
+ */
+export declare function boundedMeasurement(measurement: BaseMeasurement): BaseMeasurement;
+/**
+ * `base-measurements.json` as the host reads it (`parseBaseMeasurements` in
+ * `@yagni/shared`): the commit the checks ran on, and what each did there,
+ * each held to the bounds.
+ */
+export declare function renderBaseMeasurements(baseSha: string, measured: ReadonlyMap<string, Omit<BaseMeasurement, "id">>): string;
+//# sourceMappingURL=checkAttribution.d.ts.map

package/dist/extension/pipeline/checkAttribution.js

@@ -0,0 +1,131 @@
+/**
+ * The one rule for "did this change cause this failure?", as the session's
+ * verify gate reads it (`verify.ts`). This package does not depend on
+ * `@yagni/shared`, so the region between the markers below is a byte-for-byte
+ * copy of the same region of `packages/shared/src/checkAttribution.ts`, where
+ * the rule is written out; `test/pipeline/checkAttribution.test.ts` fails when
+ * the two differ, and both packages' tests read one corpus,
+ * `test/fixtures/checkAttribution.json`. Change the shared file and copy the
+ * region here.
+ *
+ * Copied rather than bundled: the extension is built by `tsc` alone and
+ * shipped inside the CLI's own package, and the identical copy keeps that so
+ * while the test keeps one rule.
+ */
+// --- mirrored region: begin (pi-extension-yagni/src/pipeline/checkAttribution.ts)
+/** Package-manager words that are the manager's own command, never a script. */
+const YARN_COMMANDS = new Set("add audit autoclean bin cache check config constraints create dedupe dlx exec explain generate-lock-entry global help import info init install licenses link list login logout node npm outdated owner pack patch patch-commit plugin policies publish rebuild remove run set stage tag team unlink unplug up upgrade upgrade-interactive version versions why workspace workspaces".split(" "));
+const PNPM_COMMANDS = new Set("add audit bin cache cat-file cat-index config create dedupe deploy dlx doctor env exec fetch find-hash i import init install install-test it licenses link list ln ls outdated pack patch patch-commit patch-remove prune publish rb rebuild recursive remove rm root run self-update server setup store un uninstall unlink up update why".split(" "));
+/** The scripts npm runs without `run`: its lifecycle shorthands. */
+const NPM_SCRIPT_SHORTHANDS = new Set(["test", "start", "stop", "restart"]);
+/**
+ * A command as two lists compare it: the same words, whatever spaces sit
+ * between them, and a package manager's script named the one way it runs,
+ * so `yarn test` and `yarn run test`, `npm test` and `npm run test`, `pnpm
+ * lint` and `pnpm run lint` are one check. Only the leading form: a
+ * manager's flags before the script leave the command as it is. Both
+ * packages' tests read one corpus,
+ * pi-extension-yagni/test/fixtures/equivalentCheckCommands.json.
+ */
+export function canonicalCheckCommand(command) {
+    const words = command.trim().split(/\s+/).filter(Boolean);
+    const [manager, next, ...rest] = words;
+    const script = /^[A-Za-z0-9][\w:.@/-]*$/;
+    if (manager === "npm" || manager === "yarn" || manager === "pnpm") {
+        const runs = next === "run" || (manager === "npm" && next === "run-script");
+        if (runs && rest[0] && script.test(rest[0]))
+            return [manager, "run", ...rest].join(" ");
+        const shorthand = next !== undefined &&
+            script.test(next) &&
+            (manager === "npm"
+                ? NPM_SCRIPT_SHORTHANDS.has(next)
+                : !(manager === "yarn" ? YARN_COMMANDS : PNPM_COMMANDS).has(next));
+        if (shorthand)
+            return [manager, "run", next, ...rest].join(" ");
+    }
+    return words.join(" ");
+}
+/**
+ * One check's identity across the change's run and the base's, and across
+ * sessions: the folder it runs in, relative to the repository root, and its
+ * command as {@link canonicalCheckCommand} reads it.
+ */
+export function checkId(command, cwd) {
+    const dir = cwd
+        .replace(/\\/g, "/")
+        .replace(/^(?:\.\/+)+/, "")
+        .replace(/\/+$/, "") || ".";
+    return `${dir}\u0000${canonicalCheckCommand(command)}`;
+}
+/** A failing test's key: its name, without the duration a runner prints after it. */
+export function testKey(name) {
+    return `test:${name.replace(/\s*\(\d+(?:\.\d+)?\s*m?s\)\s*$/, "").trim()}`;
+}
+/** A located diagnostic's key: its file and message, never its line, which a change above it moves. */
+export function diagKey(file, message) {
+    return `diag:${file.replace(/\\/g, "/").replace(/^(?:\.\/+)+/, "")}\u0000${message.trim()}`;
+}
+/** A check annotation's key: its path and message, never its line. */
+export function annotationKey(path, message) {
+    return `ann:${path}\u0000${message.trim()}`;
+}
+/**
+ * The rule. `excused` is index for index with `head.keys`: true where the
+ * base already had that failure, each base key excusing one head key at most.
+ * Pure.
+ */
+export function attributeFailure(head, base) {
+    const excused = head.keys.map(() => false);
+    if (!base)
+        return { verdict: "no_baseline", excused };
+    if (head.step && base.step && head.step !== base.step)
+        return { verdict: "caused", excused };
+    const left = new Map();
+    for (const key of base.keys)
+        if (key !== null)
+            left.set(key, (left.get(key) ?? 0) + 1);
+    head.keys.forEach((key, index) => {
+        const count = key === null ? 0 : (left.get(key) ?? 0);
+        if (key === null || count === 0)
+            return;
+        left.set(key, count - 1);
+        excused[index] = true;
+    });
+    const count = excused.filter(Boolean).length;
+    const verdict = count === 0 ? "caused" : count === head.keys.length ? "preexisting" : "partly";
+    return { verdict, excused };
+}
+/** The file the session writes beside its `result.json`, and the bounds both sides keep. */
+export const BASE_MEASUREMENTS_FILE_NAME = "base-measurements.json";
+export const MAX_BASE_MEASUREMENTS = 100;
+export const MAX_BASE_KEYS = 1_000;
+export const MAX_BASE_KEY_CHARS = 500;
+/**
+ * One measurement within the bounds: a key longer than the bound is left
+ * out, and keys past the count bound are dropped. Either only makes fewer
+ * failures excused, never more.
+ */
+export function boundedMeasurement(measurement) {
+    return {
+        id: measurement.id,
+        outcome: measurement.outcome,
+        keys: measurement.outcome === "passed"
+            ? []
+            : measurement.keys
+                .filter((key) => key.length <= MAX_BASE_KEY_CHARS)
+                .slice(0, MAX_BASE_KEYS),
+    };
+}
+// --- mirrored region: end
+/**
+ * `base-measurements.json` as the host reads it (`parseBaseMeasurements` in
+ * `@yagni/shared`): the commit the checks ran on, and what each did there,
+ * each held to the bounds.
+ */
+export function renderBaseMeasurements(baseSha, measured) {
+    const checks = [...measured]
+        .slice(0, MAX_BASE_MEASUREMENTS)
+        .map(([id, measurement]) => boundedMeasurement({ id, ...measurement }));
+    return `${JSON.stringify({ version: 1, baseSha, checks }, null, 2)}\n`;
+}
+//# sourceMappingURL=checkAttribution.js.map

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

@@ -75,7 +75,7 @@ import { snapshotWorkspace } from "./workspace.js";
 import type { WorktreeExec } from "./worktree.js";
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
-import { makeMeasureChecksOnBase, makeRunVerify, type VerifyBaselineResult } from "./verify.js";
+import { baseTargets, makeMeasureOnBase, makeRunVerify } from "./verify.js";
 import { type RunBudget } from "./budget.js";
 import type { Finding, JsonEvent, ModelTier, PipelineStage, StageId, StageTag, StageUsage, StopReason } from "./types.js";
 /** One-line usage copy, shared by every argument error. */
@@ -182,14 +182,14 @@ export interface HeadlessGoDeps {
      * there is none). Defaults to the real gate; injected in tests.
      */
     makeRunVerify?: typeof makeRunVerify;
-    /** The approved checks' run on the unchanged code (`measureOnBase`). Defaults to the real one; injected in tests. */
-    measureChecksOnBase?: ReturnType<typeof makeMeasureChecksOnBase>;
+    /** The checks' run on the unchanged code (YAG-1003). Defaults to the real one; injected in tests. */
+    measureOnBase?: ReturnType<typeof makeMeasureOnBase>;
+    /** What the run on the unchanged code measures. Defaults to the real detection; injected in tests. */
+    baseTargets?: typeof baseTargets;
     /** A resumed session's switch to the attempt's base commit and back (baseTree.ts). Defaults to real git; injected in tests. */
     measureOnBaseTree?: typeof measureOnBaseTree;
     /** The paths the session's HEAD changed since the attempt's base, null when git cannot say. Defaults to real git; injected in tests. */
     pathsCommittedSince?: (cwd: string, base: string) => Promise<string[] | null>;
-    /** The verify gate's clean-tree baseline run (YAG-1003). Defaults to the real one; injected in tests. */
-    takeVerifyBaseline?: (cwd: string, dirs: string[], signal?: AbortSignal, budgetMs?: number) => Promise<VerifyBaselineResult>;
     /** stdout sink; one call per NDJSON line, newline added by the caller. */
     write?: (line: string) => void;
     /** stderr sink for human-readable problems. */

package/dist/extension/pipeline/headlessGo.js

@@ -86,7 +86,8 @@ import { normalizeMission } from "./mission.js";
 import { MISSION_CHECKS_FILE_NAME, MISSION_CI_RESULTS_FILE_NAME, readMissionChecksFile, renderCiResults, } from "./missionChecks.js";
 import { startTreeSnapshots } from "./treeSnapshot.js";
 import { PipelineStageError, runPipeline as defaultRunPipeline, } from "./orchestrator.js";
-import { baselineDirs, makeMeasureChecksOnBase, makeRunVerify, makeTakeVerifyBaseline, makeWorkstreamCheck, parseChangedPaths, planPaths, } from "./verify.js";
+import { baselineDirs, baseTargets, makeMeasureOnBase, makeRunVerify, makeWorkstreamCheck, parseChangedPaths, planPaths, } from "./verify.js";
+import { BASE_MEASUREMENTS_FILE_NAME, renderBaseMeasurements, } from "./checkAttribution.js";
 import { loadGroundingEnabled } from "../grounding.js";
 import { codeStateHome } from "../stateHome.js";
 import { parseTierCap, TIER_CAP_ENV } from "./tierCap.js";
@@ -448,13 +449,16 @@ export async function runHeadlessGo(argv, deps = {}) {
             ...(mission ? { mission } : {}),
         }, lane ? { maxRounds: lane.maxReviewRounds, committed: true } : {})
         : undefined;
-    // The gate's own checks, once on the clean tree before the build (YAG-1003),
-    // in the packages the approved plan names: what already failed there is a
-    // note, never a finding. Only a fresh build's tree is the clean base; a
-    // continuation or a fix round already carries a change, so taking them on
-    // its own tree would excuse the attempt's own breakage. It takes them on
-    // the attempt's base commit instead (baseTree.ts), when its host names one.
-    let baseline;
+    // What the gate compares a failure with: each check it will judge, run once
+    // on the unchanged code before the build (YAG-1003, `makeMeasureOnBase`), so
+    // a failure the base already had is a note, never a finding
+    // (`attributeFailure`, checkAttribution.ts). A fresh build's tree is the
+    // base; a continuation or a fix round already carries a change, so taking
+    // them on its own tree would excuse the attempt's own breakage, and it
+    // measures on the attempt's base commit instead (baseTree.ts), when its host
+    // names one. What the attempt's earlier sessions measured on that base
+    // comes in `checks.json` (`baseMeasured`) and is not run again; what this
+    // session measures goes to `base-measurements.json` for the host to keep.
     const logPipeline = (event, data) => {
         deps.logger?.(event, data);
         if (stream)
@@ -502,9 +506,9 @@ export async function runHeadlessGo(argv, deps = {}) {
         }
         return { exitCode: HEADLESS_GO_EXIT.unverified, error: message };
     };
-    // A measurement before the build (the baseline, the plan's checks on the
-    // base) gets at most a sixth of the run's time left when it starts, and
-    // none below a minute: the build itself must still fit. No deadline, no cap.
+    // A measurement before the build gets at most a sixth of the run's time
+    // left when it starts, and none below a minute: the build itself must
+    // still fit. No deadline, no cap.
     const preBuildShare = () => {
         const leftMs = budget?.deadlineMs === undefined ? undefined : budget.deadlineMs - (deps.now ?? Date.now)();
         const shareMs = leftMs === undefined ? undefined : Math.floor(leftMs / BASELINE_SHARE_OF_TIME_LEFT);
@@ -514,8 +518,15 @@ export async function runHeadlessGo(argv, deps = {}) {
             tooLittle: shareMs !== undefined && shareMs < MIN_BASELINE_BUDGET_MS,
         };
     };
-    /** The gate's detected checks on the tree as it is, in `dirs`; never throws. */
-    const takeBaseline = async (dirs) => {
+    const measureFile = gateOpts?.repoChecks?.() ?? null;
+    // The host matched them to the attempt's base: the tree a fresh build
+    // starts on, and the commit a resumed session measures on.
+    const measuredBase = carriedMeasurements(measureFile);
+    const carried = measuredBase.size;
+    const measuredHere = new Map();
+    const targetsOf = deps.baseTargets ?? baseTargets;
+    /** The targets no session measured yet, on the tree as it is; never throws. */
+    const measure = async (targets) => {
         const share = preBuildShare();
         if (share.tooLittle) {
             logPipeline("verify_baseline", {
@@ -526,79 +537,53 @@ export async function runHeadlessGo(argv, deps = {}) {
             return;
         }
         try {
-            const taken = await (deps.takeVerifyBaseline ?? makeTakeVerifyBaseline(heard))(cwd, dirs, deps.signal, share.shareMs);
+            const result = await (deps.measureOnBase ?? makeMeasureOnBase(heard))(cwd, targets, deps.signal, share.shareMs);
             logPipeline("verify_baseline", {
-                ran: taken.ran,
-                failures: taken.failures,
-                notes: taken.notes,
+                ran: result.ran,
+                failures: result.failures,
+                notes: result.notes,
+                treeUndone: result.treeUndone,
+                carried,
             });
-            if (taken.baseline.size > 0)
-                baseline = taken.baseline;
+            for (const [id, measurement] of result.measured) {
+                measuredBase.set(id, measurement);
+                measuredHere.set(id, measurement);
+            }
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             logPipeline("verify_baseline", { error: message });
-            writeErr(`The verify baseline could not run (every failure counts): ${message}`);
+            writeErr(`The base measurement could not run (every failure counts): ${message}`);
         }
     };
+    const missing = (targets) => targets.filter((target) => !measuredBase.has(target.id));
     const resumed = Boolean(continuation || fixRound);
-    if (mission?.plan && !resumed && !deps.signal?.aborted) {
-        const dirs = baselineDirs(cwd, planPaths(mission.plan), readFile);
-        if (dirs.length > 0)
-            await takeBaseline(dirs);
-    }
-    // The approved checks the host has not seen pass on the unchanged code
-    // (`measureOnBase`: the plan's, and CI's when the repository's record has
-    // none of its own), each run once there before the build, on the same
-    // fresh tree the baseline above reads: a check that already failed there is
-    // not this change's to fix.
-    let checksOnBase;
-    const measureFile = gateOpts?.repoChecks?.() ?? null;
-    /** The approved checks `file` marks to measure, on the tree as it is; never throws. */
-    const measureChecks = async (file) => {
-        const share = preBuildShare();
-        if (share.tooLittle) {
-            logPipeline("verify_checks_on_base", {
-                skipped: "too little of the run's time left",
-                leftMs: share.leftMs,
-                shareMs: share.shareMs,
-            });
-            return;
-        }
-        try {
-            const measured = await (deps.measureChecksOnBase ?? makeMeasureChecksOnBase(heard))(cwd, file, deps.signal, share.shareMs);
-            logPipeline("verify_checks_on_base", {
-                ran: measured.ran,
-                passed: [...measured.passed],
-                failed: [...measured.failed.keys()],
-                notes: measured.notes,
-                treeUndone: measured.treeUndone,
-            });
-            if (measured.passed.size > 0 || measured.failed.size > 0)
-                checksOnBase = measured;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            logPipeline("verify_checks_on_base", { error: message });
-            writeErr(`The approved checks could not run on the unchanged code (each keeps its checks.json standing): ${message}`);
-        }
-    };
-    if (measureFile?.checks.some((check) => check.measureOnBase) &&
-        !resumed &&
-        !deps.signal?.aborted) {
-        await measureChecks(measureFile);
+    // The commit a resumed session measured on; a fresh build's is its start.
+    let measuredOn;
+    if (!resumed && !deps.signal?.aborted) {
+        // The packages the approved plan names, and the approved checks the host
+        // has not seen pass on the unchanged code (`measureOnBase`: the plan's,
+        // and CI's when the repository's record has none of its own).
+        const targets = missing(targetsOf(cwd, {
+            dirs: mission?.plan ? baselineDirs(cwd, planPaths(mission.plan), readFile) : [],
+            checks: measureFile,
+        }, gateOpts ?? {}));
+        if (targets.length > 0)
+            await measure(targets);
     }
     // A one-attempt lane continuation or fix round starts past the attempt's
-    // earlier commits, so it measures both on the attempt's base commit
+    // earlier commits, so it measures on the attempt's base commit
     // (`continue.json` names it, YAG-1042), with the tree put back after (YAG-1056).
     // Before, its host had nothing to hand it for the gate's own checks and only
     // a stale record for a plan check, so every failure main already had was its
     // to fix, and COREX-1291's sessions ended `round_cap` on main's lint errors
     // one after another (production, 2026-10-26). It measures every approved
     // check it can run there, not only those marked: the record's green is what
-    // went stale. Its baseline covers the plan's packages and those the attempt
-    // changed. A base it cannot measure on leaves the run as it was; a tree it
-    // cannot put back stops the session before it builds.
+    // went stale. It covers the plan's packages and those the attempt changed.
+    // What an earlier session measured on the same base is not run again, and
+    // with nothing missing the base is never checked out. A base it cannot
+    // measure on leaves the run as it was; a tree it cannot put back stops the
+    // session before it builds.
     if (cloud && resumed && !deps.signal?.aborted) {
         const base = baseCommitOf(continuation?.baseSha) ?? baseCommitOf(fixRound?.baseRef);
         const share = preBuildShare();
@@ -614,24 +599,19 @@ export async function runHeadlessGo(argv, deps = {}) {
             });
         }
         else {
-            const onBaseFile = measureFile && {
-                ...measureFile,
-                checks: measureFile.checks.map((check) => check.status === "cannot_run" ? check : { ...check, measureOnBase: true }),
-            };
-            const checksToMeasure = Boolean(onBaseFile?.checks.some((check) => check.status !== "cannot_run"));
             try {
-                // A list git cannot read narrows the baseline to the plan's packages: said.
+                // A list git cannot read narrows the measurement to the plan's packages: said.
                 const changed = await (deps.pathsCommittedSince ?? pathsCommittedSince)(cwd, base);
                 const unread = changed === null ? { changedPathsUnread: true } : {};
                 const dirs = baselineDirs(cwd, [...planPaths(mission?.plan ?? ""), ...(changed ?? [])], readFile);
-                const outcome = dirs.length === 0 && !checksToMeasure
-                    ? { kind: "skipped", reason: "nothing to measure" }
-                    : await (deps.measureOnBaseTree ?? measureOnBaseTree)(cwd, base, async () => {
-                        if (dirs.length > 0)
-                            await takeBaseline(dirs);
-                        if (onBaseFile && checksToMeasure)
-                            await measureChecks(onBaseFile);
-                    });
+                const targets = missing(targetsOf(cwd, { dirs, checks: measureFile, allChecks: true }, gateOpts ?? {}));
+                measuredOn = base;
+                const outcome = targets.length === 0
+                    ? {
+                        kind: "skipped",
+                        reason: carried > 0 ? "measured by an earlier session" : "nothing to measure",
+                    }
+                    : await (deps.measureOnBaseTree ?? measureOnBaseTree)(cwd, base, () => measure(targets));
                 logPipeline("verify_base_tree", outcome.kind === "measured"
                     ? { base, measured: true, ...unread }
                     : { base, skipped: outcome.reason, ...unread });
@@ -682,11 +662,22 @@ export async function runHeadlessGo(argv, deps = {}) {
     const scan = cloud
         ? (scanCwd, signal, skip) => scanChange(scanCwd, { exec, sessionSecrets, ...onBase }, skip, signal)
         : undefined;
-    if (gateOpts || baseline || cloud) {
+    // What this session measured, for the host to keep: on the base a resumed
+    // session checked out, or the commit a fresh build starts on.
+    if (cloud && measuredHere.size > 0) {
+        writeBaseMeasurements({
+            outDir: cloud.outDir,
+            sha: measuredOn ?? baseSha,
+            measured: measuredHere,
+            writeFile: deps.writeFile ?? writeFileSync,
+            log: logPipeline,
+        });
+    }
+    const onBaseOpts = measuredBase.size > 0 ? { onBase: measuredBase } : {};
+    if (gateOpts || measuredBase.size > 0 || cloud) {
         const made = (deps.makeRunVerify ?? makeRunVerify)({
             ...gateOpts,
-            ...(baseline ? { baseline } : {}),
-            ...(checksOnBase ? { checksOnBase } : {}),
+            ...onBaseOpts,
             ...(scan ? { scanChange: scan } : {}),
             // The one-attempt lane's host runs no checks after the build.
             ...(cloud
@@ -725,7 +716,9 @@ export async function runHeadlessGo(argv, deps = {}) {
         ...(reviewLane ? { lane: reviewLane } : {}),
         ...(mission ? { mission } : {}),
         ...(runVerify ? { runVerify } : {}),
-        ...(baseline ? { runWorkstreamCheck: makeWorkstreamCheck({ baseline }) } : {}),
+        ...(measuredBase.size > 0
+            ? { runWorkstreamCheck: makeWorkstreamCheck({ onBase: measuredBase }) }
+            : {}),
         // A cloud execution never starts on an earlier attempt's uncommitted
         // edits: that work is on the branch, so its tree baselines as it is.
         ...(continuation && !cloud ? { continuation: { stageAtStop: continuation.stageAtStop } } : {}),
@@ -859,4 +852,36 @@ export async function runHeadlessGo(argv, deps = {}) {
 function treeKey(snapshot) {
     return `${snapshot.head}\n${snapshot.status}`;
 }
+/** What the attempt's earlier sessions measured on its base, as `checks.json` carries it, by check id. */
+function carriedMeasurements(file) {
+    return new Map((file?.baseMeasured?.checks ?? []).map((check) => [
+        check.id,
+        { outcome: check.outcome, keys: check.keys },
+    ]));
+}
+/**
+ * `base-measurements.json` beside `result.json`, for the host to keep. With
+ * no commit to name, or a write that fails, it is logged and dropped: the
+ * next session measures again.
+ */
+function writeBaseMeasurements(input) {
+    const path = join(input.outDir, BASE_MEASUREMENTS_FILE_NAME);
+    if (!input.sha) {
+        input.log("base_measurements_write_failed", {
+            path,
+            error: "no commit to name what was measured on",
+            measured: input.measured.size,
+        });
+        return;
+    }
+    try {
+        input.writeFile(path, renderBaseMeasurements(input.sha, input.measured));
+    }
+    catch (err) {
+        input.log("base_measurements_write_failed", {
+            path,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 //# sourceMappingURL=headlessGo.js.map

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

@@ -15,6 +15,7 @@
  * parser. A change there is a change here. A file that is missing or does not
  * read as version 1 means no repository checks, never a stopped build.
  */
+import { type BaseMeasurement } from "./checkAttribution.js";
 export declare const MISSION_CHECKS_FILE_NAME = "checks.json";
 export type MissionCheckStatus = "runnable" | "fails_on_base" | "cannot_run";
 export interface MissionCheck {
@@ -25,7 +26,7 @@ export interface MissionCheck {
      * The host has not seen it pass on the unchanged code (an approved plan's
      * check, or one CI runs that has no baseline): the session runs it there
      * once before the build, and what that
-     * measures stands over `status` (`makeMeasureChecksOnBase` in verify.ts).
+     * measures stands over `status` (`makeMeasureOnBase` in verify.ts).
      */
     measureOnBase?: boolean;
 }
@@ -61,6 +62,15 @@ export interface MissionChecksFile {
         name: string;
         reason: string;
     }>;
+    /**
+     * What the attempt's earlier sessions measured on its base commit, by check
+     * id (`checkId`): the session measures only the rest. A field that does
+     * not read is left out, never the file.
+     */
+    baseMeasured?: {
+        baseSha: string;
+        checks: BaseMeasurement[];
+    };
 }
 export declare const MISSION_CI_RESULTS_FILE_NAME = "ci-results.json";
 /** How one failed CI check's job went the last time the gate ran it. */

package/dist/extension/pipeline/missionChecks.js

@@ -16,6 +16,7 @@
  * read as version 1 means no repository checks, never a stopped build.
  */
 import { readFileSync } from "node:fs";
+import { boundedMeasurement } from "./checkAttribution.js";
 export const MISSION_CHECKS_FILE_NAME = "checks.json";
 export const MISSION_CI_RESULTS_FILE_NAME = "ci-results.json";
 /** `ci-results.json` (version 1), as the host reads it. */
@@ -98,6 +99,20 @@ function parseJob(value) {
     }
     return job;
 }
+function parseBaseMeasured(value) {
+    if (!isRecord(value) || !isString(value.baseSha) || !Array.isArray(value.checks))
+        return undefined;
+    const checks = [];
+    for (const raw of value.checks) {
+        if (!isRecord(raw) || !isString(raw.id) || !raw.id)
+            continue;
+        if (raw.outcome !== "passed" && raw.outcome !== "failed")
+            continue;
+        const keys = Array.isArray(raw.keys) ? raw.keys.filter(isString) : [];
+        checks.push(boundedMeasurement({ id: raw.id, outcome: raw.outcome, keys }));
+    }
+    return { baseSha: value.baseSha, checks };
+}
 function parseCannotRunChecks(value) {
     if (!Array.isArray(value))
         return null;
@@ -145,12 +160,19 @@ export function parseMissionChecksFile(text) {
             return null;
         ciJobs.push(job);
     }
+    const baseMeasured = parseBaseMeasured(parsed.baseMeasured);
+    const file = {
+        version: 1,
+        checks,
+        ciJobs,
+        ...(baseMeasured ? { baseMeasured } : {}),
+    };
     if (parsed.failedChecksCannotRun === undefined)
-        return { version: 1, checks, ciJobs };
+        return file;
     const failedChecksCannotRun = parseCannotRunChecks(parsed.failedChecksCannotRun);
     if (!failedChecksCannotRun)
         return null;
-    return { version: 1, checks, ciJobs, failedChecksCannotRun };
+    return { ...file, failedChecksCannotRun };
 }
 /**
  * Read the file. `missing` (no such file: a host that predates it, or a run