@yagni-app/code-staging 1.2.2-staging.1555.1 → 1.2.2-staging.1563.1

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

@@ -50,6 +50,7 @@
  * anchored to this process's clock at start: the run then stops `budget_exceeded` before a review round or fix it
  * cannot finish, rather than being killed partway through one (see budget.ts).
  */
+import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 import { type RunBudget } from "./budget.js";
 import type { Finding, JsonEvent, ModelTier, PipelineStage, StageId, StageTag, StageUsage, StopReason } from "./types.js";
@@ -151,6 +152,8 @@ export interface HeadlessGoDeps {
     onEvent?: (ev: JsonEvent, tag: StageTag) => void;
     /** Additive tap on the pipeline's own log events. */
     logger?: (event: string, data?: unknown) => void;
+    /** Mission runs' working-tree snapshots (see treeSnapshot.ts); injected in tests. */
+    startTreeSnapshots?: (cwd: string, snapshotDeps: TreeSnapshotDeps) => () => Promise<void>;
 }
 /**
  * Parse the argv remainder after `go`. Accepts both `--flag value` and

package/dist/extension/pipeline/headlessGo.js

@@ -54,6 +54,7 @@ import { readFileSync } from "node:fs";
 import { resolveFanoutMode } from "./fanout.js";
 import { makeFanoutBeats } from "./fanoutBeats.js";
 import { normalizeMission } from "./mission.js";
+import { startTreeSnapshots } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 import { loadGroundingEnabled } from "../grounding.js";
 import { codeStateHome } from "../stateHome.js";
@@ -333,6 +334,13 @@ export async function runHeadlessGo(argv, deps = {}) {
                 emit({ type: "pipeline_log", event, ...(data === undefined ? {} : { data }) });
         },
     };
+    // A mission's tree is the only copy of its work until the host commits it,
+    // so it is snapshotted for the host to recover from (treeSnapshot.ts).
+    const stopSnapshots = mission
+        ? (deps.startTreeSnapshots ?? startTreeSnapshots)(cwd, {
+            onError: (message) => writeErr(`Working-tree checkpoint failed (the run continues without it): ${message}`),
+        })
+        : null;
     try {
         const result = await runPipeline(files.ticket, pipelineDeps);
         const headless = buildResult(result, {
@@ -353,5 +361,8 @@ export async function runHeadlessGo(argv, deps = {}) {
         writeErr(message);
         return { exitCode: HEADLESS_GO_EXIT.unverified, error: message };
     }
+    finally {
+        await stopSnapshots?.();
+    }
 }
 //# sourceMappingURL=headlessGo.js.map

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

@@ -0,0 +1,51 @@
+/**
+ * Working-tree snapshots for a headless mission run.
+ *
+ * In mission mode the pipeline's FINISH stage never runs: the host turns
+ * whatever is in the tree when the harness ends into the one candidate commit.
+ * That makes the tree the only copy of the work, and a model can empty it in
+ * the last minute of a stage (a `git stash` to see whether a test failed before
+ * its change, a `git checkout .` to retry an approach) and then be cut off by
+ * the wall clock before putting it back. The host then finds the tree at the
+ * approved base and the paid build is gone.
+ *
+ * So, on an interval and once at the end, the run records the tree as a commit
+ * under {@link CHECKPOINT_REF}: a side ref the host reads only to recover from
+ * exactly that, never a commit on the branch. It goes through a throwaway
+ * index (`GIT_INDEX_FILE`), so HEAD, the real index and the files are never
+ * touched and the model's own git view is unchanged; `add -A` against that
+ * index still picks up new files and still honours `.gitignore`. A clean tree
+ * never overwrites the last real snapshot. Hooks are off for every call: the
+ * repository is the model's to edit, and a hook it installed must not run.
+ *
+ * Fail-soft throughout: a snapshot that cannot be taken is just not taken.
+ */
+/** The side ref a snapshot lands on. Never pushed: the candidate bundle carries HEAD only. */
+export declare const CHECKPOINT_REF = "refs/yagni/checkpoint";
+/** How often a mission run records its tree. */
+export declare const SNAPSHOT_INTERVAL_MS = 60000;
+/**
+ * Record the working tree under {@link CHECKPOINT_REF}. Answers the snapshot
+ * commit, or undefined when the tree matches HEAD or anything failed.
+ */
+export declare function snapshotWorkingTree(cwd: string, onError?: (message: string) => void): Promise<string | undefined>;
+export interface TreeSnapshotDeps {
+    intervalMs?: number;
+    /** Bound on the stop-time snapshot; defaults to {@link STOP_SNAPSHOT_BOUND_MS}. */
+    stopBoundMs?: number;
+    /**
+     * Told when snapshots start failing (once per run of failures: a success
+     * re-arms it), and always about the final snapshot failing or being cut
+     * off, so a recovery that never arms or a stale checkpoint is visible.
+     */
+    onError?: (message: string) => void;
+    snapshot?: (cwd: string, onError?: (message: string) => void) => Promise<string | undefined>;
+    setInterval?: (fn: () => void, ms: number) => NodeJS.Timeout;
+    clearInterval?: (timer: NodeJS.Timeout) => void;
+}
+/**
+ * Snapshot `cwd` every {@link SNAPSHOT_INTERVAL_MS} until the returned stop
+ * runs, which takes one last snapshot. Snapshots never overlap.
+ */
+export declare function startTreeSnapshots(cwd: string, deps?: TreeSnapshotDeps): () => Promise<void>;
+//# sourceMappingURL=treeSnapshot.d.ts.map

