@tea-agent/loop-agent 0.13.0-alpha.0 → 0.13.0

package/dist/executors/shell-executor.js

@@ -3,7 +3,14 @@ import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-store.js";
 import { truncateOutput } from "../shared/output-truncation.js";
-import { expandShellPreset, buildVerdictGateShellCommand } from "./shell-presets.js";
+import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand, } from "./shell-presets.js";
+import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
+import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
+import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
+import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout, runFrontendFailureAssessGate, runFrontendRepairContractGate, } from "../workflows/dag/frontend-repair.js";
+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 { buildShellProcessEnv } from "./shell-verification.js";
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
@@ -23,7 +30,9 @@ function resolveBashExecutable() {
         path.join(process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)", "Git", "bin", "bash.exe"),
         path.join(process.env.LocalAppData ?? "", "Programs", "Git", "bin", "bash.exe"),
     ].filter(Boolean);
-    return candidates.find((candidate) => existsSync(candidate)) ?? envCandidate ?? "bash";
+    return (candidates.find((candidate) => existsSync(candidate)) ??
+        envCandidate ??
+        "bash");
 }
 function isWithinRoot(root, candidate) {
     const relative = path.relative(root, candidate);
@@ -44,7 +53,15 @@ export function resolveShellCommands(shell) {
     const fromVerdictGate = shell.verdictGate
         ? [buildVerdictGateShellCommand(shell.verdictGate)]
         : [];
-    return [...fromPreset, ...explicit, ...fromVerdictGate];
+    const fromRequirementCoverageGate = shell.requirementCoverageGate
+        ? [buildRequirementCoverageGateShellCommand(shell.requirementCoverageGate)]
+        : [];
+    return [
+        ...fromPreset,
+        ...explicit,
+        ...fromVerdictGate,
+        ...fromRequirementCoverageGate,
+    ];
 }
 async function readGitStatusPorcelain(cwd) {
     return new Promise((resolve, reject) => {
@@ -141,13 +158,16 @@ export async function executeShellCommand(input) {
             });
         });
         child.on("close", (code) => {
+            let failureCategory = "nonzero-exit";
+            if (timedOut) {
+                failureCategory = "timeout";
+            }
+            else if (code === 0) {
+                failureCategory = "success";
+            }
             finish({
                 exitCode: code,
-                failureCategory: timedOut
-                    ? "timeout"
-                    : code === 0
-                        ? "success"
-                        : "nonzero-exit",
+                failureCategory,
                 ok: code === 0 && !timedOut,
             });
         });
@@ -279,6 +299,182 @@ async function runShellWriteGuard(input) {
 }
 export async function executeDagShellNode(input, meta) {
     const shell = input.task.shell;
+    if (shell?.jsonArtifactGate) {
+        const started = Date.now();
+        try {
+            const gate = shell.jsonArtifactGate;
+            let artifact;
+            switch (gate.schemaId) {
+                case "backend-test-analysis-v1":
+                    artifact = await materializeBackendTestAnalysisContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                case "backend-test-execution-v1":
+                    artifact = await materializeBackendTestExecutionContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                    });
+                    break;
+                case "backend-test-result-v1":
+                    artifact = await materializeBackendTestResultFromRunDir({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                    });
+                    break;
+                case "backend-test-case-manifest-v1":
+                    artifact = await materializeBackendTestCaseManifest({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                case "frontend-implementation-contract-v1":
+                    artifact = await materializeFrontendImplementationContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                default:
+                    throw new Error(`unsupported jsonArtifactGate.schemaId: ${String(gate.schemaId)}`);
+            }
+            return {
+                ok: true,
+                stdout: `Structured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+                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,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "backend-test-traceability-gate") {
+        const started = Date.now();
+        try {
+            const result = await runBackendTestTraceabilityGate({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+            });
+            return {
+                ok: true,
+                stdout: formatTraceabilityGateStdout(result),
+                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,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-verification-trace-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendVerificationTraceGate({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendVerificationTraceStdout(result),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            const stderr = error instanceof Error ? error.message : String(error);
+            const recordNonZero = shell.nonZeroExitPolicy === "record";
+            return {
+                ok: recordNonZero,
+                stdout: recordNonZero
+                    ? "nonZeroExitPolicy=record failureCategory=invalid-output\n"
+                    : "",
+                stderr,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-failure-assess-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendFailureAssessGate({
+                runDir: meta.runDir,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendFailureAssessStdout(result),
+                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,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-repair-contract-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendRepairContractGate({
+                runDir: meta.runDir,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendRepairContractStdout(result.assessment),
+                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,
+            };
+        }
+    }
     const commands = shell ? resolveShellCommands(shell) : [];
     if (!shell || commands.length === 0) {
         throw new Error(`shell task ${input.task.id} requires shell.preset, shell.verdictGate, and/or non-empty shell.commands`);
@@ -330,7 +526,8 @@ export async function executeDagShellNode(input, meta) {
         }
     }
     const commandsOk = results.every((result) => result.ok);
-    const ok = commandsOk && writeGuardOk;
+    const recordNonZero = shell.nonZeroExitPolicy === "record";
+    const ok = (commandsOk || recordNonZero) && writeGuardOk;
     const firstFailure = results.find((result) => !result.ok);
     await writeDagNodeTextArtifact(meta.runDir, input.task.id, "result.summary.md", buildShellResultSummaryMarkdown({
         nodeId: input.task.id,
@@ -344,15 +541,29 @@ export async function executeDagShellNode(input, meta) {
     if (!writeGuardOk) {
         stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
     }
+    let failureCategory = "success";
+    if (!commandsOk) {
+        failureCategory = firstFailure?.failureCategory ?? "nonzero-exit";
+    }
+    else if (!writeGuardOk) {
+        failureCategory = "write-guard";
+    }
+    const commandResults = results.map((result) => ({
+        ok: result.ok,
+        exitCode: result.exitCode,
+        failureCategory: result.failureCategory,
+        command: result.command,
+    }));
+    const recordPrefix = recordNonZero && !commandsOk
+        ? `nonZeroExitPolicy=record exitCode=${firstFailure?.exitCode ?? "null"}\n`
+        : "";
     return {
         ok,
-        stdout: aggregate.stdout,
+        stdout: `${recordPrefix}${aggregate.stdout}`,
         stderr: stderrParts.filter(Boolean).join("\n\n"),
-        failureCategory: !commandsOk
-            ? (firstFailure?.failureCategory ?? "nonzero-exit")
-            : !writeGuardOk
-                ? "write-guard"
-                : "success",
+        failureCategory,
         durationMs: Date.now() - started,
+        // extra field consumed by node-execution if supported; also embedded in stdout marker
+        ...{ commandResults },
     };
 }

package/dist/executors/shell-presets.js

@@ -45,3 +45,23 @@ export function buildVerdictGateShellCommand(gate) {
         .join("|");
     return `${preamble}; case "\${FIRST}" in ${acceptPattern}) exit 0 ;; *) echo "${blockedMessage}" >&2; exit 1 ;; esac`;
 }
+/** Build a deterministic current-run gate over exact REQ-/BR-/AC- ids in node facts. */
+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 program = [
+        'const fs=require("fs");',
+        "const required=JSON.parse(process.argv[1]);",
+        "let text='';",
+        "for(const file of process.argv.slice(2)){",
+        " 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 ?? '');",
+        "}",
+        "const found=new Set((text.toUpperCase().match(/\\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\\b/g)||[]));",
+        "const missing=required.filter((id)=>!found.has(id));",
+        `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}`;
+}

package/dist/executors/shell-verification.js

@@ -20,6 +20,13 @@ const VERIFY_ENV_ALLOWLIST = [
     "COREPACK_ENABLE",
     "COREPACK_ENABLE_AUTO_PIN",
     "COREPACK_HOME",
+    // Windows DLL 加载必需
+    "SystemRoot",
+    "SYSTEMROOT",
+    "windir",
+    "WINDIR",
+    "ComSpec",
+    "PATHEXT",
 ];
 export function buildVerifyProcessEnv(mode = "clean") {
     if (mode === "inherit") {

package/dist/governance/manifest-types.js

@@ -43,6 +43,7 @@ export const workflowPolicyDagTemplateSchema = z.enum([
     "review-gated-dag",
     "supervised-implementation",
     "frontend-implementation",
+    "frontend-test-dag",
     "backend-test-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",