@tea-agent/loop-agent 0.16.1-beta.2 → 0.16.2

package/dist/commands/init.js

@@ -859,6 +859,12 @@ export function buildManagedGitignoreBlock() {
         ".harness/*.log",
         ".harness/init-surface.json",
         "",
+        "# Eval Lab runtime (candidates, campaigns, scorecards, dogfood scratch)",
+        ".harness/evaluation/",
+        "",
+        "# fullstack / worker dogfood evidence (local campaign scratch)",
+        ".harness/dogfood-evidence/",
+        "",
         "# worker task pool",
         ".harness/task-pool/*",
         ".task-pool/",
@@ -2089,7 +2095,7 @@ export function buildInitInstructions(input) {
         "- Enrich the root `README.md`: keep the deterministic project title and the loop-agent managed block intact, and fill the human-authored sections (项目概览, 技术栈与目录结构, 开发与验证) from the target project's actual files. The root README must serve both as a human-first project entry and as an agent work entry; replace the initialization-model supplement comments when the project files provide the information.",
         `- Populate \`${governanceRoot}/verification-matrix.md\` with the target project's actual quick, standard, and full verification commands derived from its real language and toolchain, keeping the governance rows intact.`,
         "- Project repo-local skills live in `.agents/skills/`. Do not create a root `skills/` directory in the target project; the package's bundled `skills/` remains the built-in fallback.",
-        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
+        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, evaluation, dogfood-evidence, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
         "- Do not copy examples by default; examples stay bundled in the tool and are available through `loop-agent examples`.",
         "- Add or update a loop-agent managed block in AGENTS.md.",
         "- The generated AGENTS.md must include documentation convergence and structured DAG write-boundary rules so target projects keep the same working discipline as this repository.",

package/dist/executors/dag-pi-executor.js

@@ -272,7 +272,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         persona,
         step,
     });
-    const mapped = mapPiResultToDagNodeResult(result, input.task.firstProtocolLine);
+    const mapped = mapPiResultToDagNodeResult(result);
     if (!isWriteTask) {
         return mapped;
     }
@@ -292,9 +292,11 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
             writeGuardOk = guard.ok;
             writeGuardViolations = guard.violations;
         }
