@yagni-app/code-staging 1.2.9-staging.2082.1 → 1.2.10-staging.2090.1

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

@@ -0,0 +1,68 @@
+/**
+ * The attempt's base commit's files, for what a resumed session measures
+ * before it builds.
+ *
+ * A fresh build measures the gate's checks on its clean tree, which is the
+ * attempt's base (YAG-1003, `measureOnBase`), so a failure the base already
+ * has is a note. A resumed session (a continuation, a fix round) starts on the
+ * branch past the earlier sessions' commits, so it used to measure nothing,
+ * and every failure the base already had was its own to fix: COREX-1291's
+ * sessions each took main's lint errors as findings, ended `round_cap`, and
+ * were resumed again (production, 2026-10-26).
+ *
+ * {@link measureOnBaseTree} puts the base commit's files in the checkout for
+ * one measurement and then puts the session's tree back exactly: HEAD, its
+ * branch, the index, every file git sees (`git stash --include-untracked`
+ * holds the uncommitted state meanwhile), the untracked empty folders and the
+ * uncommitted files' modes, which git keeps no record of. Ignored files stay
+ * where they are, so the clone's installed dependencies serve both trees; an
+ * attempt whose commits changed what is installed is therefore never
+ * measured, since the base's sources on the change's dependencies would
+ * excuse what the dependency change broke. It measures only when it can put
+ * the tree back: anything it cannot be sure of is a skip that leaves the tree
+ * as it was. A tree it cannot put back is a {@link BaseTreeRestoreError},
+ * never a quiet build on the wrong tree. Hooks are off for every call: a
+ * repository's post-checkout hook must not run.
+ */
+/** One git call's outcome; a spawn error or a timeout is code -1. */
+export interface BaseTreeGitResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/** The git seam (default: real git, hooks off); injected in tests. */
+export type BaseTreeGit = (args: string[], cwd: string, env?: NodeJS.ProcessEnv) => Promise<BaseTreeGitResult>;
+export declare const defaultBaseTreeGit: BaseTreeGit;
+/** A commit id the session may put in a git command line, or undefined. */
+export declare function baseCommitOf(value: string | undefined): string | undefined;
+/** The tree put back after a measurement it could not be sure of. */
+export declare class BaseTreeRestoreError extends Error {
+    /** The session's HEAD, its branch (null when detached) and the stash holding its uncommitted state. */
+    readonly head: string;
+    readonly branch: string | null;
+    readonly stash: string | null;
+    constructor(message: string, state: {
+        head: string;
+        branch: string | null;
+        stash: string | null;
+    });
+}
+export type BaseTreeOutcome<T> = {
+    kind: "measured";
+    value: T;
+} | {
+    kind: "skipped";
+    reason: string;
+};
+/** The paths the session's HEAD changed since `base`, relative to `cwd`; null when git cannot say. */
+export declare function pathsCommittedSince(cwd: string, base: string, git?: BaseTreeGit): Promise<string[] | null>;
+/**
+ * Run `measure` on the files of the commit `base`, then put the tree back as
+ * it was. `skipped` (with why) when it could not start, the tree as it was;
+ * throws {@link BaseTreeRestoreError} when the tree could not be put back
+ * exactly, and rethrows what `measure` threw once the tree is back.
+ */
+export declare function measureOnBaseTree<T>(cwd: string, base: string, measure: () => Promise<T>, opts?: {
+    git?: BaseTreeGit;
+}): Promise<BaseTreeOutcome<T>>;
+//# sourceMappingURL=baseTree.d.ts.map

package/dist/extension/pipeline/baseTree.js

