@tea-agent/loop-agent 0.27.1 → 0.28.0

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../../infrastructure/harness/artifact-store.js";
 import { executeDagNode, } from "../node-execution.js";
 import { writeRunSpec } from "../run-store.js";
+import { assertValidMaterializedDagTask } from "../validate.js";
 import { freshNodeRecord, parseJsonFromText, renderDynamicPatternList, renderDynamicTemplate, resolveItemsFromSelector, sha256Json, } from "./shared.js";
 export function buildExpandedChildTask(input) {
     const { parent, expansion, item, index, nodeId } = input;
@@ -20,6 +21,7 @@ export function buildExpandedChildTask(input) {
         role: child.role,
         skills: child.skills,
         toolProfile: child.toolProfile,
+        commandPolicy: child.commandPolicy,
         writePolicy: child.writePolicy,
         allowedPaths: renderDynamicPatternList(child.allowedPaths, item, index, expansion.itemName) ?? [],
         forbiddenPaths: renderDynamicPatternList(child.forbiddenPaths, item, index, expansion.itemName) ?? [],
@@ -98,14 +100,11 @@ async function materializeBlockedCaseEvidence(input) {
     const caseId = resolveCaseIdFromItem(input.item);
     try {
         const existing = JSON.parse(await readFile(resultPath, "utf-8"));
-        if (existing.caseId === caseId &&
-            (existing.status === "passed" ||
-                existing.status === "failed" ||
-                existing.status === "blocked"))
+        if (existing.caseId === caseId && existing.status === "blocked")
             return;
     }
     catch {
-        // Missing or malformed evidence is replaced only for a child that never finished a business result.
+        // Missing or malformed evidence is replaced by controller-owned terminal evidence.
     }
     await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: blocked\n\nReason: ${input.reason}\n`, "utf-8");
     await writeFile(resultPath, `${JSON.stringify({
@@ -130,14 +129,11 @@ async function materializeFailedCaseEvidence(input) {
     const caseId = resolveCaseIdFromItem(input.item);
     try {
         const existing = JSON.parse(await readFile(resultPath, "utf-8"));
-        if (existing.caseId === caseId &&
-            (existing.status === "passed" ||
-                existing.status === "failed" ||
-                existing.status === "blocked"))
+        if (existing.caseId === caseId && existing.status === "failed")
             return;
     }
     catch {
-        // Missing or malformed evidence is replaced only when the child never finished a business result.
+        // Missing or malformed evidence is replaced by controller-owned terminal evidence.
     }
     await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: failed\n\nReason: ${input.reason}\n`, "utf-8");
     await writeFile(resultPath, `${JSON.stringify({
@@ -170,6 +166,9 @@ export async function executeDynamicMapExpansion(input) {
         index,
         nodeId,
     }));
+    for (const child of children) {
+        assertValidMaterializedDagTask(child);
+    }
     const writeSetConflicts = collectDynamicChildWriteSetConflicts(children);
     if (writeSetConflicts.length > 0) {
         throw new Error(`dynamic map_agent ${input.task.id} expanded overlapping writeSets: ${writeSetConflicts.join("; ")}`);
@@ -356,9 +355,9 @@ export async function executeDynamicMapExpansion(input) {
                 throw new Error(`failed to materialize case outcome evidence for ${nodeId}: ${error instanceof Error ? error.message : String(error)}`);
             }
             caseOutcomeNotes.push({ nodeId, reason, status: outcomeStatus });
-            record.status = "FINISHED";
-            record.stderr = `${outcomeStatus}: ${reason}`;
-            record.failureCategory = "success";
+            // `tolerateChildFailures` changes only the map barrier's business
+            // aggregation. The child terminal state and failure category remain
+            // executor-owned facts for downstream authority checks.
         }
     }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
@@ -380,6 +379,7 @@ export async function executeDynamicMapExpansion(input) {
             item: items[index],
             workspaceRef: workspaceRefs[index],
             status: input.state.nodes[nodeId]?.status,
+            failureCategory: input.state.nodes[nodeId]?.failureCategory,
             stdout: input.state.nodes[nodeId]?.stdout,
             output: parseJsonFromText(input.state.nodes[nodeId]?.stdout),
             assistantText: input.state.nodes[nodeId]?.assistantText,

package/dist/workflows/dag/frontend-test-case-checklist.js

@@ -1,5 +1,19 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { isPlaywrightCliCommand } from "../../shared/playwright-cli-command-policy.js";
+const COMMAND_FENCE_LANGUAGE = /^(?:|bash|sh|shell|zsh|fish|console|terminal|command|cmd|powershell|pwsh|javascript|js|typescript|ts|python|py)$/i;
+const LIST_ITEM = /^\s*(?:[-+*]|\d+[.)])\s+(.+)$/;
+const INDENTED_CODE = /^(?: {4,}|\t+)(\S.*)$/;
+const EXPLICIT_COMMAND = /^(?:(?:shell|terminal)(?:\s+command)?|command|run command|execute command)\s*:\s*(.+)$/i;
+const BLOCKED_REASON_PREFIX = /^(?:(?:blocked|forbidden|reject(?:ed)?|disallow(?:ed)?|prohibited)(?:\s+reason)?\s*(?::|\bbecause\b)|(?:do not|must not|never)\s+(?:run|execute|use)\b)/i;
+const IMPERATIVE_COMMAND = /^(?:(?:run|execute|use)(?:\s+(?:the\s+)?(?:(?:shell|terminal)\s+)?command)?|in\s+(?:the\s+)?(?:shell|terminal|console)\s*,?\s*(?:run|execute|use))\s*:?\s+(.+)$/i;
+const INLINE_CODE_STEP = /^`([^`\r\n]+)`[.!?]?$/;
+const AUTOMATION_EXECUTABLE = /^(?:playwright-cli\b|playwright\b|@playwright\/test\b|npx\b|npm\b|pnpm\b|yarn\b|bunx?\b|node(?:js)?\b|python(?:3)?\b|bash\b|sh\b|zsh\b|fish\b|powershell\b|pwsh\b|cmd(?:\.exe)?\b|cypress\b|selenium\b|webdriverio\b|chromedriver\b|google-chrome\b|chrome\b|firefox\b|curl\b|wget\b)/i;
+const SHELL_WRAPPED_EXECUTABLE = /^(?:sudo\s+|env(?:\s+[A-Za-z_][A-Za-z0-9_]*=[^\s]+)*\s+|(?:\.{1,2}[\\/]|~[\\/]|[A-Za-z]:[\\/]|\/)[^\s]+)/i;
+const ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]*)/;
+const ENV_WRAPPER = /^env(?:\s+(?:-[A-Za-z]+|--[A-Za-z][A-Za-z-]*))*\s+/i;
+const SHELL_BUILTIN_WRAPPER = /^(?:command|exec|sudo)\s+/i;
+const PLAYWRIGHT_API = /^(?:from\s+playwright(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s+import\b|import\s+playwright(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\s+as\s+[A-Za-z_][A-Za-z0-9_]*)?\b|import\s+.+\s+from\s+["'](?:playwright|@playwright\/test)["']|(?:const|let|var)\s+.+\brequire\s*\(\s*["'](?:playwright|@playwright\/test)["']\s*\)|require\s*\(\s*["'](?:playwright|@playwright\/test)["']\s*\)|(?:sync_playwright|async_playwright|chromium|firefox|webkit)\.(?:launch|connect)\b)/i;
 async function exists(file) {
     try {
         return (await stat(file)).isFile();
@@ -8,6 +22,180 @@ async function exists(file) {
         return false;
     }
 }
+function normalizeCommand(value) {
+    const trimmed = value.trim().replace(/^[$>]\s*/, "");
+    const wrapped = trimmed.match(/^`([^`]+)`$/);
+    return (wrapped?.[1] ?? trimmed).trim();
+}
+function isExecutableFence(language) {
+    return COMMAND_FENCE_LANGUAGE.test(language.trim());
+}
+function isBlockedReason(value) {
+    return BLOCKED_REASON_PREFIX.test(value.trim());
+}
+function stripLeadingCommandWrappers(command) {
+    let remaining = command.trim();
+    let consumed = true;
+    while (remaining && consumed) {
+        consumed = false;
+        const assignment = remaining.match(ENV_ASSIGNMENT);
+        if (assignment) {
+            remaining = remaining.slice(assignment[0].length).trimStart();
+            consumed = true;
+            continue;
+        }
+        const env = remaining.match(ENV_WRAPPER);
+        if (env) {
+            remaining = remaining.slice(env[0].length).trimStart();
+            consumed = true;
+            continue;
+        }
+        const wrapper = remaining.match(SHELL_BUILTIN_WRAPPER);
+        if (wrapper) {
+            remaining = remaining.slice(wrapper[0].length).trimStart();
+            consumed = true;
+        }
+    }
+    return remaining;
+}
+function isCommandLikeExecutable(command) {
+    const executable = stripLeadingCommandWrappers(command);
+    return AUTOMATION_EXECUTABLE.test(executable) || SHELL_WRAPPED_EXECUTABLE.test(executable) || PLAYWRIGHT_API.test(executable);
+}
+function executableListStep(value) {
+    const trimmed = value.trim();
+    const explicit = trimmed.match(EXPLICIT_COMMAND);
+    if (explicit)
+        return isBlockedReason(explicit[1]) ? null : normalizeCommand(explicit[1]);
+    const imperative = trimmed.match(IMPERATIVE_COMMAND);
+    if (imperative)
+        return normalizeCommand(imperative[1]);
+    const inlineCode = trimmed.match(INLINE_CODE_STEP);
+    if (inlineCode)
+        return normalizeCommand(inlineCode[1]);
+    const prompted = /^[$>]\s*\S/.test(trimmed);
+    const normalized = normalizeCommand(trimmed);
+    if (prompted || isCommandLikeExecutable(normalized))
+        return normalized;
+    return null;
+}
+function hasShellControl(command) {
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (quote !== null) {
+            if (character === quote)
+                quote = null;
+            else if (quote === '"' && (character === "`" || (character === "$" && command[index + 1] === "(")))
+                return true;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            continue;
+        }
+        if (character === "#" && (index === 0 || /\s/.test(command[index - 1])))
+            break;
+        if (character === "`" || character === ";" || character === "|" || character === "&" || character === "<" || character === ">")
+            return true;
+        if (character === "$" && command[index + 1] === "(")
+            return true;
+    }
+    return false;
+}
+/**
+ * Return only Markdown lines that are presented as commands. Prose can mention
+ * forbidden commands as a blocked reason without becoming an executable step.
+ */
+function extractExecutableInstructions(markdown) {
+    const instructions = [];
+    let fenceLanguage = null;
+    for (const [index, line] of markdown.split(/\r?\n/).entries()) {
+        const lineNumber = index + 1;
+        const fence = line.match(/^\s*```([^`]*)$/);
+        if (fence) {
+            fenceLanguage = fenceLanguage === null ? fence[1].trim() : null;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (fenceLanguage !== null) {
+            if (!isExecutableFence(fenceLanguage) || /^(?:#|\/\/)/.test(trimmed))
+                continue;
+            instructions.push({ command: normalizeCommand(trimmed), lineNumber });
+            continue;
+        }
+        const listed = line.match(LIST_ITEM);
+        if (listed) {
+            if (isBlockedReason(listed[1]))
+                continue;
+            const command = executableListStep(listed[1]);
+            if (command !== null)
+                instructions.push({ command, lineNumber });
+            continue;
+        }
+        const indented = line.match(INDENTED_CODE);
+        if (indented) {
+            if (isBlockedReason(indented[1]))
+                continue;
+            const explicitIndented = indented[1].match(EXPLICIT_COMMAND);
+            if (explicitIndented && isBlockedReason(explicitIndented[1]))
+                continue;
+            instructions.push({ command: executableListStep(indented[1]) ?? normalizeCommand(indented[1]), lineNumber });
+            continue;
+        }
+        const explicit = trimmed.match(EXPLICIT_COMMAND);
+        if (explicit) {
+            if (isBlockedReason(explicit[1]))
+                continue;
+            instructions.push({ command: normalizeCommand(explicit[1]), lineNumber });
+            continue;
+        }
+        const command = executableListStep(trimmed);
+        if (command !== null)
+            instructions.push({ command, lineNumber });
+    }
+    return instructions;
+}
+function commandGateIssue(input) {
+    const commandMatch = input.instruction.command.match(/^playwright-cli\s+([^\s`]+)/i);
+    if (commandMatch) {
+        const command = commandMatch[1].toLowerCase();
+        if (isPlaywrightCliCommand(command) && !hasShellControl(input.instruction.command))
+            return null;
+        if (isPlaywrightCliCommand(command)) {
+            return {
+                ruleId: "alternative-executable-command",
+                caseId: input.caseId,
+                casePath: input.casePath,
+                lineNumber: input.instruction.lineNumber,
+                command: input.instruction.command,
+                detail: "shell control or additional executable fragments are not allowed after playwright-cli commands",
+            };
+        }
+        return {
+            ruleId: "playwright-cli-command-not-allowed",
+            caseId: input.caseId,
+            casePath: input.casePath,
+            lineNumber: input.instruction.lineNumber,
+            command: input.instruction.command,
+            detail: `playwright-cli command is not allowlisted: ${command}`,
+        };
+    }
+    return {
+        ruleId: "alternative-executable-command",
+        caseId: input.caseId,
+        casePath: input.casePath,
+        lineNumber: input.instruction.lineNumber,
+        command: input.instruction.command,
+        detail: "only allowlisted playwright-cli commands may appear in executable case instructions",
+    };
+}
 export async function validateFrontendCaseChecklist(input) {
     const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
     const draft = path.join(root, "manifest.draft.json");
@@ -36,34 +224,39 @@ export async function validateFrontendCaseChecklist(input) {
         const absolute = path.resolve(input.workspaceRoot, casePath);
         const relative = path.relative(input.workspaceRoot, absolute);
         if (!casePath || relative.startsWith("..") || path.isAbsolute(relative) || !(await exists(absolute))) {
-            issues.push({ ruleId: "case-file-missing", caseId: id, detail: casePath || "missing casePath" });
+            issues.push({ ruleId: "case-file-missing", caseId: id, casePath: casePath || undefined, detail: casePath || "missing casePath" });
             continue;
         }
         if (expectedPath && casePath.replaceAll("\\", "/") !== expectedPath)
-            issues.push({ ruleId: "case-path-mismatch", caseId: id, detail: `${casePath} must equal ${expectedPath}` });
+            issues.push({ ruleId: "case-path-mismatch", caseId: id, casePath, detail: `${casePath} must equal ${expectedPath}` });
         const body = await readFile(absolute, "utf8");
         if (!openRe.test(body))
-            issues.push({ ruleId: "open-prefix", caseId: id, detail: "missing playwright-cli open --browser=chrome --headed <absolute-url>" });
+            issues.push({ ruleId: "open-prefix", caseId: id, casePath, detail: "missing playwright-cli open --browser=chrome --headed <absolute-url>" });
         const match = body.match(/playwright-cli\s+open\s+--browser=chrome\s+--headed\s+(https?:\/\/\S+)/i);
         if (match) {
             try {
                 const url = new URL(match[1].replace(/[)\]},.\"'`]+$/, ""));
                 if (productionHostRe.test(url.hostname))
-                    issues.push({ ruleId: "production-url", caseId: id, detail: match[1] });
+                    issues.push({ ruleId: "production-url", caseId: id, casePath, detail: match[1] });
             }
             catch {
-                issues.push({ ruleId: "production-url", caseId: id, detail: match[1] });
+                issues.push({ ruleId: "production-url", caseId: id, casePath, detail: match[1] });
             }
         }
+        for (const instruction of extractExecutableInstructions(body)) {
+            const issue = commandGateIssue({ caseId: id, casePath, instruction });
+            if (issue)
+                issues.push(issue);
+        }
         if (!Array.isArray(item?.acIds) || item.acIds.length === 0) {
-            issues.push({ ruleId: "ac-mapping", caseId: id, detail: "acIds required" });
+            issues.push({ ruleId: "ac-mapping", caseId: id, casePath, detail: "acIds required" });
         }
         else {
             for (const ac of item.acIds) {
                 if (typeof ac !== "string" || !acIdRe.test(ac))
-                    issues.push({ ruleId: "ac-id-shape", caseId: id, detail: String(ac) });
+                    issues.push({ ruleId: "ac-id-shape", caseId: id, casePath, detail: String(ac) });
                 else if (declaredAc.size > 0 && !declaredAc.has(ac))
-                    issues.push({ ruleId: "unknown-ac", caseId: id, detail: `${ac} not in sourceBinding` });
+                    issues.push({ ruleId: "unknown-ac", caseId: id, casePath, detail: `${ac} not in sourceBinding` });
             }
         }
     }

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

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
-import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+import { readPlaywrightCliReceipts, summarizePlaywrightCliReceipts, } from "../../executors/pi-playwright-cli-tool.js";
 import { validateFrontendCaseContent } from "./frontend-test-case-quality.js";
 export const FRONTEND_TEST_RESULT_SCHEMA_ID = "frontend-test-result-v1";
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
@@ -180,6 +181,38 @@ export async function validateFrontendCaseEvidence(input) {
     }
     return { cases: manifest.cases.length, issues, hardFail };
 }
+export function evaluatePassedCaseBrowserReceipts(summary, caseId) {
+    if (!summary || summary.caseIds.size !== 1 || !summary.caseIds.has(caseId)) {
+        return { ok: false, reason: "browser-command-evidence-missing" };
+    }
+    if (!summary.hasOrderedPassedReceiptChain) {
+        return { ok: false, reason: "browser-command-evidence-missing" };
+    }
+    return { ok: true };
+}
+async function loadCaseBrowserReceiptSummary(input) {
+    try {
+        const entries = await readdir(input.runDir, { withFileTypes: true });
+        // A passed chain must belong to exactly one browser child stream. Never
+        // stitch receipts across DAG nodes or accept ambiguous duplicate authority.
+        const authorizingStreams = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const nodeReceipts = (await readPlaywrightCliReceipts(input.runDir, entry.name))
+                .filter((item) => item.caseId === input.caseId);
+            const summary = summarizePlaywrightCliReceipts(nodeReceipts);
+            if (summary.hasOrderedPassedReceiptChain)
+                authorizingStreams.push(summary);
+        }
+        return authorizingStreams.length === 1
+            ? authorizingStreams[0]
+            : summarizePlaywrightCliReceipts([]);
+    }
+    catch {
+        return summarizePlaywrightCliReceipts([]);
+    }
+}
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
@@ -296,7 +329,7 @@ export async function materializeFrontendTestResult(input) {
             advisoryFindings.push({ ruleId: "missing-or-invalid-case-result", caseId: item.caseId, detail: "case-result.json is missing or invalid" });
         }
         const parsedStatus = caseStatusSchema.safeParse(resultRaw.status);
-        const status = parsedStatus.success ? parsedStatus.data : "blocked";
+        let status = parsedStatus.success ? parsedStatus.data : "blocked";
         if (resultRaw.caseId !== undefined && resultRaw.caseId !== item.caseId)
             advisoryFindings.push({ ruleId: "case-result-identity", caseId: item.caseId, detail: "case-result caseId does not match manifest" });
         if (status === "blocked" && resultRaw.blockedReason !== undefined && (typeof resultRaw.blockedReason !== "string" || !resultRaw.blockedReason.trim()))
@@ -318,8 +351,24 @@ export async function materializeFrontendTestResult(input) {
         }
         if (status === "passed" && !evidence.some((entry) => /\.(png|jpg|jpeg|webp|zip|har|webm|mp4|ya?ml|md)$/i.test(entry.path)))
             advisoryFindings.push({ ruleId: "passed-without-browser-evidence", caseId: item.caseId, detail: "passed case has no browser evidence" });
+        let blockedReason = status === "blocked" && typeof resultRaw.blockedReason === "string" && resultRaw.blockedReason.trim() ? resultRaw.blockedReason.trim() : undefined;
+        if (status === "passed") {
+            const receiptSummary = await loadCaseBrowserReceiptSummary({
+                runDir: input.runDir,
+                caseId: item.caseId,
+            });
+            const receiptGate = evaluatePassedCaseBrowserReceipts(receiptSummary, item.caseId);
+            if (!receiptGate.ok) {
+                status = "blocked";
+                blockedReason = receiptGate.reason ?? "browser-command-evidence-missing";
+                advisoryFindings.push({
+                    ruleId: "browser-command-evidence-missing",
+                    caseId: item.caseId,
+                    detail: "passed case lacks controller-owned open + interaction/assertion + cleanup receipts",
+                });
+            }
+        }
         const caseContent = await readFrontendCaseContent(input.workspaceRoot, item.casePath);
-        const blockedReason = status === "blocked" && typeof resultRaw.blockedReason === "string" && resultRaw.blockedReason.trim() ? resultRaw.blockedReason.trim() : undefined;
         const explicitAnalysis = typeof resultRaw.errorAnalysis === "string" && resultRaw.errorAnalysis.trim()
             ? resultRaw.errorAnalysis.trim()
             : typeof resultRaw.errorSummary === "string" && resultRaw.errorSummary.trim()