-        catch {
+        catch (error) {
             writeGuardOk = false;
-            writeGuardViolations = ["write guard failed: git status unavailable"];
+            writeGuardViolations = [
+                `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            ];
         }
     }
     if (writeGuardOk) {
@@ -313,57 +315,17 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
-export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
-    const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
+export function mapPiResultToDagNodeResult(result) {
     return {
         ok: result.ok,
-        stdout: assistantText || result.stdout,
+        stdout: result.assistantText || result.stdout,
         stderr: result.stderr,
         failureCategory: result.failureCategory,
         durationMs: result.durationMs,
-        assistantText,
+        assistantText: result.assistantText,
         backend: result.backend,
         sdkAttempted: result.sdkAttempted,
         tokensUsed: result.tokensUsed,
         parsedEvents: result.parsedEvents,
     };
 }
-function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
-    if (!assistantText || !firstProtocolLine)
-        return assistantText;
-    const lines = assistantText.split(/\r?\n/);
-    let protocolIndex = -1;
-    let protocolLine = "";
-    for (const [index, line] of lines.entries()) {
-        const normalized = normalizeProtocolLine(line);
-        if (normalized.startsWith(firstProtocolLine)) {
-            protocolIndex = index;
-            protocolLine = normalized;
-            break;
-        }
-    }
-    if (protocolIndex < 0)
-        return assistantText;
-    if (protocolIndex === 0) {
-        return [protocolLine, ...lines.slice(1)].join("\n");
-    }
-    const before = lines.slice(0, protocolIndex);
-    const after = lines.slice(protocolIndex + 1);
-    while (before.at(-1)?.trim() === "" &&
-        after.at(0)?.trim() === "") {
-        after.shift();
-    }
-    const bodyLines = [...before, ...after];
-    while (bodyLines.at(0)?.trim() === "")
-        bodyLines.shift();
-    while (bodyLines.at(-1)?.trim() === "")
-        bodyLines.pop();
-    return bodyLines.length > 0
-        ? `${protocolLine}\n\n${bodyLines.join("\n")}`
-        : protocolLine;
-}
-function normalizeProtocolLine(line) {
-    const trimmed = line.trim();
-    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
-    return (emphasized?.[2] ?? trimmed).trim();
-}

package/dist/executors/pi-sdk-executor.js

@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { classifyPiFailure, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, extractTokenUsageFromPiJson, } from './pi-executor.js';
+import { classifyPiFailure, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
 import { serializeSessionEvent } from './pi-event-serializer.js';
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
@@ -202,6 +202,63 @@ async function resolveSdkSessionFactory(reuseScope) {
         return createSdkSession(sdk, input, shared);
     };
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readUsageNumber(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+            return Math.trunc(value);
+        }
+    }
+    return undefined;
+}
+function extractSdkUsageSample(event) {
+    const message = isRecord(event.message) ? event.message : undefined;
+    const usageCandidates = [event.usage, message?.usage, event.tokenUsage];
+    let tokens;
+    for (const candidate of usageCandidates) {
+        if (!isRecord(candidate))
+            continue;
+        const input = readUsageNumber(candidate, ['input_tokens', 'inputTokens', 'prompt_tokens', 'promptTokens']);
+        const output = readUsageNumber(candidate, ['output_tokens', 'outputTokens', 'completion_tokens', 'completionTokens']);
+        const total = readUsageNumber(candidate, ['total_tokens', 'totalTokens']);
+        if (input !== undefined && output !== undefined) {
+            tokens = input + output;
+            break;
+        }
+        if (total !== undefined) {
+            tokens = total;
+            break;
+        }
+    }
+    if (tokens === undefined)
+        return undefined;
+    const responseKeyCandidates = [
+        event.responseId,
+        event.messageId,
+        message?.responseId,
+        message?.id,
+    ];
+    const responseKey = responseKeyCandidates.find((value) => typeof value === 'string' && value.length > 0);
+    return responseKey ? { responseKey, tokens } : { tokens };
+}
+function aggregateSdkTokenUsage(samples) {
+    const identified = new Map();
+    let anonymousMaximum = 0;
+    for (const sample of samples) {
+        if (sample.responseKey) {
+            identified.set(sample.responseKey, Math.max(identified.get(sample.responseKey) ?? 0, sample.tokens));
+        }
+        else {
+            // SDK lifecycle events may repeat cumulative usage without a response id.
+            // Treat anonymous samples as snapshots for this attempt rather than increments.
+            anonymousMaximum = Math.max(anonymousMaximum, sample.tokens);
+        }
+    }
+    return anonymousMaximum + Array.from(identified.values()).reduce((sum, tokens) => sum + tokens, 0);
+}
 /**
  * Execute a single Pi step via the SDK.
  * When reuseScope is active, only shared auth/model resources are reused; each attempt still
@@ -227,6 +284,7 @@ export async function executeSingleSdkAttempt(options) {
     let timedOut = false;
     let stderr = '';
     const stdoutLines = [];
+    const usageSamples = [];
     let session;
     let timeoutHandle;
     const sessionEventAppender = options.sessionEventsPath
@@ -243,11 +301,16 @@ export async function executeSingleSdkAttempt(options) {
             thinking: modelConfig.thinking,
         });
         const unsubscribe = session.subscribe((event) => {
+            const usageSample = extractSdkUsageSample(event);
+            if (usageSample)
+                usageSamples.push(usageSample);
             if (!shouldPersistSessionEvent(event))
                 return;
             const line = serializeSessionEvent(event);
             stdoutLines.push(line);
-            sessionEventAppender?.append(line, event);
+            if (sessionEventAppender) {
+                sessionEventAppender.append(line, event);
+            }
         });
         const filePrefix = options.attachedFiles.map((file) => `@${file}`).join(' ');
         const promptMessage = filePrefix
@@ -305,7 +368,7 @@ export async function executeSingleSdkAttempt(options) {
     const stdout = stdoutLines.join('\n');
     const durationMs = Date.now() - startedAt;
     const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
-    const tokensUsed = extractTokenUsageFromPiJson(stdout);
+    const tokensUsed = aggregateSdkTokenUsage(usageSamples);
     const failureCategory = classifyPiFailure({
         assistantText,
         exitCode: timedOut ? 1 : stderr ? 1 : 0,

package/dist/executors/shell-executor.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-store.js";
 import { truncateOutput } from "../shared/output-truncation.js";
@@ -11,7 +12,9 @@ import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout,
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { materializeBackendTestResultFromRunDir } from "../workflows/dag/backend-test-result-contract.js";
-import { pathsChangedDuringRun, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { buildBackendTestEffectiveResultSelectorShellSnippet, buildBackendTestRepairEligibilityShellSnippet, buildBackendTestRepairSafetyShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-repair-contract.js";
+import { materializeBackendTestSemanticReview } from "../workflows/dag/backend-test-semantic-review-contract.js";
+import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
 const SUMMARY_STDOUT_MAX = 4_000;
@@ -63,32 +66,6 @@ export function resolveShellCommands(shell) {
         ...fromRequirementCoverageGate,
     ];
 }
-async function readGitStatusPorcelain(cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
-            cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf-8");
-        child.stderr.setEncoding("utf-8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code === 0) {
-                resolve(stdout);
-                return;
-            }
-            reject(new Error(`git status failed: ${stderr.trim() || stdout.trim()}`));
-        });
-    });
-}
 export async function executeShellCommand(input) {
     return new Promise((resolve) => {
         const startedAt = Date.now();
@@ -98,7 +75,7 @@ export async function executeShellCommand(input) {
                 HARNESS_DAG_RUN_ID: input.dagRunMeta.runId,
             }
             : undefined;
-        const child = spawn(resolveBashExecutable(), ["-lc", input.command], {
+        const child = spawn(resolveBashExecutable(), ["-c", input.command], {
             cwd: input.cwd,
             env: buildShellProcessEnv(input.envAllowlist, injectedEnv),
             stdio: ["ignore", "pipe", "pipe"],
@@ -297,8 +274,194 @@ async function runShellWriteGuard(input) {
         forbiddenPaths: input.task.forbiddenPaths,
     });
 }
+async function executeBackendTestPipeline(input, meta) {
+    const pipeline = input.task.shell?.backendTestPipeline;
+    const started = Date.now();
+    try {
+        if (!pipeline)
+            throw new Error("missing backend-test pipeline id");
+        const outputs = [];
+        if (pipeline === "contracts") {
+            const wrapperPath = path.join(meta.runDir, "analyze-and-discover-backend-test-pi.json");
+            const wrapper = JSON.parse(await readFile(wrapperPath, "utf8"));
+            const raw = wrapper.assistantText?.trim() || wrapper.stdout?.trim() || "";
+            const fenced = raw.match(/^```json\s*([\s\S]*?)\s*```$/i);
+            const envelope = JSON.parse(fenced ? fenced[1] : raw);
+            if (!envelope.analysis || !envelope.execution)
+                throw new Error("backend-test contract envelope requires analysis and execution");
+            await writeFile(path.join(meta.runDir, "backend-test-analysis-envelope.json"), JSON.stringify({ assistantText: JSON.stringify(envelope.analysis) }));
+            await writeFile(path.join(meta.runDir, "backend-test-execution-envelope.json"), JSON.stringify({ assistantText: JSON.stringify(envelope.execution) }));
+            const analysis = await materializeBackendTestAnalysisContract({
+                runDir: meta.runDir,
+                fromNodeId: "backend-test-analysis-envelope",
+                artifactName: "backend-test-analysis.json",
+                outputDir: "contracts",
+                sourceBinding: meta.spec.sourceBinding,
+            });
+            const execution = await materializeBackendTestExecutionContract({
+                runDir: meta.runDir,
+                fromNodeId: "backend-test-execution-envelope",
+                artifactName: "backend-test-execution.json",
+                outputDir: "contracts",
+            });
+            outputs.push(`analysis=${analysis.path}`, `execution=${execution.path}`);
+        }
+        else if (pipeline === "semantic-initial" || pipeline === "semantic-final") {
+            const fromNodeId = pipeline === "semantic-final"
+                ? "review-generated-backend-pytest-final-pi"
+                : "review-generated-backend-pytest-pi";
+            const artifactName = pipeline === "semantic-final"
+                ? "backend-test-semantic-review-final.json"
+                : "backend-test-semantic-review.json";
+            const review = await materializeBackendTestSemanticReview({
+                runDir: meta.runDir,
+                fromNodeId,
+                artifactName,
+                outputDir: "contracts",
+            });
+            const trace = await runBackendTestTraceabilityGate({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+            });
+            outputs.push(`semantic=${review.path}`, formatTraceabilityGateStdout(trace));
+            const parsed = JSON.parse(await readFile(review.path, "utf8"));
+            if (pipeline === "semantic-initial") {
+                return { ok: true, stdout: JSON.stringify(parsed), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
+            }
+            if (pipeline === "semantic-final") {
+                if (parsed.verdict !== "pass")
+                    throw new Error("backend pytest semantic review did not pass");
+            }
+        }
+        else if (pipeline === "execute-parse-initial") {
+            const results = await executePipelineCommands(input, meta);
+            if (!results.every((result) => result.ok)) {
+                const failure = results.find((result) => !result.ok);
+                return { ok: false, stdout: results.map((result) => result.stdout).join("\n"), stderr: failure.stderr, failureCategory: failure.failureCategory, durationMs: Date.now() - started };
+            }
+            const artifact = await materializeBackendTestResultFromRunDir({
+                runDir: meta.runDir,
+                fromNodeId: input.task.id,
+                artifactName: "backend-test-result-initial.json",
+                outputDir: "contracts",
+                junitRelativePath: "reports/backend-test-initial-junit.xml",
+            });
+            outputs.push(...results.map((result) => result.stdout), `result=${artifact.path}`);
+        }
+        else if (pipeline === "classification-eligibility") {
+            const classification = await materializeBackendTestClassification({
+                runDir: meta.runDir,
+                fromNodeId: "classify-backend-test-result-pi",
+                artifactName: "backend-test-classification.json",
+                outputDir: "contracts",
+            });
+            const results = await executePipelineCommands(input, meta, [buildBackendTestRepairEligibilityShellSnippet()]);
+            if (!results.every((result) => result.ok))
+                throw new Error(results.find((result) => !result.ok)?.stderr || "repair eligibility failed");
+            const eligibility = JSON.parse(await readFile(path.join(meta.runDir, "contracts", "backend-test-repair-eligibility.json"), "utf8"));
+            return { ok: true, stdout: JSON.stringify(eligibility), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
+        }
+        else if (pipeline === "repair-safety-traceability") {
+            const results = await executePipelineCommands(input, meta, [buildBackendTestRepairSafetyShellSnippet()]);
+            if (!results.every((result) => result.ok))
+                throw new Error(results.find((result) => !result.ok)?.stderr || "repair safety failed");
+            const trace = await runBackendTestTraceabilityGate({ runDir: meta.runDir, workspaceRoot: input.cwd });
+            outputs.push(...results.map((result) => result.stdout), formatTraceabilityGateStdout(trace));
+        }
+        else if (pipeline === "finalize-effective-result") {
+            const eligibilityPath = path.join(meta.runDir, "contracts", "backend-test-repair-eligibility.json");
+            const eligibility = existsSync(eligibilityPath)
+                ? JSON.parse(await readFile(eligibilityPath, "utf8"))
+                : { eligible: false };
+            const finalNeeded = eligibility.eligible === true;
+            if (finalNeeded) {
+                const results = await executePipelineCommands(input, meta);
+                if (!results.every((result) => result.ok))
+                    return { ok: false, stdout: results.map((result) => result.stdout).join("\n"), stderr: results.find((result) => !result.ok)?.stderr ?? "final pytest failed", failureCategory: results.find((result) => !result.ok)?.failureCategory ?? "nonzero-exit", durationMs: Date.now() - started };
+                const artifact = await materializeBackendTestResultFromRunDir({ runDir: meta.runDir, fromNodeId: input.task.id, artifactName: "backend-test-result-final.json", outputDir: "contracts", junitRelativePath: "reports/backend-test-final-junit.xml" });
+                outputs.push(...results.map((result) => result.stdout), `final=${artifact.path}`);
+            }
+            const selected = await executePipelineCommands(input, meta, [buildBackendTestEffectiveResultSelectorShellSnippet()]);
+            if (!selected.every((result) => result.ok))
+                throw new Error(selected.find((result) => !result.ok)?.stderr || "effective result selection failed");
+            outputs.push(...selected.map((result) => result.stdout));
+        }
+        else {
+            throw new Error(`unsupported backend-test pipeline: ${pipeline}`);
+        }
+        return { ok: true, stdout: outputs.filter(Boolean).join("\n"), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
+    }
+    catch (error) {
+        return { ok: false, stdout: "", stderr: error instanceof Error ? error.message : String(error), failureCategory: "invalid-output", durationMs: Date.now() - started };
+    }
+}
+async function executeBackendTestPipelineWithWriteGuard(input, meta) {
+    let beforeStatus;
+    try {
+        beforeStatus = await readGitStatusPorcelain(input.cwd);
+    }
+    catch {
+        // Non-git cwd: keep the same documented limitation as normal shell nodes.
+        beforeStatus = undefined;
+    }
+    const result = await executeBackendTestPipeline(input, meta);
+    if (beforeStatus === undefined)
+        return result;
+    try {
+        const guard = await runShellWriteGuard({
+            rootCwd: input.cwd,
+            task: input.task,
+            beforeStatus,
+        });
+        if (guard.ok)
+            return result;
+        const detail = `write guard failed: ${guard.violations.join(", ")}`;
+        return {
+            ...result,
+            ok: false,
+            stderr: [result.stderr, detail].filter(Boolean).join("\n\n"),
+            failureCategory: "write-guard",
+        };
+    }
+    catch (error) {
+        const detail = `write guard failed: git status unavailable: ${error instanceof Error ? error.message : String(error)}`;
+        return {
+            ...result,
+            ok: false,
+            stderr: [result.stderr, detail].filter(Boolean).join("\n\n"),
+            failureCategory: "write-guard",
+        };
+    }
+}
+async function executePipelineCommands(input, meta, overrideCommands) {
+    const shell = input.task.shell;
+    const cwd = resolveShellCwd(input.cwd, shell.cwd);
+    const commands = overrideCommands ?? shell.commands;
+    const results = [];
+    for (const command of commands) {
+        const commandNumber = results.length + 1;
+        const result = await executeShellCommand({
+            command,
+            cwd,
+            timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+            envAllowlist: shell.envAllowlist,
+            dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+            outputArtifacts: {
+                stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+            },
+        });
+        results.push(result);
+        if (!result.ok)
+            break;
+    }
+    return results;
+}
 export async function executeDagShellNode(input, meta) {
     const shell = input.task.shell;
+    if (shell?.backendTestPipeline) {
+        return executeBackendTestPipelineWithWriteGuard(input, meta);
+    }
     if (shell?.jsonArtifactGate) {
         const started = Date.now();
         try {
@@ -306,6 +469,7 @@ export async function executeDagShellNode(input, meta) {
             let artifact;
             switch (gate.schemaId) {
                 case "backend-test-analysis-v1":
+                case "backend-test-analysis-v2":
                     artifact = await materializeBackendTestAnalysisContract({
                         runDir: meta.runDir,
                         fromNodeId: gate.fromNodeId,
@@ -328,6 +492,23 @@ export async function executeDagShellNode(input, meta) {
                         fromNodeId: gate.fromNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
+                        junitRelativePath: gate.junitRelativePath,
+                    });
+                    break;
+                case "backend-test-classification-v1":
+                    artifact = await materializeBackendTestClassification({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                    });
+                    break;
+                case "backend-test-semantic-review-v1":
+                    artifact = await materializeBackendTestSemanticReview({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
                     });
                     break;
                 case "backend-test-case-manifest-v1":
@@ -520,9 +701,11 @@ export async function executeDagShellNode(input, meta) {
             writeGuardOk = guard.ok;
             writeGuardViolations = guard.violations;
         }
-        catch {
+        catch (error) {
             writeGuardOk = false;
-            writeGuardViolations = ["write guard failed: git status unavailable"];
+            writeGuardViolations = [
+                `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            ];
         }
     }
     const commandsOk = results.every((result) => result.ok);

