@tea-agent/loop-agent 0.27.1 → 0.28.1-beta.1

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-implementation-contract.js

@@ -155,7 +155,7 @@ export const frontendImplementationContractSchema = z
             "not-needed",
         ]),
         productionDefaultOff: z.literal(true),
-        activation: z.string().min(1),
+        activation: z.preprocess((value) => (value === "" || value === null ? "explicit activation boundary" : value), z.string().min(1)),
         endpoints: z.array(z
             .object({
             method: z.enum([
@@ -168,7 +168,10 @@ export const frontendImplementationContractSchema = z
                 "OPTIONS",
             ]),
             path: z.string().startsWith("/"),
-            fixture: safePath.optional(),
+            // Models occasionally emit an empty fixture when Mock is
+            // intentionally not needed. Treat it like an omitted optional
+            // field; active Mock strategies still fail the refinement below.
+            fixture: z.preprocess((value) => (value === "" || value === null ? undefined : value), safePath.optional()),
             consumer: safePath.optional(),
         })
             .strict()),
@@ -187,7 +190,7 @@ export const frontendImplementationContractSchema = z
         type: z.enum(["static", "unit", "component", "integration", "mock"]),
         commandLabel: z.string().min(1),
         file: safePath,
-        symbol: z.string().min(1).optional(),
+        symbol: z.preprocess((value) => (value === "" || value === null ? undefined : value), z.string().min(1).optional()),
         requirementIds: z.array(id),
         uiStates: z.array(z.string().min(1)),
     })
@@ -343,12 +346,127 @@ function secretIssues(value, at = "$", issues = []) {
 }
 export function extractFrontendImplementationJson(text) {
     const trimmed = text.trim();
+    const parse = (source) => {
+        try {
+            return JSON.parse(source);
+        }
+        catch (error) {
+            // Models sometimes put ordinary ASCII quotes inside a JSON string
+            // (for example: `reason: "支持..."`). Repair only quotes that are
+            // clearly not structural: a closing quote is followed by JSON
+            // punctuation, while an embedded quote is followed by content.
+            let repaired = "";
+            let inString = false;
+            let escaped = false;
+            for (let index = 0; index < source.length; index += 1) {
+                const character = source[index];
+                if (character !== '"') {
+                    repaired += character;
+                    if (inString && character === "\\" && !escaped)
+                        escaped = true;
+                    else
+                        escaped = false;
+                    continue;
+                }
+                if (escaped) {
+                    repaired += character;
+                    escaped = false;
+                    continue;
+                }
+                if (!inString) {
+                    inString = true;
+                    repaired += character;
+                    continue;
+                }
+                const next = source.slice(index + 1).trimStart()[0];
+                if ([",", "}", "]", ":"].includes(next ?? "") || source.slice(index + 1).trim() === "") {
+                    inString = false;
+                    repaired += character;
+                }
+                else {
+                    repaired += "\\\"";
+                }
+            }
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                throw error;
+            }
+        }
+    };
+    const isContract = (candidate) => {
+        const record = asRecord(candidate);
+        return (record?.schemaVersion === 1 &&
+            asRecord(record.targets) !== null &&
+            Array.isArray(record.requirements) &&
+            Array.isArray(record.verificationTargets));
+    };
     if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return JSON.parse(trimmed);
+        return parse(trimmed);
+    const balancedObjects = [];
+    for (let start = 0; start < trimmed.length; start += 1) {
+        if (trimmed[start] !== "{")
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = start; index < trimmed.length; index += 1) {
+            const character = trimmed[index];
+            if (inString) {
+                if (escaped)
+                    escaped = false;
+                else if (character === "\\")
+                    escaped = true;
+                else if (character === '"')
+                    inString = false;
+                continue;
+            }
+            if (character === '"')
+                inString = true;
+            else if (character === "{")
+                depth += 1;
+            else if (character === "}" && --depth === 0) {
+                try {
+                    const candidate = parse(trimmed.slice(start, index + 1));
+                    if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+                        balancedObjects.push(candidate);
+                }
+                catch {
+                    // Continue scanning for a later complete JSON object.
+                }
+                break;
+            }
+        }
+    }
+    const balancedContracts = balancedObjects.filter(isContract);
+    if (balancedContracts.length === 1)
+        return balancedContracts[0];
+    if (balancedObjects.length === 1)
+        return balancedObjects[0];
     const blocks = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)];
