@tea-agent/loop-agent 0.24.5 → 0.24.7

package/dist/workflows/dag/frontend-test-result-contract.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { lstat, readFile, realpath } from "node:fs/promises";
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
@@ -68,6 +68,111 @@ export const frontendTestResultContractSchema = z.object({
         ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["integrationMode"], message: "real integration requires passed outcome" });
     }
 });
+async function isNonEmptyFile(filePath) {
+    try {
+        const info = await stat(filePath);
+        return info.isFile() && info.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function isSafeEvidenceShellPath(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        !path.isAbsolute(value) &&
+        !path.win32.isAbsolute(value) &&
+        !value.includes(".."));
+}
+/**
+ * Validate frontend browser evidence without going through a shell command.
+ * Keeping this in the Node executor avoids CMD/Git Bash/PowerShell quoting and
+ * backslash interpretation for the former long `node -e` command.
+ */
+export async function validateFrontendCaseEvidence(input) {
+    const manifestPath = path.join(input.workspaceRoot, "testcase/frontend/cases/manifest.json");
+    try {
+        await stat(manifestPath);
+    }
+    catch {
+        throw new Error("missing testcase/frontend/cases/manifest.json");
+    }
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (!Array.isArray(manifest.cases))
+        throw new Error("invalid frontend case manifest");
+    const statuses = new Set(["passed", "failed", "blocked"]);
+    const issues = [];
+    let hardFail = false;
+    for (const rawCase of manifest.cases) {
+        const item = rawCase;
+        const id = typeof item?.caseId === "string" ? item.caseId : "?";
+        const dir = item?.evidenceDir;
+        const prefix = `testcase/frontend/evidence/${id}`;
+        if (!item ||
+            typeof item.caseId !== "string" ||
+            typeof dir !== "string" ||
+            !isSafeEvidenceShellPath(dir) ||
+            !(dir === prefix || dir.startsWith(`${prefix}/`))) {
+            hardFail = true;
+            issues.push({ ruleId: "unsafe-evidence-dir", caseId: id, detail: String(dir) });
+            continue;
+        }
+        const execution = path.join(input.workspaceRoot, dir, "execution.md");
+        const resultPath = path.join(input.workspaceRoot, dir, "case-result.json");
+        if (!(await isNonEmptyFile(execution))) {
+            issues.push({ ruleId: "missing-execution", caseId: id, detail: "execution.md is missing or empty" });
+        }
+        let result = null;
+        if (!(await isNonEmptyFile(resultPath))) {
+            issues.push({ ruleId: "missing-case-result", caseId: id, detail: "case-result.json is missing" });
+            continue;
+        }
+        try {
+            result = JSON.parse(await readFile(resultPath, "utf8"));
+        }
+        catch {
+            issues.push({ ruleId: "invalid-case-result", caseId: id, detail: "case-result.json is malformed" });
+            continue;
+        }
+        if (!result || result.caseId !== id) {
+            issues.push({ ruleId: "case-result-identity", caseId: id, detail: "case-result caseId does not match manifest" });
+        }
+        if (!statuses.has(String(result?.status))) {
+            issues.push({ ruleId: "invalid-case-status", caseId: id, detail: "status must be passed, failed, or blocked" });
+        }
+        if (!Array.isArray(result?.evidencePaths)) {
+            issues.push({ ruleId: "invalid-evidence-paths", caseId: id, detail: "evidencePaths must be an array" });
+        }
+        else {
+            for (const evidencePath of result.evidencePaths) {
+                if (!isSafeEvidenceShellPath(evidencePath)) {
+                    hardFail = true;
+                    issues.push({ ruleId: "unsafe-evidence-path", caseId: id, detail: String(evidencePath) });
+                    continue;
+                }
+                const currentPrefix = `${prefix}/`;
+                if (evidencePath.startsWith("testcase/frontend/evidence/") && !evidencePath.startsWith(currentPrefix)) {
+                    hardFail = true;
+                    issues.push({ ruleId: "cross-case-evidence-path", caseId: id, detail: evidencePath });
+                    continue;
+                }
+                const target = evidencePath.startsWith("testcase/")
+                    ? path.join(input.workspaceRoot, evidencePath)
+                    : path.join(input.workspaceRoot, dir, evidencePath);
+                if (!(await isNonEmptyFile(target))) {
+                    issues.push({ ruleId: "missing-evidence", caseId: id, detail: `${evidencePath} is missing or empty` });
+                }
+            }
+        }
+        if (result?.status === "passed" && (!Array.isArray(result.evidencePaths) || !result.evidencePaths.some((entry) => /\.(png|jpg|jpeg|webp|zip|har|webm|mp4)$/i.test(String(entry))))) {
+            issues.push({ ruleId: "passed-without-browser-evidence", caseId: id, detail: "passed case has no screenshot, HAR, video, or equivalent browser artifact" });
+        }
+        if (result?.status === "blocked" && (typeof result.blockedReason !== "string" || !result.blockedReason.trim())) {
+            issues.push({ ruleId: "blocked-reason", caseId: id, detail: "blocked result has no usable reason" });
+        }
+    }
+    return { cases: manifest.cases.length, issues, hardFail };
+}
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
@@ -214,43 +319,3 @@ export function buildFrontendTestOutcomeGateShellSnippet(options) {
         `node -e 'const fs=require("fs");const r=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));const ok=r.outcome==="passed"&&r.integrationMode==="real"&&Number(r.totals?.failed||0)===0&&Number(r.totals?.blocked||0)===0&&Array.isArray(r.acceptanceCoverage?.missing)&&r.acceptanceCoverage.missing.length===0;console.log("frontend-test outcome="+r.outcome+" integrationMode="+r.integrationMode);if(!ok)process.exit(1);' "\${RESULT}"`,
     ].join("; ");
 }
