@tea-agent/loop-agent 0.16.26 → 0.17.0

package/dist/executors/pi-executor.js

@@ -50,6 +50,10 @@ export function extractSubagentStats(stdout) {
 export const DEFAULT_TIMEOUT_MS = 1_800_000;
 export const MAX_ALLOWED_TIMEOUT_MS = 1_800_000;
 const PI_BACKEND_ENV = 'CODE_AGENT_PI_BACKEND';
+const OUTPUT_PREVIEW_HEAD_CHARS = 64_000;
+const OUTPUT_PREVIEW_TAIL_CHARS = 64_000;
+const MAX_STREAM_JSONL_LINE_CHARS = 16_000_000;
+const MAX_ASSISTANT_TEXT_CHARS = 16_000_000;
 const PI_CLI_PACKAGE_NAMES = [
     '@earendil-works/pi-coding-agent',
     '@mariozechner/pi-coding-agent',
@@ -186,6 +190,10 @@ function resolvePiCliPath() {
         path.join(nvmBase, nodeVersion, 'lib', 'node_modules'),
     ].flatMap((nodeModulesRoot) => PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot(nodeModulesRoot, packageName)));
     const otherCandidates = [
+        // Prefer the project-local Pi dependency. `npm run` adds node_modules/.bin
+        // to PATH, but direct invocations from the DAG runner may not, so resolve
+        // the package from the current workspace explicitly.
+        ...PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot(path.resolve(process.cwd(), 'node_modules'), packageName)),
         // Global npm installation (non-nvm)
         ...PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot('/usr/local/lib/node_modules', packageName)),
         // Bun installation