@@ -0,0 +1,522 @@
+/**
+ * The attempt's base commit's files, for what a resumed session measures
+ * before it builds.
+ *
+ * A fresh build measures the gate's checks on its clean tree, which is the
+ * attempt's base (YAG-1003, `measureOnBase`), so a failure the base already
+ * has is a note. A resumed session (a continuation, a fix round) starts on the
+ * branch past the earlier sessions' commits, so it used to measure nothing,
+ * and every failure the base already had was its own to fix: COREX-1291's
+ * sessions each took main's lint errors as findings, ended `round_cap`, and
+ * were resumed again (production, 2026-10-26).
+ *
+ * {@link measureOnBaseTree} puts the base commit's files in the checkout for
+ * one measurement and then puts the session's tree back exactly: HEAD, its
+ * branch, the index, every file git sees (`git stash --include-untracked`
+ * holds the uncommitted state meanwhile), the untracked empty folders and the
+ * uncommitted files' modes, which git keeps no record of. Ignored files stay
+ * where they are, so the clone's installed dependencies serve both trees; an
+ * attempt whose commits changed what is installed is therefore never
+ * measured, since the base's sources on the change's dependencies would
+ * excuse what the dependency change broke. It measures only when it can put
+ * the tree back: anything it cannot be sure of is a skip that leaves the tree
+ * as it was. A tree it cannot put back is a {@link BaseTreeRestoreError},
+ * never a quiet build on the wrong tree. Hooks are off for every call: a
+ * repository's post-checkout hook must not run.
+ */
+import { execFile } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve as resolvePath } from "node:path";
+import { trackChild } from "./childRegistry.js";
+const GIT_ARGS = [
+    "-c",
+    "core.hooksPath=/dev/null",
+    "-c",
+    "user.name=YAGNI",
+    "-c",
+    "user.email=worker@yagni.local",
+];
+/** One git call's cap: a stash or a checkout of a large tree takes a while. */
+const GIT_TIMEOUT_MS = 5 * 60_000;
+export const defaultBaseTreeGit = (args, cwd, env) => new Promise((resolve) => {
+    const child = execFile("git", [...GIT_ARGS, ...args], {
+        cwd,
+        env: { ...process.env, ...env, GIT_TERMINAL_PROMPT: "0" },
+        maxBuffer: 64 * 1024 * 1024,
+        timeout: GIT_TIMEOUT_MS,
+    }, (err, stdout, stderr) => {
+        const code = err?.code;
+        resolve({
+            code: err ? (typeof code === "number" ? code : -1) : 0,
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? err?.message ?? ""),
+        });
+    });
+    trackChild(child);
+});
+const COMMIT_SHA = /^[0-9a-f]{40}$/;
+/** A commit id the session may put in a git command line, or undefined. */
+export function baseCommitOf(value) {
+    return value && COMMIT_SHA.test(value) ? value : undefined;
+}
+/** The tree put back after a measurement it could not be sure of. */
+export class BaseTreeRestoreError extends Error {
+    /** The session's HEAD, its branch (null when detached) and the stash holding its uncommitted state. */
+    head;
+    branch;
+    stash;
+    constructor(message, state) {
+        super(message);
+        this.name = "BaseTreeRestoreError";
+        this.head = state.head;
+        this.branch = state.branch;
+        this.stash = state.stash;
+    }
+}
+const errorText = (err) => (err instanceof Error ? err.message : String(err));
+const firstLine = (text) => text.trim().split("\n")[0]?.trim() ?? "";
+function why(result) {
+    return firstLine(result.stderr) || firstLine(result.stdout) || `exit ${result.code}`;
+}
+const skipped = (reason) => ({
+    kind: "skipped",
+    reason,
+});
+/** The paths the session's HEAD changed since `base`, relative to `cwd`; null when git cannot say. */
+export async function pathsCommittedSince(cwd, base, git = defaultBaseTreeGit) {
+    const diff = await git(["diff", "--name-only", "-z", "--no-renames", "--relative", base, "HEAD"], cwd);
+    return diff.code === 0 ? diff.stdout.split("\0").filter(Boolean) : null;
+}
+/** Files that say which dependencies or which toolchain a checkout installs. */
+const DEPENDENCY_FILES = new Set([
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "yarn.lock",
+    ".yarnrc.yml",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "bun.lock",
+    "bun.lockb",
+    ".npmrc",
+    "composer.json",
+    "composer.lock",
+    "Gemfile",
+    "Gemfile.lock",
+    "go.mod",
+    "go.sum",
+    "go.work",
+    "go.work.sum",
+    "Cargo.toml",
+    "Cargo.lock",
+    "pyproject.toml",
+    "poetry.lock",
+    "uv.lock",
+    "Pipfile",
+    "Pipfile.lock",
+    "setup.py",
+    "setup.cfg",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "gradle.lockfile",
+    "global.json",
+    "packages.lock.json",
+    "Directory.Packages.props",
+    ".nvmrc",
+    ".node-version",
+    ".tool-versions",
+    ".python-version",
+    ".ruby-version",
+    ".java-version",
+    "rust-toolchain",
+    "rust-toolchain.toml",
+    "mise.toml",
+    ".mise.toml",
+]);
+const REQUIREMENTS_FILE = /^requirements.*\.(?:txt|in)$/;
+/** A package.json's keys that change what an install puts in `node_modules`. */
+const PACKAGE_INSTALL_KEYS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+    "bundleDependencies",
+    "bundledDependencies",
+    "overrides",
+    "resolutions",
+    "pnpm",
+    "packageManager",
+    "engines",
+    "workspaces",
+];
+/** A JSON value as text with every object's keys sorted, so reordered keys compare equal. Pure. */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+        return `{${entries.map(([key, inner]) => `${JSON.stringify(key)}:${canonicalJson(inner)}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "undefined";
+}
+/** Whether a package.json says to install something else at HEAD than at `base`; a side git cannot read differs. */
+async function packageInstallDiffers(root, base, path, git) {
+    const read = async (rev) => {
+        const shown = await git(["show", `${rev}:${path}`], root);
+        if (shown.code !== 0)
+            return null;
+        try {
+            const value = JSON.parse(shown.stdout);
+            return value && typeof value === "object" ? value : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const before = await read(base);
+    const after = await read("HEAD");
+    if (!before || !after)
+        return true;
+    return PACKAGE_INSTALL_KEYS.some((key) => canonicalJson(before[key]) !== canonicalJson(after[key]));
+}
+/**
+ * Why the clone's installed dependencies are not the base's, or null when
+ * they are: the attempt's commits changed a lockfile, a manifest or a
+ * toolchain pin. Uncommitted changes (an install's lockfile churn) are not
+ * the attempt's and do not count.
+ */
+async function dependencyChange(root, base, git) {
+    const diff = await git(["diff", "--name-only", "-z", "--no-renames", base, "HEAD"], root);
+    if (diff.code !== 0)
+        return `git could not list what the attempt changed: ${why(diff)}`;
+    for (const path of diff.stdout.split("\0").filter(Boolean)) {
+        const name = basename(path);
+        const installs = DEPENDENCY_FILES.has(name) ||
+            REQUIREMENTS_FILE.test(name) ||
+            (name === "package.json" && (await packageInstallDiffers(root, base, path, git)));
+        if (installs) {
+            return `the attempt changed what is installed since the base (${path}), so the installed dependencies are not the base's`;
+        }
+    }
+    return null;
+}
+async function fingerprint(top, git) {
+    const must = async (args, env) => {
+        const result = await git(args, top, env);
+        if (result.code !== 0)
+            throw new Error(`git ${args[0]} failed: ${why(result)}`);
+        return result.stdout.trim();
+    };
+    const head = await must(["rev-parse", "--verify", "HEAD"]);
+    const symbolic = await git(["symbolic-ref", "-q", "HEAD"], top);
+    const branch = symbolic.code === 0 ? symbolic.stdout.trim() : "";
+    // Fails on an index with unresolved conflicts.
+    const index = await must(["write-tree"]);
+    // Every file `.gitignore` leaves in, through a throwaway index seeded from
+    // the real one so `add -A` re-reads only what changed (treeSnapshot.ts).
+    const scratch = mkdtempSync(join(tmpdir(), "yagni-base-tree-"));
+    try {
+        const scratchIndex = join(scratch, "index");
+        const env = { GIT_INDEX_FILE: scratchIndex };
+        const realIndex = resolvePath(top, await must(["rev-parse", "--git-path", "index"]));
+        if (existsSync(realIndex))
+            copyFileSync(realIndex, scratchIndex);
+        else
+            await must(["read-tree", "HEAD"], env);
+        await must(["add", "-A"], env);
+        const files = await must(["write-tree"], env);
+        return { head, branch, index, files };
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}
+/** The most untracked folders read for empty ones; past it the tree is not touched. */
+const MAX_UNTRACKED_DIRS = 2_000;
+/** Folders the empty-folder walk never enters: another repository, or installed dependencies. */
+const UNWALKED_DIRS = new Set([".git", "node_modules"]);
+/** The untracked folders with nothing in them, which `stash` and `clean` remove. */
+async function untrackedEmptyDirs(root, git) {
+    const listed = await git(["ls-files", "--others", "--directory", "--exclude-standard", "-z"], root);
+    if (listed.code !== 0)
+        throw new Error(`git ls-files failed: ${why(listed)}`);
+    const empty = [];
+    let read = 0;
+    const walk = (dir) => {
+        read += 1;
+        if (read > MAX_UNTRACKED_DIRS)
+            throw new Error("too many untracked folders to put back");
+        const entries = readdirSync(join(root, dir), { withFileTypes: true });
+        if (entries.length === 0)
+            empty.push(dir);
+        for (const entry of entries) {
+            if (entry.isDirectory() && !UNWALKED_DIRS.has(entry.name))
+                walk(join(dir, entry.name));
+        }
+    };
+    for (const entry of listed.stdout.split("\0")) {
+        if (entry.endsWith("/"))
+            walk(entry.slice(0, -1));
+    }
+    return empty;
+}
+/** Each uncommitted file's permission bits, by repository-relative path. */
+async function uncommittedModes(root, git) {
+    const status = await git(["status", "--porcelain", "-z", "--untracked-files=all"], root);
+    if (status.code !== 0)
+        throw new Error(`git status failed: ${why(status)}`);
+    const modes = new Map();
+    const fields = status.stdout.split("\0");
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i] ?? "";
+        if (field.length < 4)
+            continue;
+        // A rename's or a copy's source path is the next field.
+        if (/[RC]/.test(field.slice(0, 2)))
+            i += 1;
+        const path = field.slice(3);
+        try {
+            const stat = lstatSync(join(root, path));
+            if (stat.isFile())
+                modes.set(path, stat.mode & 0o7777);
+        }
+        catch {
+            // Deleted in the tree: nothing to give a mode back to.
+        }
+    }
+    return modes;
+}
+async function readTree(root, git) {
+    return {
+        fingerprint: await fingerprint(root, git),
+        emptyDirs: await untrackedEmptyDirs(root, git),
+        modes: await uncommittedModes(root, git),
+    };
+}
+function differences(before, after) {
+    return [
+        ...(after.head !== before.head ? [`HEAD is ${after.head}, not ${before.head}`] : []),
+        ...(after.branch !== before.branch
+            ? [`HEAD is on ${after.branch || "no branch"}, not ${before.branch || "no branch"}`]
+            : []),
+        ...(after.index !== before.index ? ["the index differs"] : []),
+        ...(after.files !== before.files ? ["the files differ"] : []),
+    ];
+}
+const IN_PROGRESS = [
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "rebase-merge",
+    "rebase-apply",
+];
+async function operationInProgress(top, git) {
+    for (const name of IN_PROGRESS) {
+        const path = await git(["rev-parse", "--git-path", name], top);
+        if (path.code !== 0)
+            return `git could not say whether a ${name} is in progress`;
+        if (existsSync(resolvePath(top, path.stdout.trim())))
+            return `a ${name} is in progress`;
+    }
+    return null;
+}
+async function refOf(top, ref, git) {
+    const result = await git(["rev-parse", "-q", "--verify", ref], top);
+    return result.code === 0 ? result.stdout.trim() : null;
+}
+/**
+ * Run `measure` on the files of the commit `base`, then put the tree back as
+ * it was. `skipped` (with why) when it could not start, the tree as it was;
+ * throws {@link BaseTreeRestoreError} when the tree could not be put back
+ * exactly, and rethrows what `measure` threw once the tree is back.
+ */
+export async function measureOnBaseTree(cwd, base, measure, opts = {}) {
+    const git = opts.git ?? defaultBaseTreeGit;
+    if (!baseCommitOf(base))
+        return skipped("the base is not a commit id");
+    // Nothing is touched until the tree is read: any trouble here is a skip.
+    let root;
+    let before;
+    try {
+        const top = await git(["rev-parse", "--show-toplevel"], cwd);
+        if (top.code !== 0)
+            return skipped(`not a git checkout: ${why(top)}`);
+        root = top.stdout.trim();
+        if ((await git(["cat-file", "-e", `${base}^{commit}`], root)).code !== 0) {
+            return skipped("the base commit is not in this clone");
+        }
+        const busy = await operationInProgress(root, git);
+        if (busy)
+            return skipped(busy);
+        const installs = await dependencyChange(root, base, git);
+        if (installs)
+            return skipped(installs);
+        before = await readTree(root, git);
+    }
+    catch (err) {
+        return skipped(`the tree could not be read: ${errorText(err)}`);
+    }
+    const aside = await checkOutBase(root, base, git);
+    let ran;
+    if (aside.skip !== null) {
+        ran = { outcome: skipped(aside.skip) };
+    }
+    else {
+        try {
+            ran = { outcome: { kind: "measured", value: await measure() } };
+        }
+        catch (error) {
+            ran = { error };
+        }
+    }
+    const state = {
+        head: before.fingerprint.head,
+        branch: before.fingerprint.branch.replace(/^refs\/heads\//, "") || null,
+        stash: aside.stash,
+    };
+    try {
+        await putBack(root, before, state, aside.setAside, git);
+    }
+    catch (err) {
+        if (err instanceof BaseTreeRestoreError)
+            throw err;
+        throw new BaseTreeRestoreError(`the session's tree could not be put back after the base measurement: ${errorText(err)}`, state);
+    }
+    if ("error" in ran)
+        throw ran.error;
+    return ran.outcome;
+}
+/**
+ * Set the session's tree aside and put the base's files in it. `setAside`
+ * once everything git sees outside HEAD is in the stash: only then may
+ * putting the tree back force a checkout and clean what is left. `skip` says
+ * why the base is not checked out; the caller puts the tree back either way.
+ */
+async function checkOutBase(root, base, git) {
+    let stash = null;
+    let setAside = false;
+    const done = (skip) => ({ stash, setAside, skip });
+    try {
+        const stashBefore = await refOf(root, "refs/stash", git);
+        const pushed = await git([
+            "stash",
+            "push",
+            "--include-untracked",
+            "--quiet",
+            "-m",
+            "yagni: the tree, set aside to measure the base",
+        ], root);
+        const stashAfter = await refOf(root, "refs/stash", git);
+        if (stashAfter && stashAfter !== stashBefore)
+            stash = stashAfter;
+        if (pushed.code !== 0)
+            return done(`the tree could not be set aside: ${why(pushed)}`);
+        const left = await git(["status", "--porcelain", "--untracked-files=all"], root);
+        if (left.code !== 0 || left.stdout.trim())
+            return done("the tree was not clean once set aside");
+        setAside = true;
+        // A file only the base tracks, sitting here ignored (a build output the
+        // change stopped tracking), would be overwritten and then deleted; one
+        // in the way of its folder makes the checkout refuse.
+        const baseOnly = await git(["diff", "--name-only", "-z", "--no-renames", "--diff-filter=D", base, "HEAD"], root);
+        if (baseOnly.code !== 0)
+            return done(`git could not compare the base: ${why(baseOnly)}`);
+        const inTheWay = baseOnly.stdout
+            .split("\0")
+            .filter(Boolean)
+            .find((path) => {
+            try {
+                lstatSync(join(root, path));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (inTheWay)
+            return done(`an ignored file is where the base has a tracked one: ${inTheWay}`);
+        const onBase = await git(["checkout", "--quiet", "--no-overwrite-ignore", "--detach", base, "--"], root);
+        if (onBase.code !== 0)
+            return done(`the base could not be checked out: ${why(onBase)}`);
+        return done(null);
+    }
+    catch (err) {
+        return done(`the base could not be checked out: ${errorText(err)}`);
+    }
+}
+/**
+ * Put the tree back to `before`, or throw {@link BaseTreeRestoreError} saying
+ * what is wrong. Only a tree set aside whole is forced back to its branch and
+ * cleaned of what the measurement left; otherwise the stash, if the tree
+ * changed, goes back on the tree as it is. A `stash apply` that exits non-zero
+ * on a tree that is back all the same is not a failure.
+ */
+async function putBack(root, before, state, setAside, git) {
+    const { stash } = state;
+    const recover = stash ? ` Its uncommitted state is in the stash ${stash}.` : "";
+    const fail = (what) => {
+        throw new BaseTreeRestoreError(`the session's tree could not be put back after the base measurement: ${what}.${recover}`, state);
+    };
+    const read = async () => {
+        try {
+            return await fingerprint(root, git);
+        }
+        catch (err) {
+            return fail(`the tree could not be read again: ${errorText(err)}`);
+        }
+    };
+    let applyFailed = null;
+    const apply = async () => {
+        if (!stash)
+            return;
+        const applied = await git(["stash", "apply", "--index", "--quiet", stash], root);
+        if (applied.code !== 0)
+            applyFailed = `git stash apply failed: ${why(applied)}`;
+    };
+    if (setAside) {
+        const back = await git(state.branch
+            ? ["checkout", "--quiet", "--force", state.branch, "--"]
+            : ["checkout", "--quiet", "--force", "--detach", state.head, "--"], root);
+        if (back.code !== 0)
+            fail(`git checkout ${state.branch ?? state.head} failed: ${why(back)}`);
+        const cleaned = await git(["clean", "-fdq"], root);
+        if (cleaned.code !== 0)
+            fail(`git clean failed: ${why(cleaned)}`);
+        await apply();
+    }
+    else if (differences(before.fingerprint, await read()).length > 0) {
+        // Setting it aside stopped partway, after it took something.
+        await apply();
+    }
+    const problems = restoreUnrecorded(root, before);
+    const off = differences(before.fingerprint, await read());
+    if (off.length > 0 || problems.length > 0) {
+        fail([...(applyFailed ? [applyFailed] : []), ...off, ...problems].join("; "));
+    }
+    if (stash && (await refOf(root, "refs/stash", git)) === stash) {
+        await git(["stash", "drop", "--quiet"], root);
+    }
+}
+/** Put back what git keeps no record of: the untracked empty folders and the uncommitted files' modes. What could not be. */
+function restoreUnrecorded(root, before) {
+    const problems = [];
+    for (const dir of before.emptyDirs) {
+        try {
+            mkdirSync(join(root, dir), { recursive: true });
+        }
+        catch (err) {
+            problems.push(`the empty folder ${dir} could not be made again: ${errorText(err)}`);
+        }
+    }
+    for (const [path, mode] of before.modes) {
+        try {
+            chmodSync(join(root, path), mode);
+        }
+        catch (err) {
+            problems.push(`${path} could not be given its mode back: ${errorText(err)}`);
+        }
+    }
+    return problems;
+}
+//# sourceMappingURL=baseTree.js.map

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

@@ -152,6 +152,19 @@ export declare function ticketOfBranch(branch: string | null): string | undefine
 export declare function attemptCommitted(cwd: string, exec: WorktreeExec, attemptId: string): Promise<boolean | null>;
 /** Read the execution's work off git. Never throws: a read that fails is a note. */
 export declare function gitFacts(cwd: string, exec: WorktreeExec, baseSha: string): Promise<GitFacts>;
+/**
+ * `result.json` for a session that stopped before it built anything, its
+ * tree not put back after the base measurement (baseTree.ts): a failed stop
+ * with why, on the head it started on, with nothing committed. Pure.
+ */
+export declare function unbuiltCloudResult(input: {
+    identity: CloudIdentity;
+    stage: CloudStage;
+    head: string;
+    branch: string | null;
+    roundsDone: number;
+    note: string;
+}): AttemptResult;
 /**
  * The checks that gave no verdict because the sandbox could not run them,
  * each with why, as one sentence for the person who reads the result: no

package/dist/extension/pipeline/cloud.js

@@ -236,6 +236,30 @@ export async function gitFacts(cwd, exec, baseSha) {
         notes,
     };
 }
+/**
+ * `result.json` for a session that stopped before it built anything, its
+ * tree not put back after the base measurement (baseTree.ts): a failed stop
+ * with why, on the head it started on, with nothing committed. Pure.
+ */
+export function unbuiltCloudResult(input) {
+    return {
+        version: 1,
+        ...input.identity,
+        stage: input.stage,
+        headSha: input.head,
+        branch: input.branch,
+        baseSha: input.head,
+        stopReason: "failed",
+        rounds: input.roundsDone,
+        checks: [],
+        findingsOpen: [],
+        filesChanged: [],
+        commits: [],
+        notes: [input.note],
+        blockingKey: null,
+        usage: { tokens: 0, costMillicents: 0, byStage: [] },
+    };
+}
 /** Checks the cannot-run note names before "and N more". */
 const MAX_NAMED_CANNOT_RUN = 5;
 /**

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

@@ -70,6 +70,7 @@
  * cannot finish, rather than being killed partway through one (see budget.ts). Such a run gets the sandbox lane's
  * ceilings (`SANDBOX_RUN_BUDGET`), not interactive /go's.
  */
+import { measureOnBaseTree } from "./baseTree.js";
 import { snapshotWorkspace } from "./workspace.js";
 import type { WorktreeExec } from "./worktree.js";
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
@@ -183,6 +184,10 @@ export interface HeadlessGoDeps {
     makeRunVerify?: typeof makeRunVerify;
     /** The approved checks' run on the unchanged code (`measureOnBase`). Defaults to the real one; injected in tests. */
     measureChecksOnBase?: ReturnType<typeof makeMeasureChecksOnBase>;
+    /** 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. */

package/dist/extension/pipeline/headlessGo.js

@@ -72,7 +72,8 @@
  */
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
-import { CLOUD_SESSION_ENV, completeCloudSession, prepareCloudLane, readCloudEnv, } from "./cloud.js";
+import { baseCommitOf, BaseTreeRestoreError, measureOnBaseTree, pathsCommittedSince, } from "./baseTree.js";
+import { CLOUD_SESSION_ENV, completeCloudSession, prepareCloudLane, readCloudEnv, RESULT_FILE_NAME, unbuiltCloudResult, } from "./cloud.js";
 import { scanChange } from "./changeScan.js";
 import { continuationResumePlan, parseContinuation, } from "./continuation.js";
 import { finishExec } from "./finish.js";
@@ -450,10 +451,9 @@ export async function runHeadlessGo(argv, deps = {}) {
     // 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 it takes none (a
-    // cloud continuation's earlier work is committed on its branch, and taking
-    // the baseline there would excuse the attempt's own breakage). It then leans
-    // on `checks.json`, whose base standing the host took on the real base.
+    // 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;
     const logPipeline = (event, data) => {
         deps.logger?.(event, data);
@@ -467,6 +467,41 @@ export async function runHeadlessGo(argv, deps = {}) {
         ? (event) => logPipeline("verify_check", event)
         : undefined;
     const heard = onCheck ? { onCheck } : {};
+    /**
+     * A resumed session whose tree could not be put back after its base
+     * measurement stops before it builds. Its tree is not the one it started
+     * on, so it commits nothing; a cloud session reports a failed stop on the
+     * head it started on, so its host pushes nothing either.
+     */
+    const stopUnbuilt = (err, base) => {
+        const message = `The session stops before it builds: ${err.message}`;
+        logPipeline("verify_base_tree", { base, error: err.message });
+        emit({ type: "pipeline_error", message });
+        writeErr(message);
+        if (cloud) {
+            const attempt = unbuiltCloudResult({
+                identity: cloud.identity,
+                stage: cloud.stage,
+                head: err.head,
+                branch: err.branch,
+                roundsDone: continuation?.reviewRoundsDone ?? 0,
+                note: message,
+            });
+            const path = join(cloud.outDir, RESULT_FILE_NAME);
+            try {
+                (deps.writeFile ?? writeFileSync)(path, `${JSON.stringify(attempt, null, 2)}\n`);
+            }
+            catch (writeError) {
+                // The stream's result then says why the file is missing, as a written one would.
+                const note = `${RESULT_FILE_NAME} could not be written: ${writeError instanceof Error ? writeError.message : String(writeError)}`;
+                attempt.notes.push(note);
+                logPipeline("result_write_failed", { path, error: note });
+                writeErr(note);
+            }
+            emit({ type: "pipeline_result", ...attempt });
+        }
+        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.
@@ -479,46 +514,48 @@ export async function runHeadlessGo(argv, deps = {}) {
             tooLittle: shareMs !== undefined && shareMs < MIN_BASELINE_BUDGET_MS,
         };
     };
-    if (mission?.plan && !continuation && !fixRound && !deps.signal?.aborted) {
-        const dirs = baselineDirs(cwd, planPaths(mission.plan), readFile);
+    /** The gate's detected checks on the tree as it is, in `dirs`; never throws. */
+    const takeBaseline = async (dirs) => {
         const share = preBuildShare();
-        if (dirs.length > 0 && share.tooLittle) {
+        if (share.tooLittle) {
             logPipeline("verify_baseline", {
                 skipped: "too little of the run's time left",
                 deadlineLeftMs: share.leftMs,
                 baselineBudgetMs: share.shareMs,
             });
+            return;
         }
-        else if (dirs.length > 0) {
-            try {
-                const taken = await (deps.takeVerifyBaseline ?? makeTakeVerifyBaseline(heard))(cwd, dirs, deps.signal, share.shareMs);
-                logPipeline("verify_baseline", {
-                    ran: taken.ran,
-                    failures: taken.failures,
-                    notes: taken.notes,
-                });
-                if (taken.baseline.size > 0)
-                    baseline = taken.baseline;
-            }
-            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}`);
-            }
+        try {
+            const taken = await (deps.takeVerifyBaseline ?? makeTakeVerifyBaseline(heard))(cwd, dirs, deps.signal, share.shareMs);
+            logPipeline("verify_baseline", {
+                ran: taken.ran,
+                failures: taken.failures,
+                notes: taken.notes,
+            });
+            if (taken.baseline.size > 0)
+                baseline = taken.baseline;
+        }
+        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}`);
         }
+    };
+    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. A continuation or a fix round carries a change,
-    // so it measures nothing; its host hands it what an earlier session found.
+    // not this change's to fix.
     let checksOnBase;
     const measureFile = gateOpts?.repoChecks?.() ?? null;
-    if (measureFile?.checks.some((check) => check.measureOnBase) &&
-        !continuation &&
-        !fixRound &&
-        !deps.signal?.aborted) {
+    /** 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", {
@@ -526,24 +563,87 @@ export async function runHeadlessGo(argv, deps = {}) {
                 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);
+    }
+    // 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
+    // (`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.
+    if (cloud && resumed && !deps.signal?.aborted) {
+        const base = baseCommitOf(continuation?.baseSha) ?? baseCommitOf(fixRound?.baseRef);
+        const share = preBuildShare();
+        if (!base) {
+            logPipeline("verify_base_tree", { skipped: "the host named no base commit" });
+        }
+        else if (share.tooLittle) {
+            logPipeline("verify_base_tree", {
+                base,
+                skipped: "too little of the run's time left",
+                leftMs: share.leftMs,
+                shareMs: share.shareMs,
+            });
         }
         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 {
-                const measured = await (deps.measureChecksOnBase ?? makeMeasureChecksOnBase(heard))(cwd, measureFile, 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;
+                // A list git cannot read narrows the baseline 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);
+                    });
+                logPipeline("verify_base_tree", outcome.kind === "measured"
+                    ? { base, measured: true, ...unread }
+                    : { base, skipped: outcome.reason, ...unread });
             }
             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}`);
+                // Any other error came once the tree was back: only the measurement failed.
+                if (err instanceof BaseTreeRestoreError)
+                    return stopUnbuilt(err, base);
+                logPipeline("verify_base_tree", {
+                    base,
+                    error: err instanceof Error ? err.message : String(err),
+                });
             }
         }
     }

package/dist/extension/pipeline/verify.js

@@ -1734,9 +1734,10 @@ export function makeRunVerify(opts = {}) {
      * failure with its output. A check that passed on the unchanged code
      * (`passedOnBase`, measured in this environment) and now says it lacks a
      * credential failed: the change made it need one, and that is the change's
-     * (`needs` says what). Only the session that measured knows it passed: a
-     * resumed session's host carries forward what failed on the base, never
-     * what passed, so there the same check is could not run, failing open.
+     * (`needs` says what). Only a session that measured knows it passed: a
+     * resumed session that could not measure on the attempt's base gets what
+     * failed there from its host, never what passed, so there the same check
+     * is could not run, failing open.
      * The stream hears the command start, and its end here unless it failed:
      * a failure's caller tells its end once it decided whose the failure is.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.9-staging.2082.1",
+  "version": "1.2.10-staging.2090.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "aa51aeb734fe374a2b12c82a0680729e2bf5c4d1"
+  "yagniSourceSha": "103c1ce736a7d5b0d46b562836ea60279d755976"
 }