-/**
- * Shared frontend-test evidence advisory check for map children + node 7.
- * Hard-fails only for unsafe evidence directories or evidence paths. Missing,
- * malformed, or empty evidence is reported without mutating case outputs.
- */
-export function buildFrontendCaseEvidenceValidateShellSnippet() {
-    const body = [
-        "const fs=require('fs'),path=require('path');",
-        "const manifestPath='testcase/frontend/cases/manifest.json';",
-        "if(!fs.existsSync(manifestPath))throw new Error('missing '+manifestPath);",
-        "const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));",
-        "if(!Array.isArray(manifest.cases))throw new Error('invalid frontend case manifest');",
-        "const statuses=new Set(['passed','failed','blocked']);",
-        "const issues=[];",
-        "let hardFail=false;",
-        "function isSafeRel(p){return typeof p==='string'&&p.length>0&&!path.isAbsolute(p)&&!path.win32.isAbsolute(p)&&!p.includes('..');}",
-        "for(const c of manifest.cases){",
-        " const id=c&&typeof c.caseId==='string'?c.caseId:'?';",
-        " const dir=c&&c.evidenceDir;",
-        " const prefix='testcase/frontend/evidence/'+id;",
-        " if(!c||typeof c.caseId!=='string'||typeof dir!=='string'||!isSafeRel(dir)||!(dir===prefix||dir.startsWith(prefix+'/'))){",
-        "  hardFail=true; issues.push({ruleId:'unsafe-evidence-dir',caseId:id,detail:String(dir)}); continue;",
-        " }",
-        " const execution=path.join(dir,'execution.md');",
-        " const resultPath=path.join(dir,'case-result.json');",
-        " if(!fs.existsSync(execution)||!fs.statSync(execution).isFile()||fs.statSync(execution).size===0)issues.push({ruleId:'missing-execution',caseId:id,detail:'execution.md is missing or empty'});",
-        " let result=null;",
-        " if(!fs.existsSync(resultPath)){issues.push({ruleId:'missing-case-result',caseId:id,detail:'case-result.json is missing'});continue;}",
-        " try{result=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch(e){issues.push({ruleId:'invalid-case-result',caseId:id,detail:'case-result.json is malformed'});continue;}",
-        " if(!result||result.caseId!==id)issues.push({ruleId:'case-result-identity',caseId:id,detail:'case-result caseId does not match manifest'});",
-        " if(!statuses.has(result&&result.status))issues.push({ruleId:'invalid-case-status',caseId:id,detail:'status must be passed, failed, or blocked'});",
-        " if(!Array.isArray(result&&result.evidencePaths)){issues.push({ruleId:'invalid-evidence-paths',caseId:id,detail:'evidencePaths must be an array'});}else{for(const p of result.evidencePaths){if(!isSafeRel(p)){hardFail=true;issues.push({ruleId:'unsafe-evidence-path',caseId:id,detail:String(p)});continue;}const currentPrefix=prefix+'/';if(p.startsWith('testcase/frontend/evidence/')&&!p.startsWith(currentPrefix)){hardFail=true;issues.push({ruleId:'cross-case-evidence-path',caseId:id,detail:p});continue;}const target=p.startsWith('testcase/')?p:path.join(dir,p);if(!fs.existsSync(target)||!fs.statSync(target).isFile()||fs.statSync(target).size===0)issues.push({ruleId:'missing-evidence',caseId:id,detail:p+' is missing or empty'});}}",
-        " if(result&&result.status==='passed'&&(!Array.isArray(result.evidencePaths)||!result.evidencePaths.some(p=>/\\.(png|jpg|jpeg|webp|zip|har|webm|mp4)$/i.test(p))))issues.push({ruleId:'passed-without-browser-evidence',caseId:id,detail:'passed case has no screenshot, HAR, video, or equivalent browser artifact'});",
-        " if(result&&result.status==='blocked'&&(typeof result.blockedReason!=='string'||!result.blockedReason.trim()))issues.push({ruleId:'blocked-reason',caseId:id,detail:'blocked result has no usable reason'});",
-        "}",
-        "if(hardFail){console.error('frontend-test evidence hard-fail: '+JSON.stringify(issues)); process.exit(1);}",
-        "console.log('frontend case evidence advisory validation ok cases='+manifest.cases.length+' findings='+issues.length+(issues.length?(' issues='+JSON.stringify(issues)):''));",
-    ].join("");
-    return ["node -e", JSON.stringify(body)].join(" ");
-}

