@yagni-app/code-staging 1.2.6-staging.1882.1 → 1.2.6-staging.1886.1

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

@@ -153,6 +153,8 @@ export interface HeadlessGoDeps {
     now?: () => number;
     runPipeline?: typeof defaultRunPipeline;
     readFile?: (path: string) => string;
+    /** Writes the gate's `ci-results.json`. Defaults to `writeFileSync`; injected in tests. */
+    writeFile?: (path: string, text: string) => void;
     /**
      * The verify gate a mission run uses, given its `checks.json` (null when
      * there is none). Defaults to the real gate; injected in tests.

package/dist/extension/pipeline/headlessGo.js

@@ -58,7 +58,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 { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { continuationResumePlan, parseContinuation } from "./continuation.js";
 import { resolveFanoutMode } from "./fanout.js";
@@ -66,7 +66,7 @@ import { makeFanoutBeats } from "./fanoutBeats.js";
 import { isBlockingFinding } from "./findings.js";
 import { MISSION_FIX_ROUND_FILE_NAME, readFixRoundFile } from "./fixRound.js";
 import { normalizeMission } from "./mission.js";
-import { MISSION_CHECKS_FILE_NAME, readMissionChecksFile } from "./missionChecks.js";
+import { MISSION_CHECKS_FILE_NAME, MISSION_CI_RESULTS_FILE_NAME, readMissionChecksFile, renderCiResults, } from "./missionChecks.js";
 import { startTreeSnapshots } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
 import { makeRunVerify } from "./verify.js";
@@ -333,7 +333,23 @@ export async function runHeadlessGo(argv, deps = {}) {
         const read = readMissionChecksFile(checksPath, readFile);
         if (read.file) {
             const checks = read.file;
-            runVerify = (deps.makeRunVerify ?? makeRunVerify)({ repoChecks: () => checks });
+            // How the failed CI checks' jobs went, for the host, beside the checks
+            // file. A write that fails is said once; the host then trusts the
+            // round's own account, as before.
+            const resultsPath = join(dirname(args.ticketFile), MISSION_CI_RESULTS_FILE_NAME);
+            let resultsWriteFailed = false;
+            const onFailedChecks = (results) => {
+                try {
+                    (deps.writeFile ?? writeFileSync)(resultsPath, renderCiResults(results));
+                }
+                catch (err) {
+                    if (resultsWriteFailed)
+                        return;
+                    resultsWriteFailed = true;
+                    writeErr(`Could not write ${resultsPath}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            };
+            runVerify = (deps.makeRunVerify ?? makeRunVerify)({ repoChecks: () => checks, onFailedChecks });
         }
         else if (read.problem !== "missing") {
             const why = read.problem === "malformed" ? "not a version 1 checks file" : "it could not be read";

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

@@ -3,7 +3,11 @@
  * run besides its own detected scripts: the plan's approved checks (each with
  * what the host already knows: it fails on the unchanged code, or the sandbox
  * cannot start it) and the pull request's CI jobs, read from the repository's
- * workflows at build time.
+ * workflows at build time. On a fix round, the job the pull request's CI
+ * reported failed is marked (`failedCheck`): the gate runs it whatever its
+ * `paths` say, and writes how it went to `ci-results.json` beside this file
+ * for the host, which reads it with its own parser
+ * (`packages/backend/src/agent/runs/mission/roundOutcomes.ts`).
  *
  * The format's producer is `renderMissionChecksJson` in
  * `packages/backend/src/integrations/e2b/missionFiles.ts`; this package does
@@ -35,12 +39,31 @@ export interface MissionCiJob {
         step: string;
         reason: string;
     }>;
+    /** The pull request's CI reported this job failed (at `step`): the gate runs it whatever its `paths` say. */
+    failedCheck?: {
+        name: string;
+        step?: string;
+    };
 }
 export interface MissionChecksFile {
     version: 1;
     checks: MissionCheck[];
     ciJobs: MissionCiJob[];
+    /** Failed CI checks the gate cannot run, with why (no job named like it, or a job that cannot run here). */
+    failedChecksCannotRun?: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+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. */
+export interface FailedCheckResult {
+    name: string;
+    status: "passed" | "failed" | "cannot_run" | "not_reached";
+    reason?: string;
 }
+/** `ci-results.json` (version 1), as the host reads it. */
+export declare function renderCiResults(checks: readonly FailedCheckResult[]): string;
 /** The file, or null when the text is not a well-formed version 1 file. */
 export declare function parseMissionChecksFile(text: string): MissionChecksFile | null;
 /**

package/dist/extension/pipeline/missionChecks.js

@@ -3,7 +3,11 @@
  * run besides its own detected scripts: the plan's approved checks (each with
  * what the host already knows: it fails on the unchanged code, or the sandbox
  * cannot start it) and the pull request's CI jobs, read from the repository's
- * workflows at build time.
+ * workflows at build time. On a fix round, the job the pull request's CI
+ * reported failed is marked (`failedCheck`): the gate runs it whatever its
+ * `paths` say, and writes how it went to `ci-results.json` beside this file
+ * for the host, which reads it with its own parser
+ * (`packages/backend/src/agent/runs/mission/roundOutcomes.ts`).
  *
  * The format's producer is `renderMissionChecksJson` in
  * `packages/backend/src/integrations/e2b/missionFiles.ts`; this package does
@@ -13,6 +17,11 @@
  */
 import { readFileSync } from "node:fs";
 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. */
+export function renderCiResults(checks) {
+    return `${JSON.stringify({ version: 1, checks }, null, 2)}\n`;
+}
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isString = (value) => typeof value === "string";
 function stringList(value) {
@@ -76,8 +85,27 @@ function parseJob(value) {
             return null;
         job[key] = list;
     }
+    if (value.failedCheck !== undefined) {
+        const failed = value.failedCheck;
+        if (!isRecord(failed) || !isString(failed.name))
+            return null;
+        if (failed.step !== undefined && !isString(failed.step))
+            return null;
+        job.failedCheck = { name: failed.name, ...(isString(failed.step) ? { step: failed.step } : {}) };
+    }
     return job;
 }
+function parseCannotRunChecks(value) {
+    if (!Array.isArray(value))
+        return null;
+    const entries = [];
+    for (const raw of value) {
+        if (!isRecord(raw) || !isString(raw.name) || !isString(raw.reason))
+            return null;
+        entries.push({ name: raw.name, reason: raw.reason });
+    }
+    return entries;
+}
 /** The file, or null when the text is not a well-formed version 1 file. */
 export function parseMissionChecksFile(text) {
     let parsed;
@@ -112,7 +140,12 @@ export function parseMissionChecksFile(text) {
             return null;
         ciJobs.push(job);
     }
-    return { version: 1, checks, ciJobs };
+    if (parsed.failedChecksCannotRun === undefined)
+        return { version: 1, checks, ciJobs };
+    const failedChecksCannotRun = parseCannotRunChecks(parsed.failedChecksCannotRun);
+    if (!failedChecksCannotRun)
+        return null;
+    return { version: 1, checks, ciJobs, failedChecksCannotRun };
 }
 /**
  * Read the file. `missing` (no such file: a host that predates it, or a run

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

@@ -47,7 +47,7 @@
  * findings, handoffs, or run records (§0.9).
  */
 import { type ToolchainFile } from "../toolchain/spawnHook.js";
-import { type MissionChecksFile } from "./missionChecks.js";
+import { type FailedCheckResult, type MissionChecksFile } from "./missionChecks.js";
 import type { Finding } from "./types.js";
 /**
  * Total wall-clock budget for a single verify run before it is abandoned
@@ -329,6 +329,11 @@ export interface MakeRunVerifyOpts {
      * jobs). Absent or null: no repository-checks half, as before.
      */
     repoChecks?: () => MissionChecksFile | null;
+    /**
+     * How each failed CI check's job went (the jobs `checks.json` marks), after
+     * every repository-checks half that ran: the host reads the last one.
+     */
+    onFailedChecks?: (results: FailedCheckResult[]) => void;
     /**
      * This run's own changed paths (repo-relative), which scope the CI jobs by
      * their `paths` filters. Default: the same `git status` the scope reads,

package/dist/extension/pipeline/verify.js

@@ -361,6 +361,14 @@ export function classifyVerifyInfraFailure(output, exitCode) {
     }
     if (/\bspawn(?:Sync)?\b.*\bENOENT\b/.test(output))
         return "spawn failed (ENOENT)";
+    // uv's and make's words for a tool that is not installed (`uv run ruff` with
+    // ruff absent from the environment, a Makefile recipe calling it).
+    if (/\bFailed to spawn: `[^`\n]+`\s+Caused by: No such file or directory \(os error 2\)/.test(output)) {
+        return "command not found (not installed in the environment)";
+    }
+    if (/^make(?:\[\d+\])?: \*\*\* \[[^\]\n]*\] Error 127$/m.test(output)) {
+        return "command not found (a Makefile recipe's tool is not installed)";
+    }
     return null;
 }
 /**
@@ -969,11 +977,31 @@ export function makeRunVerify(opts = {}) {
                 cannotRun.push(`\`${check.command}\`${check.cause ? ` (${check.cause})` : ""}`);
         }
         const paths = await changedPaths(cwd, signal, input.baselinePaths);
-        const jobs = file.ciJobs.filter((job) => ciJobInScope(job, paths));
+        // A job the pull request's CI reported failed runs whatever its paths say.
+        const jobs = file.ciJobs.filter((job) => job.failedCheck !== undefined || ciJobInScope(job, paths));
         for (const job of jobs) {
             for (const entry of job.cannotRun)
                 cannotRun.push(`CI ${job.name}, "${entry.step}" (${entry.reason})`);
         }
+        for (const failed of file.failedChecksCannotRun ?? []) {
+            cannotRun.push(`failed CI check "${failed.name}" (${failed.reason})`);
+        }
+        const failedJobs = new Map();
+        for (const job of jobs) {
+            if (!job.failedCheck)
+                continue;
+            failedJobs.set(job, job.steps.length > 0
+                ? { name: job.failedCheck.name, status: "not_reached" }
+                : { name: job.failedCheck.name, status: "cannot_run", reason: job.cannotRun[0]?.reason ?? "none of its steps can run in the sandbox" });
+        }
+        const report = () => {
+            if (failedJobs.size === 0 && !file.failedChecksCannotRun?.length)
+                return;
+            opts.onFailedChecks?.([
+                ...failedJobs.values(),
+                ...(file.failedChecksCannotRun ?? []).map((failed) => ({ name: failed.name, status: "cannot_run", reason: failed.reason })),
+            ]);
+        };
         if (cannotRun.length > 0) {
             const named = cannotRun.slice(0, MAX_NAMED_CANNOT_RUN).join("; ");
             const more = cannotRun.length > MAX_NAMED_CANNOT_RUN ? `; and ${cannotRun.length - MAX_NAMED_CANNOT_RUN} more` : "";
@@ -981,8 +1009,10 @@ export function makeRunVerify(opts = {}) {
         }
         const approved = file.checks.filter((check) => check.status !== "cannot_run");
         const steps = jobs.flatMap((job) => job.steps.map((step) => ({ job, step })));
-        if (approved.length === 0 && steps.length === 0)
+        if (approved.length === 0 && steps.length === 0) {
+            report();
             return { findings, reasons, labels };
+        }
         const buildLeft = (opts.repoChecksBuildBudgetMs ?? REPO_CHECKS_BUILD_BUDGET_MS) - repoChecksSpentMs;
         if (buildLeft < REPO_CHECK_MIN_START_MS) {
             reasons.push("approved checks and CI steps not run again: the build's check budget is spent; the host still runs the approved checks after the build");
@@ -999,6 +1029,8 @@ export function makeRunVerify(opts = {}) {
             reasons,
             labels,
             notReached: 0,
+            failedJobs,
+            approvedFailed: new Set(),
         };
         const before = await treeStatus(cwd, signal).catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
@@ -1010,6 +1042,9 @@ export function makeRunVerify(opts = {}) {
             await runCiSteps(run, steps, new Set(file.checks.map((check) => check.command.trim())));
         }
         finally {
+            // Whatever ran (an aborted half included) is what the host reads. A half
+            // skipped for the spent budget, above, writes nothing: the last real run stands.
+            report();
             repoChecksSpentMs += now() - halfStartedAt;
             // What the checks wrote into the tree (a coverage folder, an updated
             // snapshot, a build output) is not the build's change: undone, so the
@@ -1075,6 +1110,8 @@ export function makeRunVerify(opts = {}) {
             }
             const label = check.command.length > 80 ? `${check.command.slice(0, 77)}...` : check.command;
             const verdict = await runRepoCommand(run, check.command, run.cwd, undefined);
+            if (verdict.kind === "failed")
+                run.approvedFailed.add(check.command.trim());
             if (verdict.kind === "note") {
                 run.reasons.push(`approved check \`${label}\` ${verdict.reason}`);
             }
@@ -1099,11 +1136,35 @@ export function makeRunVerify(opts = {}) {
      */
     async function runCiSteps(run, steps, approvedCommands) {
         const stoppedJobs = new Set();
+        // A marked job's result: the first step that does not pass decides it;
+        // every step passing (or being an approved check that passed) is a pass.
+        const passedSteps = new Map();
+        const settle = (job, status, reason) => {
+            const result = run.failedJobs.get(job);
+            if (!result || result.status === "failed" || result.status === "cannot_run")
+                return;
+            result.status = status;
+            if (reason)
+                result.reason = reason;
+        };
+        const stepPassed = (job) => {
+            const count = (passedSteps.get(job) ?? 0) + 1;
+            passedSteps.set(job, count);
+            if (count === job.steps.length)
+                settle(job, "passed");
+        };
         for (const { job, step } of steps) {
             if (run.signal?.aborted)
                 return;
-            if (stoppedJobs.has(job) || approvedCommands.has(step.run.trim()))
+            if (stoppedJobs.has(job))
                 continue;
+            if (approvedCommands.has(step.run.trim())) {
+                if (run.approvedFailed.has(step.run.trim()))
+                    settle(job, "failed");
+                else
+                    stepPassed(job);
+                continue;
+            }
             if (run.left() < REPO_CHECK_MIN_START_MS) {
                 run.notReached += 1;
                 continue;
@@ -1115,13 +1176,16 @@ export function makeRunVerify(opts = {}) {
             if (verdict.kind === "passed") {
                 lastCiFailure.delete(key);
                 run.labels.push(`CI ${job.name}: ${step.name}`);
+                stepPassed(job);
                 continue;
             }
             stoppedJobs.add(job);
             if (verdict.kind === "note") {
                 run.reasons.push(`${where} ${verdict.reason}`);
+                settle(job, "cannot_run", `step "${step.name}" ${verdict.reason}`);
                 continue;
             }
+            settle(job, "failed");
             const stepFindings = repoFailureFindings(run, verdict, step.name, where, dir);
             const keys = new Set(stepFindings.map((f) => f.message));
             const previous = lastCiFailure.get(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.6-staging.1882.1",
+  "version": "1.2.6-staging.1886.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": "95cd2d148c903aba47bd97219b68c883f56811e4"
+  "yagniSourceSha": "8d2eb70b49e6d282e8587ac8458423f8249a4953"
 }