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

package/dist/commands/loop-benchmark.js

@@ -37,17 +37,17 @@ export function parseLoopBenchmarkArgs(args) {
     return { json, markdown, outputPath };
 }
 export function printLoopBenchmarkUsage() {
-    console.log(`usage: loop-benchmark [options]
-
-Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
-
-Options:
-  --json              Emit JSON (default when no format flag is set)
-  --markdown          Emit Markdown report
-  --output <path>     Write Markdown report to a repo-relative or absolute path
-  -h, --help          Show this help
-
-Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
+    console.log(`usage: loop-benchmark [options]
+
+Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
+
+Options:
+  --json              Emit JSON (default when no format flag is set)
+  --markdown          Emit Markdown report
+  --output <path>     Write Markdown report to a repo-relative or absolute path
+  -h, --help          Show this help
+
+Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
 Recommendation never changes convergence.enabled default.`);
 }
 export async function runLoopBenchmark(repoRoot, rawArgs) {

package/dist/commands/pi-reuse-benchmark.js

@@ -106,22 +106,22 @@ export function parsePiReuseBenchmarkArgs(args) {
     };
 }
 export function printPiReuseBenchmarkUsage() {
-    console.log(`usage: pi-reuse-benchmark [options]
-
-Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
-
-Options:
-  --report <path>         Benchmark report markdown (approval status)
-  --approval <path>       Explicit approval JSON artifact
-  --off-executor <path>   Baseline executor.jsonl (reuse off)
-  --on-executor <path>    Treatment executor.jsonl (reuse on)
-  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
-  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
-  --json                  Emit JSON (default when no format flag is set)
-  --markdown              Emit Markdown summary
-  -h, --help              Show this help
-
-Recommendations: defer | maintain-opt-in | eligible-for-human-review
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
 Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
 }
 function resolveRepoRelative(repoRoot, filePath) {

package/dist/executors/shell-executor.js

@@ -3,8 +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 { buildRequirementCoverageGateShellCommand, 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;
@@ -24,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);
@@ -48,7 +56,12 @@ export function resolveShellCommands(shell) {
     const fromRequirementCoverageGate = shell.requirementCoverageGate
         ? [buildRequirementCoverageGateShellCommand(shell.requirementCoverageGate)]
         : [];
-    return [...fromPreset, ...explicit, ...fromVerdictGate, ...fromRequirementCoverageGate];
+    return [
+        ...fromPreset,
+        ...explicit,
+        ...fromVerdictGate,
+        ...fromRequirementCoverageGate,
+    ];
 }
 async function readGitStatusPorcelain(cwd) {
     return new Promise((resolve, reject) => {
@@ -145,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,
             });
         });
@@ -286,16 +302,164 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.jsonArtifactGate) {
         const started = Date.now();
         try {
-            const artifact = await materializeBackendTestAnalysisContract({
+            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,
-                fromNodeId: shell.jsonArtifactGate.fromNodeId,
-                artifactName: shell.jsonArtifactGate.artifactName,
-                outputDir: shell.jsonArtifactGate.outputDir,
-                sourceBinding: meta.spec.sourceBinding,
+                workspaceRoot: input.cwd,
             });
             return {
                 ok: true,
-                stdout: `Structured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+                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,
@@ -362,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,
@@ -376,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/infrastructure/evaluation/candidate-store.js

@@ -272,7 +272,11 @@ export async function registerCandidateManifest(input) {
         }
         catch (error) {
             const code = error.code;
-            if (code !== "EEXIST" && code !== "ENOTEMPTY")
+            const isCreateRace = code === "EEXIST" ||
+                code === "ENOTEMPTY" ||
+                (code === "EPERM" &&
+                    (await pathExists(candidateDir(repoRoot, manifest.candidateId))));
+            if (!isCreateRace)
                 throw error;
             await rm(stagingDir, { recursive: true, force: true });
             return readExistingRegistration(repoRoot, manifest, manifestPath, lifecyclePath);

package/dist/sidecars/cursor-prompt/executor.js

@@ -29,7 +29,7 @@ export function resolveArtifactWriteDir(options) {
 }
 export function buildArtifactPathPrompt(writeDir) {
     if (!writeDir)
-        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
 ${ARTIFACT_INSTRUCTIONS}`;
     return [
         `After changes, write the following files:`,

package/dist/task/runtime.js

@@ -236,35 +236,35 @@ export function shouldInjectSubagentGuidance(step, mode) {
     return false;
 }
 /** Advisory guidance for `analyze-plan` mode. */
-export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-Use it only for read-only tasks:
-- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+Use it only for read-only tasks:
+- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Strong guidance for `full` mode — prescriptive when to delegate. */
-export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-
-You SHOULD delegate to subagent scouts when:
-- The task requires scanning 3+ directories or comparing implementations across modules
-- You would otherwise need 5+ sequential read/grep calls to gather context
-- A reviewer subagent can independently catch scope drift before you finalize your output
-
-Delegation saves context tokens and produces better results.
-
-Allowed patterns:
-- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+
+You SHOULD delegate to subagent scouts when:
+- The task requires scanning 3+ directories or comparing implementations across modules
+- You would otherwise need 5+ sequential read/grep calls to gather context
+- A reviewer subagent can independently catch scope drift before you finalize your output
+
+Delegation saves context tokens and produces better results.
+
+Allowed patterns:
+- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Preserved for backward compatibility (alias of STANDARD). */
 export const SUBAGENT_GUIDANCE = SUBAGENT_GUIDANCE_STANDARD;

package/dist/worker/observe/static/api.js

@@ -1,46 +1,46 @@
-/** Fetch and artifact helpers (Observe UI R5). */
-
-export async function fetchJson(url) {
-	try {
-		const res = await fetch(url);
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Read-only JSON fetch that preserves HTTP status so callers can distinguish
- * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
- */
-export async function fetchJsonResult(url) {
-	try {
-		const res = await fetch(url);
-		let body = null;
-		try {
-			body = await res.json();
-		} catch {
-			body = null;
-		}
-		return { ok: res.ok, status: res.status, body };
-	} catch {
-		return { ok: false, status: 0, body: null };
-	}
-}
-
-export function artifactUrl(artifactPath) {
-	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
-}
-
-export function parseArtifactPreviewResponse(text) {
-	const parsed = JSON.parse(text);
-	if (!parsed || typeof parsed.content !== "string") {
-		throw new Error("Artifact preview response is invalid");
-	}
-	return {
-		content: parsed.content,
-		truncated: parsed.truncated === true,
-	};
-}
-
+/** Fetch and artifact helpers (Observe UI R5). */
+
+export async function fetchJson(url) {
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read-only JSON fetch that preserves HTTP status so callers can distinguish
+ * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
+ */
+export async function fetchJsonResult(url) {
+	try {
+		const res = await fetch(url);
+		let body = null;
+		try {
+			body = await res.json();
+		} catch {
+			body = null;
+		}
+		return { ok: res.ok, status: res.status, body };
+	} catch {
+		return { ok: false, status: 0, body: null };
+	}
+}
+
+export function artifactUrl(artifactPath) {
+	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
+}
+
+export function parseArtifactPreviewResponse(text) {
+	const parsed = JSON.parse(text);
+	if (!parsed || typeof parsed.content !== "string") {
+		throw new Error("Artifact preview response is invalid");
+	}
+	return {
+		content: parsed.content,
+		truncated: parsed.truncated === true,
+	};
+}
+