package/dist/executors/shell-presets.js

@@ -31,10 +31,20 @@ function verdictGateNodeParser(lineMode) {
  */
 export function buildVerdictGateShellCommand(gate) {
     const gateLabel = gate.label ?? `${gate.fromNodeId} verdict`;
-    const jsonFile = `${gate.fromNodeId}.json`;
     const lineMode = gate.lineMode ?? "first-non-empty";
     const parser = verdictGateNodeParser(lineMode);
-    const preamble = `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${gateLabel} gate" >&2; exit 1; }; FILE="\${HARNESS_DAG_RUN_DIR}/${jsonFile}"; test -f "\${FILE}" || { echo "missing ${gateLabel} JSON output: \${FILE}" >&2; exit 1; }; FIRST=$(${parser})`;
+    const candidateNodeIds = [
+        gate.fromNodeId,
+        ...(gate.fallbackFromNodeIds ?? []).filter((id) => id !== gate.fromNodeId),
+    ];
+    const resolveFile = candidateNodeIds.length === 1
+        ? `FILE="\${HARNESS_DAG_RUN_DIR}/${candidateNodeIds[0]}.json"; test -f "\${FILE}" || { echo "missing ${gateLabel} JSON output: \${FILE}" >&2; exit 1; }`
+        : [
+            "FILE=\"\"",
+            ...candidateNodeIds.map((id) => `if test -z "\${FILE}" && test -f "\${HARNESS_DAG_RUN_DIR}/${id}.json"; then FILE="\${HARNESS_DAG_RUN_DIR}/${id}.json"; fi`),
+            `test -n "\${FILE}" || { echo "missing ${gateLabel} JSON output (tried: ${candidateNodeIds.join(", ")})" >&2; exit 1; }`,
+        ].join("; ");
+    const preamble = `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${gateLabel} gate" >&2; exit 1; }; ${resolveFile}; FIRST=$(${parser})`;
     const blockedMessage = `${gateLabel} gate blocked: \${FIRST:-missing VERDICT line}`;
     if (gate.accept.length === 1) {
         const expected = escapeShellSingleQuoted(gate.accept[0]);

package/dist/executors/shell-write-guard.js

@@ -67,7 +67,26 @@ export function validateShellWriteGuard(input) {
     }
     return { ok: violations.length === 0, violations };
 }
-export async function readGitStatusPorcelain(cwd) {
+export async function readGitStatusPorcelain(cwd, options = {}) {
+    const attempts = Math.max(1, options.attempts ?? 3);
+    const retryDelayMs = Math.max(0, options.retryDelayMs ?? 100);
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return await readGitStatusPorcelainOnce(cwd);
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < attempts && retryDelayMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs * attempt));
+            }
+        }
+    }
+    throw lastError instanceof Error
+        ? lastError
+        : new Error(`git status failed after ${attempts} attempts`);
+}
+function readGitStatusPorcelainOnce(cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
             cwd,