@@ -327,8 +335,167 @@ function extractAssistantTextFromMessage(message) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+export class BoundedTextPreview {
+    label;
+    headMax;
+    tailMax;
+    parts = [];
+    head = '';
+    tail = '';
+    bufferedChars = 0;
+    totalChars = 0;
+    truncated = false;
+    constructor(label, headMax = OUTPUT_PREVIEW_HEAD_CHARS, tailMax = OUTPUT_PREVIEW_TAIL_CHARS) {
+        this.label = label;
+        this.headMax = headMax;
+        this.tailMax = tailMax;
+    }
+    append(chunk) {
+        if (!chunk)
+            return;
+        this.totalChars += chunk.length;
+        if (!this.truncated) {
+            if (this.bufferedChars + chunk.length <= this.headMax + this.tailMax) {
+                this.parts.push(chunk);
+                this.bufferedChars += chunk.length;
+                return;
+            }
+            const combined = this.parts.join('') + chunk;
+            this.head = combined.slice(0, this.headMax);
+            this.tail = combined.slice(-this.tailMax);
+            this.parts = [];
+            this.bufferedChars = 0;
+            this.truncated = true;
+            return;
+        }
+        this.tail = (this.tail + chunk).slice(-this.tailMax);
+    }
+    text() {
+        if (!this.truncated)
+            return this.parts.join('');
+        const omitted = Math.max(0, this.totalChars - this.head.length - this.tail.length);
+        return [
+            this.head,
+            `[${this.label} truncated: omitted ${omitted} chars; kept first ${this.head.length} and last ${this.tail.length}]`,
+            this.tail,
+        ].join('\n');
+    }
+}
+export class PiJsonlStreamCollector {
+    lineBuffer = '';
+    discardUntilNewline = false;
+    assistantText = '';
+    parsedEvents = 0;
+    tokensUsed = 0;
+    outputTooLarge = false;
+    subagentTotalCalls = 0;
+    subagentFailedCalls = 0;
+    subagentModes = new Set();
+    subagentAgents = new Set();
+    append(chunk) {
+        if (!chunk)
+            return;
+        const lines = chunk.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const part = lines[index] ?? '';
+            const isLast = index === lines.length - 1;
+            if (this.discardUntilNewline) {
+                if (!isLast)
+                    this.discardUntilNewline = false;
+                continue;
+            }
+            if (this.lineBuffer.length + part.length > MAX_STREAM_JSONL_LINE_CHARS) {
+                this.outputTooLarge = true;
+                this.lineBuffer = '';
+                if (isLast)
+                    this.discardUntilNewline = true;
+                continue;
+            }
+            this.lineBuffer += part;
+            if (!isLast) {
+                this.consumeLine(this.lineBuffer);
+                this.lineBuffer = '';
+            }
+        }
+    }
+    finish() {
+        if (!this.discardUntilNewline && this.lineBuffer.trim()) {
+            this.consumeLine(this.lineBuffer);
+        }
+        this.lineBuffer = '';
+        return {
+            assistantText: this.assistantText.trim(),
+            outputTooLarge: this.outputTooLarge,
+            parsedEvents: this.parsedEvents,
+            subagentStats: this.formatSubagentStats(),
+            tokensUsed: this.tokensUsed,
+        };
+    }
+    consumeLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            const event = JSON.parse(trimmed);
+            this.parsedEvents += 1;
+            this.consumeEvent(event);
+        }
+        catch {
+            // tolerate non-json noise
+        }
+    }
+    consumeEvent(event) {
+        const candidate = extractAssistantTextFromEvent(event);
+        if (candidate) {
+            if (candidate.length > MAX_ASSISTANT_TEXT_CHARS) {
+                this.outputTooLarge = true;
+                this.assistantText = candidate.slice(0, MAX_ASSISTANT_TEXT_CHARS);
+            }
+            else {
+                this.assistantText = candidate;
+            }
+        }
+        const usage = extractUsageFromEvent(event);
+        if (usage !== null)
+            this.tokensUsed += usage;
+        if (event.type === 'tool_execution_start' && event.toolName === 'subagent') {
+            this.subagentTotalCalls += 1;
+            if (isRecord(event.input)) {
+                if (event.input.agent)
+                    this.subagentAgents.add(String(event.input.agent));
+                if (event.input.tasks)
+                    this.subagentModes.add('parallel');
+                if (event.input.chain)
+                    this.subagentModes.add('chain');
+                if (event.input.agent && !event.input.tasks && !event.input.chain) {
+                    this.subagentModes.add('single');
+                }
+            }
+        }
+        if (event.type === 'tool_execution_end' && event.toolName === 'subagent') {
+            if (event.isError === true)
+                this.subagentFailedCalls += 1;
+        }
+    }
+    formatSubagentStats() {
+        if (this.subagentTotalCalls === 0)
+            return 'calls=0';
+        const parts = [`calls=${this.subagentTotalCalls}`];
+        if (this.subagentFailedCalls > 0)
+            parts.push(`${this.subagentFailedCalls} failed`);
+        if (this.subagentModes.size > 0)
+            parts.push(Array.from(this.subagentModes).sort().join('+'));
+        if (this.subagentAgents.size > 0) {
+            parts.push(`agents=[${Array.from(this.subagentAgents).sort().join(',')}]`);
+        }
+        return parts.join(' | ');
+    }
+}
+export function createPiJsonlStreamCollector() {
+    return new PiJsonlStreamCollector();
+}
 function withSubagentStats(result) {
-    return { ...result, subagentStats: extractSubagentStats(result.stdout) };
+    return { ...result, subagentStats: result.subagentStats ?? extractSubagentStats(result.stdout) };
 }
 function withCliBackend(result) {
     return { ...result, backend: 'cli' };
@@ -354,7 +521,10 @@ async function runCliOrchestration(options, meta) {
         const fallbackResult = await executeSingleCliAttempt(options, primary.fallback);
         attemptedModels.push(fallbackResult.modelDisplay);
         const combinedStderr = [primaryResult.stderr, fallbackResult.stderr].filter(Boolean).join('\n--- fallback ---\n');
-        const combinedStdout = [primaryResult.stdout, fallbackResult.stdout].filter(Boolean).join('\n');
+        const combinedStdout = [primaryResult.stdout, fallbackResult.stdout].filter(Boolean).join('\n--- fallback ---\n');
+        const combinedStdoutTruncated = primaryResult.stdoutTruncated || fallbackResult.stdoutTruncated;
+        const combinedStderrTruncated = primaryResult.stderrTruncated || fallbackResult.stderrTruncated;
+        const combinedOutputTooLarge = primaryResult.outputTooLarge || fallbackResult.outputTooLarge;
         let fallbackIssues = [];
         if (fallbackResult.ok && options.validateOutput) {
             fallbackIssues = options.validateOutput(fallbackResult.assistantText);
@@ -367,6 +537,9 @@ async function runCliOrchestration(options, meta) {
                 sdkAttempted: meta?.sdkAttempted,
                 stderr: combinedStderr,
                 stdout: combinedStdout,
+                stdoutTruncated: combinedStdoutTruncated,
+                stderrTruncated: combinedStderrTruncated,
+                outputTooLarge: combinedOutputTooLarge,
             }));
         }
         if (fallbackResult.ok && fallbackIssues.length > 0) {
@@ -379,6 +552,9 @@ async function runCliOrchestration(options, meta) {
                 sdkAttempted: meta?.sdkAttempted,
                 stderr: combinedStderr + `\n[invalid-output] ${fallbackIssues.join('; ')}`,
                 stdout: combinedStdout,
+                stdoutTruncated: combinedStdoutTruncated,
+                stderrTruncated: combinedStderrTruncated,
+                outputTooLarge: combinedOutputTooLarge,
             }));
         }
         return withSubagentStats(withCliBackend({
@@ -388,6 +564,9 @@ async function runCliOrchestration(options, meta) {
             sdkAttempted: meta?.sdkAttempted,
             stderr: combinedStderr,
             stdout: combinedStdout,
+            stdoutTruncated: combinedStdoutTruncated,
+            stderrTruncated: combinedStderrTruncated,
+            outputTooLarge: combinedOutputTooLarge,
         }));
     }
     if (primaryInvalidOutput) {
@@ -516,12 +695,18 @@ async function executeSingleCliAttempt(options, modelConfig) {
             },
             stdio: ['ignore', 'pipe', 'pipe'],
         });