package/dist/workflows/dag/init-hybrid.js

@@ -25,7 +25,7 @@ import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "
 import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
 import { buildBackendTestIntakeContext } from "./backend-test-intake-context.js";
-import { buildFrontendCaseEvidenceValidateShellSnippet, buildFrontendTestOutcomeGateShellSnippet, } from "./frontend-test-result-contract.js";
+import { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
@@ -3504,8 +3504,6 @@ function buildFrontendTestHybridDag(sources) {
             "process.stdout.write(JSON.stringify({cases:manifest.cases}));",
         ].join("")),
     ].join(" ");
-    // Heal malformed/missing case evidence to blocked; only unsafe evidenceDir hard-fails.
-    const evidenceValidation = buildFrontendCaseEvidenceValidateShellSnippet();
     const frontendTestOutcomeGate = buildFrontendTestOutcomeGateShellSnippet();
     const frontendCaseQualityAdvisory = [
         "node -e",
@@ -3753,9 +3751,9 @@ function buildFrontendTestHybridDag(sources) {
         writeSet: [`${evidenceRoot}/**`],
         allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
         forbiddenPaths: forbidden,
-        outputContract: "Deterministic evidence gate: heal missing/malformed case-result to blocked(invalid-evidence-shape); hard-fail only on unsafe evidenceDir. Does not block retrospect.",
-        subtask_prompt: "Validate frontend case evidence before result materialization. Prefer healing bad shapes to blocked so pipeline can still produce a report; only path-escape failures abort the node.",
-        shell: { commands: [evidenceValidation], cwd: ".", timeoutMs: 120000 },
+        outputContract: "Deterministic evidence gate: missing/malformed evidence is advisory; only unsafe evidenceDir or evidence paths hard-fail. Does not block retrospect.",
+        subtask_prompt: "Validate frontend case evidence before result materialization. Keep missing or malformed evidence as advisory findings; only path-escape failures abort the node.",
+        shell: { commands: [], frontendTestEvidenceValidation: {}, cwd: ".", timeoutMs: 120000 },
     }, {
         id: "materialize-frontend-test-result-shell",
         depends_on: ["validate-frontend-case-evidence-shell"],

package/dist/workflows/dag/node-execution.js

@@ -593,8 +593,9 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
             node.structuredArtifactSchemaId = task.shell.jsonArtifactGate.schemaId;
         }
-        else if (task.shell?.backendTestPipeline === "classification-result-context") {
-            // The current 15-node single-run pipeline materializes the canonical
+        else if (task.shell?.backendTestPipeline === "classification-result-context" ||
+            task.shell?.backendTestPipeline === "markdown-execute-html") {
+            // Legacy 15-node and Markdown-first 8-node pipelines materialize
             // contracts/backend-test-result.json without jsonArtifactGate. Bind it
             // so Outcome adapters project kind=backend-test-result for Ready Planner.
             const artifactPath = path.join(runDir, "contracts", "backend-test-result.json");

package/dist/workflows/dag/types.js

@@ -280,6 +280,7 @@ export const dagBackendTestPipelineSchema = z.enum([
     "markdown-traceability",
     "markdown-execute-html",
 ]);
+export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
 export const dagShellConfigSchema = z.object({
     commands: z.array(z.string()).default([]),
     preset: dagShellPresetSchema.optional(),
@@ -293,6 +294,7 @@ export const dagShellConfigSchema = z.object({
     frontendLintBaseline: dagFrontendLintBaselineSchema.optional(),
     frontendVerificationBundle: dagFrontendVerificationBundleSchema.optional(),
     frontendReviewContext: dagFrontendReviewContextSchema.optional(),
+    frontendTestEvidenceValidation: dagFrontendTestEvidenceValidationSchema.optional(),
     backendTestPipeline: dagBackendTestPipelineSchema.optional(),
     verifyEvidence: dagShellVerifyEvidenceSchema.optional(),
     repairArtifactGate: dagRepairArtifactGateSchema.optional(),

package/dist/workflows/dag/validate.js

@@ -461,10 +461,11 @@ function validateShellTaskConfig(task, spec, issues) {
         !shell.backendTestPipeline &&
         !shell.frontendPrewriteGate &&
         !shell.frontendVerificationBundle &&
-        !shell.frontendReviewContext) {
+        !shell.frontendReviewContext &&
+        !shell.frontendTestEvidenceValidation) {
         issues.push({
             type: "missing-shell-commands",
-            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, shell.jsonArtifactGate, shell.backendTestPipeline, and/or non-empty shell.commands`,
+            message: `shell task ${task.id} requires a supported shell operation or non-empty shell.commands`,
         });
     }
     if (commands.some((command) => command.trim().length === 0)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.24.5",
+  "version": "0.24.7",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",