-    if (blocks.length !== 1)
+    if (blocks.length === 0)
         throw new Error("output must contain exactly one fenced json object");
-    return JSON.parse(blocks[0][1]);
+    const candidates = [];
+    for (const block of blocks) {
+        try {
+            const candidate = parse(block[1]);
+            if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+                candidates.push(candidate);
+        }
+        catch {
+            // Ignore incomplete model scratch blocks. A later complete contract
+            // block may still be deterministically recoverable.
+        }
+    }
+    const contractCandidates = candidates.filter(isContract);
+    if (contractCandidates.length === 1)
+        return contractCandidates[0];
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length === 0)
+        throw new Error("output must contain exactly one valid fenced json object (found 0)");
+    throw new Error(`output must contain exactly one valid frontend contract json object (found ${contractCandidates.length || candidates.length})`);
 }
 /**
  * Build the authoritative frontend-implementation-contract sourceBinding from

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -1,7 +1,8 @@
 import { readFile, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
-import { frontendImplementationContractSchema, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 async function selectNode(runDir, primary, fallbacks) {
@@ -46,7 +47,12 @@ function firstNonEmptyVerdictLine(text) {
     // The prompt requires VERDICT to be the first non-empty line, but model
     // output can still prepend a summary. Keep the protocol strict in the
     // prompt while making the deterministic gate resilient to that drift.
-    return normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
+    const verdictLine = normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
+    if (/^VERDICT:\s*pass(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
+        return "VERDICT: pass";
+    if (/^VERDICT:\s*request-revision(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
+        return "VERDICT: request-revision";
+    return verdictLine;
 }
 function eventArgs(event) {
     return event.args ?? event.toolInput ?? event.input ?? {};
@@ -155,13 +161,20 @@ export async function runFrontendPrewriteGate(input) {
     if (missingIds.length > 0) {
         throw new Error(`frontend prewrite gate missing requirement ids: ${missingIds.join(", ")}`);
     }
-    const artifact = await materializeFrontendImplementationContract({
+    const artifactPath = path.join(input.runDir, input.config.outputDir, input.config.artifactName);
+    const artifact = await stat(artifactPath)
+        .then(async () => ({
+        path: artifactPath,
+        schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        sha256: createHash("sha256").update(await readFile(artifactPath)).digest("hex"),
+    }))
+        .catch(() => materializeFrontendImplementationContract({
         runDir: input.runDir,
         fromNodeId: planNodeId,
         artifactName: input.config.artifactName,
         outputDir: input.config.outputDir,
         sourceBinding: input.sourceBinding,
-    });
+    }));
     const raw = JSON.parse(await readFile(artifact.path, "utf8"));
     const contract = frontendImplementationContractSchema.parse(raw);
     if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {
@@ -183,10 +196,11 @@ export async function runFrontendPrewriteGate(input) {
         reviewNodeId,
         repoRoot: workspaceRoot ?? process.cwd(),
     });
-    if (candidatePaths.length > 0 && openspecReadPaths.length === 0) {
-        const checkedNodes = [planNodeId, reviewNodeId].join(", ");
-        throw new Error(`openspec gate blocked: ${candidatePaths.length} candidate(s) [${candidatePaths.join(", ")}] not read by ${checkedNodes}; writer not authorized.`);
-    }
+    // OpenSpec is advisory design evidence, not an authorization boundary.
+    // Model read behavior is nondeterministic, and a missed read must not block
+    // a contract/schema/write-set-authorized implementation. Preserve any
+    // successful evidence for review context, while allowing unavailable
+    // evidence to be reported downstream.
     return {
         ok: true,
         planNodeId,

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()