-        let stdout = '';
-        let stderr = '';
+        const stdoutPreview = new BoundedTextPreview('stdout');
+        const stderrPreview = new BoundedTextPreview('stderr', 16_000, 16_000);
+        const stdoutCollector = new PiJsonlStreamCollector();
         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.stdout.on('data', (chunk) => {
+            stdoutPreview.append(chunk);
+            stdoutCollector.append(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrPreview.append(chunk);
+        });
         child.on('error', (err) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
@@ -535,28 +720,34 @@ async function executeSingleCliAttempt(options, modelConfig) {
             if (sigkillHandle)
                 clearTimeout(sigkillHandle);
             const durationMs = Date.now() - startedAt;
-            const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
-            const tokensUsed = extractTokenUsageFromPiJson(stdout);
+            const stdout = stdoutPreview.text();
+            const stderr = stderrPreview.text();
+            const collected = stdoutCollector.finish();
             const failureCategory = classifyPiFailure({
-                assistantText,
+                assistantText: collected.assistantText,
                 exitCode: code,
                 stderr,
                 stdout,
                 timedOut,
+                outputTooLarge: collected.outputTooLarge,
             });
             resolve({
-                assistantText,
+                assistantText: collected.assistantText,
                 command: ['pi', ...piArgs],
                 durationMs,
                 exitCode: code,
                 failureCategory,
                 modelDisplay,
-                ok: code === 0 && assistantText.length > 0,
-                parsedEvents,
+                ok: code === 0 && collected.assistantText.length > 0 && !collected.outputTooLarge,
+                parsedEvents: collected.parsedEvents,
                 stderr,
                 stdout,
+                stdoutTruncated: stdoutPreview.truncated,
+                stderrTruncated: stderrPreview.truncated,
+                outputTooLarge: collected.outputTooLarge,
                 timedOut,
-                tokensUsed,
+                tokensUsed: collected.tokensUsed,
+                subagentStats: collected.subagentStats,
             });
         });
         if (timeoutMs > 0) {
@@ -585,6 +776,8 @@ export function shouldRetryWithFallback(stderr, stdout) {
 export function classifyPiFailure(input) {
     if (input.timedOut)
         return 'timeout';
+    if (input.outputTooLarge)
+        return 'output-too-large';
     if (input.exitCode === 0 && input.assistantText.trim())
         return 'success';
     const combined = `${input.stderr}\n${input.stdout}`.toLowerCase();

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, } from './pi-executor.js';
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
 import { serializeSessionEvent } from './pi-event-serializer.js';
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
@@ -283,7 +283,8 @@ export async function executeSingleSdkAttempt(options) {
     const startedAt = Date.now();
     let timedOut = false;
     let stderr = '';
-    const stdoutLines = [];
+    const stdoutPreview = new BoundedTextPreview('stdout');
+    const stdoutCollector = createPiJsonlStreamCollector();
     const usageSamples = [];
     let session;
     let timeoutHandle;
@@ -307,7 +308,8 @@ export async function executeSingleSdkAttempt(options) {
             if (!shouldPersistSessionEvent(event))
                 return;
             const line = serializeSessionEvent(event);
-            stdoutLines.push(line);
+            stdoutPreview.append(`${line}\n`);
+            stdoutCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
         const filePrefix = options.attachedFiles.map((file) => `@${file}`).join(' ');
@@ -363,13 +365,23 @@ export async function executeSingleSdkAttempt(options) {
             }
         }
     }
-    const stdout = stdoutLines.join('\n');
+    const stdout = stdoutPreview.text();
     const durationMs = Date.now() - startedAt;
-    const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
+    const collected = stdoutCollector.finish();
+    const fallbackParsed = collected.parsedEvents > 0
+        ? undefined
+        : extractAssistantTextFromPiJson(stdout);
+    const assistantText = collected.parsedEvents > 0
+        ? collected.assistantText
+        : fallbackParsed?.assistantText ?? '';
+    const parsedEvents = collected.parsedEvents > 0
+        ? collected.parsedEvents
+        : fallbackParsed?.parsedEvents ?? 0;
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
     const failureCategory = classifyPiFailure({
         assistantText,
         exitCode: timedOut ? 1 : stderr ? 1 : 0,
+        outputTooLarge: collected.outputTooLarge,
         stderr,
         stdout,
         timedOut,
@@ -382,11 +394,14 @@ export async function executeSingleSdkAttempt(options) {
         exitCode: timedOut || stderr ? 1 : 0,
         failureCategory,
         modelDisplay,
-        ok: !timedOut && !stderr && assistantText.length > 0,
+        ok: !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
         parsedEvents,
         stderr,
         stdout,
+        stdoutTruncated: stdoutPreview.truncated,
+        outputTooLarge: collected.outputTooLarge,
         timedOut,
         tokensUsed,
+        subagentStats: collected.subagentStats,
     };
 }

package/dist/executors/shell-executor.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, stat, 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";
@@ -54,6 +54,28 @@ export function resolveShellCwd(root, requestedCwd) {
     }
     return resolved;
 }
+async function resolveJsonArtifactSourceNodeId(input) {
+    const candidates = [
+        input.fromNodeId,
+        ...new Set((input.fallbackFromNodeIds ?? []).filter((nodeId) => nodeId !== input.fromNodeId)),
+    ];
+    for (const nodeId of candidates) {
+        try {
+            await stat(path.join(input.runDir, `${nodeId}.json`));
+            return nodeId;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`missing jsonArtifactGate node output (tried: ${candidates.join(", ")})`);
+}
 /** Preset commands first, then explicit shell.commands, then verdictGate (deterministic ordering). */
 export function resolveShellCommands(shell) {
     const fromPreset = shell.preset ? expandShellPreset(shell.preset) : [];
@@ -421,12 +443,30 @@ async function executeBackendTestPipeline(input, meta) {
             const selected = await executePipelineCommands(input, meta, [buildBackendTestCanonicalResultFromInitialShellSnippet()]);
             if (!selected.every((result) => result.ok))
                 throw new Error(selected.find((result) => !result.ok)?.stderr || "canonical result materialization failed");
+            const readNodeOutput = async (nodeId) => {
+                const record = JSON.parse(await readFile(path.join(meta.runDir, `${nodeId}.json`), "utf8"));
+                const text = record.assistantText?.trim() || record.stdout?.trim() || "";
+                if (!text)
+                    throw new Error(`missing auditable node output: ${nodeId}`);
+                return text;
+            };
+            const caseReview = await readNodeOutput("review-backend-cases-pi");
+            const reviewVerdicts = caseReview.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("VERDICT:"));
+            if (reviewVerdicts.length !== 1 || !["VERDICT: pass", "VERDICT: request-revision"].includes(reviewVerdicts[0])) {
+                throw new Error("invalid advisory case review evidence: expected exactly one auditable VERDICT line");
+            }
+            const traceability = await readNodeOutput("backend-test-traceability-gate-shell");
+            if (!traceability.includes("Traceability gate: pass") || !/Matched symbols:\s*\d+/.test(traceability)) {
+                throw new Error("invalid traceability evidence: deterministic pass summary is missing");
+            }
             const contracts = path.join(meta.runDir, "contracts");
             const context = {
                 schemaVersion: 1,
                 result: JSON.parse(await readFile(path.join(contracts, "backend-test-result.json"), "utf8")),
                 manifest: JSON.parse(await readFile(path.join(contracts, "backend-test-case-manifest.json"), "utf8")),
                 classification: JSON.parse(await readFile(path.join(contracts, "backend-test-classification.json"), "utf8")),
+                caseReview: { verdict: reviewVerdicts[0].slice("VERDICT: ".length), evidence: caseReview },
+                traceability: { status: "pass", evidence: traceability },
             };
             outputs.push(`classification=${classification.path}`, ...selected.map((result) => result.stdout), JSON.stringify(context, null, 2));
         }
@@ -510,13 +550,20 @@ export async function executeDagShellNode(input, meta) {
         const started = Date.now();
         try {
             const gate = shell.jsonArtifactGate;
+            const sourceNodeId = gate.fallbackFromNodeIds?.length
+                ? await resolveJsonArtifactSourceNodeId({
+                    runDir: meta.runDir,
+                    fromNodeId: gate.fromNodeId,
+                    fallbackFromNodeIds: gate.fallbackFromNodeIds,
+                })
+                : gate.fromNodeId;
             let artifact;
             switch (gate.schemaId) {
                 case "backend-test-analysis-v1":
                 case "backend-test-analysis-v2":
                     artifact = await materializeBackendTestAnalysisContract({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                         sourceBinding: meta.spec.sourceBinding,
@@ -525,7 +572,7 @@ export async function executeDagShellNode(input, meta) {
                 case "backend-test-execution-v1":
                     artifact = await materializeBackendTestExecutionContract({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                     });
@@ -533,7 +580,7 @@ export async function executeDagShellNode(input, meta) {
                 case "backend-test-result-v1":
                     artifact = await materializeBackendTestResultFromRunDir({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                         junitRelativePath: gate.junitRelativePath,
@@ -542,7 +589,7 @@ export async function executeDagShellNode(input, meta) {
                 case "backend-test-classification-v1":
                     artifact = await materializeBackendTestClassification({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                     });
@@ -550,7 +597,7 @@ export async function executeDagShellNode(input, meta) {
                 case "backend-test-semantic-review-v1":
                     artifact = await materializeBackendTestSemanticReview({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                     });
@@ -558,7 +605,7 @@ export async function executeDagShellNode(input, meta) {
                 case "backend-test-case-manifest-v1":
                     artifact = await materializeBackendTestCaseManifest({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                         sourceBinding: meta.spec.sourceBinding,
@@ -567,7 +614,7 @@ export async function executeDagShellNode(input, meta) {
                 case "frontend-implementation-contract-v1":
                     artifact = await materializeFrontendImplementationContract({
                         runDir: meta.runDir,
-                        fromNodeId: gate.fromNodeId,
+                        fromNodeId: sourceNodeId,
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                         sourceBinding: meta.spec.sourceBinding,

package/dist/executors/shell-presets.js

@@ -60,12 +60,25 @@ export function buildVerdictGateShellCommand(gate) {
 export function buildRequirementCoverageGateShellCommand(gate) {
     const label = gate.label ?? "requirement coverage";
     const requiredJson = escapeShellSingleQuoted(JSON.stringify(gate.requiredIds.map((id) => id.toUpperCase())));
-    const fileArgs = gate.fromNodeIds.map((nodeId) => `"\${HARNESS_DAG_RUN_DIR}/${nodeId}.json"`).join(" ");
+    const sourceConfig = {
+        primary: gate.fromNodeIds,
+        fallback: [
+            ...new Set((gate.fallbackFromNodeIds ?? []).filter((nodeId) => !gate.fromNodeIds.includes(nodeId))),
+        ],
+    };
     const program = [
         'const fs=require("fs");',
+        'const path=require("path");',
         "const required=JSON.parse(process.argv[1]);",
+        `const sources=${JSON.stringify(sourceConfig)};`,
+        "let files=sources.primary.map((id)=>path.join(process.env.HARNESS_DAG_RUN_DIR,id+'.json'));",
+        "if(sources.fallback.length){",
+        " files=[]; const candidates=[sources.primary[0],...sources.fallback];",
+        " for(const id of candidates){const file=path.join(process.env.HARNESS_DAG_RUN_DIR,id+'.json'); try{fs.statSync(file);files=[file];break;}catch(error){if(error&&error.code==='ENOENT')continue;throw error;}}",
+        ` if(!files.length){console.error(${JSON.stringify(`${label} gate blocked: missing node output (tried: `)}+[sources.primary[0],...sources.fallback].join(', ')+')');process.exit(1);}`,
+        "}",
         "let text='';",
-        "for(const file of process.argv.slice(2)){",
+        "for(const file of files){",
         " if(!fs.existsSync(file)){console.error('missing requirement coverage node output: '+file);process.exit(1);}",
         " const raw=JSON.parse(fs.readFileSync(file,'utf8')); text+='\\n'+String(raw.assistantText ?? raw.stdout ?? '');",
         "}",
@@ -74,5 +87,5 @@ export function buildRequirementCoverageGateShellCommand(gate) {
         `if(missing.length){console.error(${JSON.stringify(`${label} gate blocked: missing `)}+missing.join(', '));process.exit(1);}`,
         `console.log(${JSON.stringify(`${label} gate passed: `)}+required.join(', '));`,
     ].join("");
-    return `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${label} gate" >&2; exit 1; }; node -e '${escapeShellSingleQuoted(program)}' '${requiredJson}' ${fileArgs}`;
+    return `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${label} gate" >&2; exit 1; }; node -e '${escapeShellSingleQuoted(program)}' '${requiredJson}'`;
 }