package/dist/extension/pipeline/treeSnapshot.js

@@ -0,0 +1,139 @@
+/**
+ * Working-tree snapshots for a headless mission run.
+ *
+ * In mission mode the pipeline's FINISH stage never runs: the host turns
+ * whatever is in the tree when the harness ends into the one candidate commit.
+ * That makes the tree the only copy of the work, and a model can empty it in
+ * the last minute of a stage (a `git stash` to see whether a test failed before
+ * its change, a `git checkout .` to retry an approach) and then be cut off by
+ * the wall clock before putting it back. The host then finds the tree at the
+ * approved base and the paid build is gone.
+ *
+ * So, on an interval and once at the end, the run records the tree as a commit
+ * under {@link CHECKPOINT_REF}: a side ref the host reads only to recover from
+ * exactly that, never a commit on the branch. It goes through a throwaway
+ * index (`GIT_INDEX_FILE`), so HEAD, the real index and the files are never
+ * touched and the model's own git view is unchanged; `add -A` against that
+ * index still picks up new files and still honours `.gitignore`. A clean tree
+ * never overwrites the last real snapshot. Hooks are off for every call: the
+ * repository is the model's to edit, and a hook it installed must not run.
+ *
+ * Fail-soft throughout: a snapshot that cannot be taken is just not taken.
+ */
+import { execFile } from "node:child_process";
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+/** The side ref a snapshot lands on. Never pushed: the candidate bundle carries HEAD only. */
+export const CHECKPOINT_REF = "refs/yagni/checkpoint";
+/** How often a mission run records its tree. */
+export const SNAPSHOT_INTERVAL_MS = 60_000;
+const GIT_BASE_ARGS = ["-c", "core.hooksPath=/dev/null", "-c", "user.name=YAGNI", "-c", "user.email=worker@yagni.local"];
+function gitOut(args, cwd, env) {
+    return new Promise((resolve, reject) => {
+        execFile("git", [...GIT_BASE_ARGS, ...args], { cwd, env: { ...process.env, ...env, GIT_TERMINAL_PROMPT: "0" }, maxBuffer: 4 * 1024 * 1024, timeout: 60_000 }, (err, stdout) => (err ? reject(err) : resolve(String(stdout).trim())));
+    });
+}
+/**
+ * Record the working tree under {@link CHECKPOINT_REF}. Answers the snapshot
+ * commit, or undefined when the tree matches HEAD or anything failed.
+ */
+export async function snapshotWorkingTree(cwd, onError) {
+    let scratch;
+    try {
+        scratch = mkdtempSync(join(tmpdir(), "yagni-snapshot-"));
+        const index = join(scratch, "index");
+        const env = { GIT_INDEX_FILE: index };
+        // Seed the throwaway index from the real one: its stat cache lets `add -A`
+        // skip every unchanged file instead of re-hashing the whole tree each
+        // minute. The result is the same tree either way (`add -A` makes the index
+        // match the files); a repo with no index yet starts from HEAD.
+        const realIndex = resolvePath(cwd, await gitOut(["rev-parse", "--git-path", "index"], cwd));
+        try {
+            copyFileSync(realIndex, index);
+        }
+        catch {
+            await gitOut(["read-tree", "HEAD"], cwd, env);
+        }
+        await gitOut(["add", "-A"], cwd, env);
+        const tree = await gitOut(["write-tree"], cwd, env);
+        const headTree = await gitOut(["rev-parse", "HEAD^{tree}"], cwd);
+        if (!tree || tree === headTree)
+            return undefined;
+        const commit = await gitOut(["commit-tree", tree, "-p", "HEAD", "-m", "yagni: working tree checkpoint"], cwd);
+        if (!commit)
+            return undefined;
+        await gitOut(["update-ref", CHECKPOINT_REF, commit], cwd);
+        return commit;
+    }
+    catch (err) {
+        onError?.(err instanceof Error ? err.message : String(err));
+        return undefined;
+    }
+    finally {
+        if (scratch)
+            rmSync(scratch, { recursive: true, force: true });
+    }
+}
+/** The most the final snapshot may hold up the harness's exit. */
+const STOP_SNAPSHOT_BOUND_MS = 15_000;
+/**
+ * Snapshot `cwd` every {@link SNAPSHOT_INTERVAL_MS} until the returned stop
+ * runs, which takes one last snapshot. Snapshots never overlap.
+ */
+export function startTreeSnapshots(cwd, deps = {}) {
+    const snapshot = deps.snapshot ?? snapshotWorkingTree;
+    let reported = false;
+    let running = null;
+    const take = (final = false) => {
+        if (!running) {
+            let failed = false;
+            const onError = (message) => {
+                failed = true;
+                if (final)
+                    deps.onError?.(`final snapshot: ${message}`);
+                else if (!reported)
+                    deps.onError?.(message);
+                reported = true;
+            };
+            running = snapshot(cwd, onError)
+                .catch((err) => onError(err instanceof Error ? err.message : String(err)))
+                .finally(() => {
+                // A snapshot that worked re-arms the report for the next failure.
+                if (!failed)
+                    reported = false;
+                running = null;
+            });
+        }
+        return running;
+    };
+    const schedule = deps.setInterval ?? ((fn, ms) => globalThis.setInterval(fn, ms));
+    const cancel = deps.clearInterval ?? ((handle) => globalThis.clearInterval(handle));
+    const timer = schedule(() => {
+        void take();
+    }, deps.intervalMs ?? SNAPSHOT_INTERVAL_MS);
+    timer.unref?.();
+    return async () => {
+        cancel(timer);
+        // The result is already known by now; a wedged filesystem must not hold
+        // the harness's exit for minutes. The last interval snapshot still stands.
+        const bound = deps.stopBoundMs ?? STOP_SNAPSHOT_BOUND_MS;
+        let timeout;
+        const limit = new Promise((resolve) => {
+            timeout = globalThis.setTimeout(() => resolve("cut_off"), bound);
+        });
+        const final = (async () => {
+            if (running)
+                await running;
+            await take(true);
+            return "taken";
+        })();
+        const outcome = await Promise.race([final, limit]);
+        if (timeout !== undefined)
+            globalThis.clearTimeout(timeout);
+        if (outcome === "cut_off") {
+            deps.onError?.(`final snapshot did not finish within ${bound} ms; the last interval snapshot stands`);
+        }
+    };
+}
+//# sourceMappingURL=treeSnapshot.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.2-staging.1555.1",
+  "version": "1.2.2-staging.1563.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": "8e8cae193cda58ced857dd7c5f832e83d29f3e5b"
+  "yagniSourceSha": "a55a45e07d5aa97ca696dcf692ec7c6507882a81"
 }