@yagni-app/code-staging 1.2.2-staging.1537.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/resilience.d.ts

@@ -37,6 +37,8 @@ export type RunStageFn = (stage: PipelineStage, ctx: {
     lens?: ReviewLens;
     grounded?: boolean;
 }, deps: RunStageDeps) => Promise<StageResult>;
+/** True when at least {@link MODEL_BOUND_SHARE} of a stage's elapsed time was spent outside tools. */
+export declare function isModelBound(elapsedMs: number, toolMs: number): boolean;
 /** One telemetry record per attempt (routed through the orchestrator logger). */
 export interface ResilienceAttemptRecord {
     stageId: string;
@@ -54,6 +56,10 @@ export interface ResilienceAttemptRecord {
     outcome: "ok" | "transient" | "fatal" | "timeout" | "aborted";
     /** Which timer fired, when the attempt timed out. */
     timeoutKind?: "idle" | "wall";
+    /** On a timeout: ms the attempt spent with a tool running (the rest went to the model). */
+    toolMs?: number;
+    /** On a timeout: whether the model, not tools, held most of the attempt's time. */
+    modelBound?: boolean;
     exitCode: number;
     stopReason?: string;
     elapsedMs: number;

package/dist/extension/pipeline/resilience.js

@@ -32,7 +32,34 @@ const WRITE_STAGE_IDS = ["implement", "fix"];
 /** Honest message stamped on a stage we aborted for exceeding its time budget. */
 const TIMEOUT_MESSAGE = "stage exceeded its idle or wall-clock timeout";
 const WALL_TIMEOUT_MESSAGE = "stage exceeded its wall-clock timeout";
+/**
+ * The wall clock fired while most of the stage's time went to waiting on model
+ * responses rather than running tools: a slow model, not a stage too big for one
+ * pass. Keeps {@link WALL_TIMEOUT_MESSAGE} as its prefix so a reader that only
+ * knows the plain sentence still reads it as a wall-clock stop.
+ */
+const WALL_TIMEOUT_MODEL_MESSAGE = `${WALL_TIMEOUT_MESSAGE} while waiting on the model`;
+/**
+ * Share of a timed-out stage's elapsed time outside tools at which the model,
+ * not the work, used the clock. The non-tool time also holds the child's
+ * startup and its teardown after the abort (seconds), which is noise against a
+ * real wall window of many minutes.
+ */
+const MODEL_BOUND_SHARE = 0.6;
 const IDLE_TIMEOUT_MESSAGE = "stage exceeded its idle timeout";
+/** True when at least {@link MODEL_BOUND_SHARE} of a stage's elapsed time was spent outside tools. */
+export function isModelBound(elapsedMs, toolMs) {
+    if (elapsedMs <= 0)
+        return false;
+    return (elapsedMs - toolMs) / elapsedMs >= MODEL_BOUND_SHARE;
+}
+function timeoutMessage(kind, modelBound) {
+    if (kind === "wall")
+        return modelBound ? WALL_TIMEOUT_MODEL_MESSAGE : WALL_TIMEOUT_MESSAGE;
+    if (kind === "idle")
+        return IDLE_TIMEOUT_MESSAGE;
+    return TIMEOUT_MESSAGE;
+}
 /** stderr fingerprints of a transient transport/provider blip worth retrying. */
 const TRANSIENT_STDERR = /\b429\b|\b5\d\d\b|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up/i;
 /**
@@ -117,6 +144,11 @@ export function withResilience(base, policy, opts = {}) {
             // and re-arms instead of aborting; the wall-clock timer stays the
             // backstop for a tool that is genuinely hung.
             let inFlightTools = 0;
+            // Time spent with at least one tool running. The rest of the stage's
+            // elapsed time is the model thinking or streaming, which is what tells a
+            // slow model apart from a stage that had too much work to do.
+            let toolMs = 0;
+            let toolsBusySince;
             let idleTimer;
             const armIdle = () => {
                 if (idleTimer)
@@ -137,10 +169,18 @@ export function withResilience(base, policy, opts = {}) {
             const originalOnEvent = deps.onEvent;
             const onEvent = (ev) => {
                 sawAnyEvent = true;
-                if (ev.type === "tool_execution_start")
+                if (ev.type === "tool_execution_start") {
+                    if (inFlightTools === 0)
+                        toolsBusySince = now();
                     inFlightTools += 1;
-                else if (ev.type === "tool_execution_end")
+                }
+                else if (ev.type === "tool_execution_end") {
                     inFlightTools = Math.max(0, inFlightTools - 1);
+                    if (inFlightTools === 0 && toolsBusySince !== undefined) {
+                        toolMs += now() - toolsBusySince;
+                        toolsBusySince = undefined;
+                    }
+                }
                 armIdle(); // reset the idle window on every live event
                 originalOnEvent?.(ev);
             };
@@ -154,6 +194,10 @@ export function withResilience(base, policy, opts = {}) {
                     clearTimeout(idleTimer);
             }
             const elapsedMs = now() - startedAt;
+            // A tool still running when the stage ended counts up to now.
+            if (toolsBusySince !== undefined)
+                toolMs += now() - toolsBusySince;
+            const modelBound = isModelBound(elapsedMs, toolMs);
             const callerAborted = callerSignal?.aborted === true;
             const record = (outcome, willRetry) => {
                 telemetry?.({
@@ -164,6 +208,7 @@ export function withResilience(base, policy, opts = {}) {
                     attempt,
                     outcome,
                     ...(timedOut && timeoutKind ? { timeoutKind } : {}),
+                    ...(timedOut ? { toolMs, modelBound } : {}),
                     exitCode: last.exitCode,
                     ...(last.stopReason ? { stopReason: last.stopReason } : {}),
                     elapsedMs,
@@ -179,9 +224,8 @@ export function withResilience(base, policy, opts = {}) {
                 record("ok", false);
                 return last;
             }
-            if (timedOut) {
-                last.errorMessage = timeoutKind === "wall" ? WALL_TIMEOUT_MESSAGE : timeoutKind === "idle" ? IDLE_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE;
-            }
+            if (timedOut)
+                last.errorMessage = timeoutMessage(timeoutKind, modelBound);
             const transient = classifyTransient(last, timedOut);
             // A wall-clock exhaustion is a "task too big" signal, not a stall: a
             // lane that opts out (subagents) fails honestly instead of re-burning

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.1537.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": "4213ac8b3bfc84b5ba97f3163242f943fb9bde9a"
+  "yagniSourceSha": "a55a45e07d5aa97ca696dcf692ec7c6507882a81"
 }