@tea-agent/loop-agent 0.38.3 → 0.38.4

package/dist/worker/observe/static/views/session-timeline.js

@@ -250,6 +250,54 @@ export function buildSessionTimelineItems(events) {
 	return items;
 }
 
+/**
+ * Split a node's shared session-events log into per-attempt segments. Every
+ * attempt appends one agent run beginning with agent_start; events recorded
+ * before the first agent_start (defensive) stay in an implicit first segment.
+ */
+export function splitSessionEventsByAttempt(events) {
+	const segments = [];
+	let current = null;
+	for (const event of events) {
+		if (typeof event?.type === "string" && event.type === "agent_start") {
+			current = [];
+			segments.push(current);
+		}
+		if (current === null) {
+			current = [];
+			segments.push(current);
+		}
+		current.push(event);
+	}
+	return segments;
+}
+
+/**
+ * Resolve the events visible in the「执行过程」tab for the selected execution
+ * key. attempt-N shows only that attempt's segment when the shared log carries
+ * multiple attempts; other keys (pass-N, null) keep the full stream.
+ */
+export function resolveTimelineVisibleEvents(events, executionKey) {
+	const match =
+		typeof executionKey === "string"
+			? /^attempt-(\d+)$/.exec(executionKey)
+			: null;
+	if (!match) return { events, note: null };
+	const segments = splitSessionEventsByAttempt(events);
+	if (segments.length <= 1) return { events, note: null };
+	const requested = Number(match[1]);
+	if (requested >= 1 && requested <= segments.length) {
+		return {
+			events: segments[requested - 1],
+			note: `已按第 ${requested} 次执行过滤 · 共 ${segments.length} 次执行`,
+		};
+	}
+	return {
+		events,
+		note: `未检测到第 ${requested} 次执行的边界（共 ${segments.length} 次执行），暂显示全部事件`,
+	};
+}
+
 /**
  * Build rich timeline items: merge tool start/end by toolCallId, collapse
  * protocol noise, surface turn thinking/text without dumping agent_end.messages.
@@ -657,7 +705,7 @@ export async function mergeSessionEvents(dagRunId, nodeId) {
 	}
 }
 
-export function renderSessionTimeline(content, nodeId) {
+export function renderSessionTimeline(content, nodeId, options = {}) {
 	content.dataset.dagRunId = uiState.currentDagRunId ?? "";
 	content.dataset.nodeId = nodeId ?? "";
 	content.classList.add("process-timeline-scroll");
@@ -666,6 +714,14 @@ export function renderSessionTimeline(content, nodeId) {
 		return;
 	}
 
+	const visible = resolveTimelineVisibleEvents(
+		uiState.sessionEvents,
+		options.executionKey,
+	);
+	if (visible.note) {
+		content.appendChild(el("p", "process-timeline-note", visible.note));
+	}
+
 	const showProtocol = Boolean(uiState.sessionTimelineShowProtocol);
 	const toolbar = el("div", "process-timeline-toolbar");
 	const protocolToggle = document.createElement("button");
@@ -681,17 +737,17 @@ export function renderSessionTimeline(content, nodeId) {
 		const scrollTop = parent.scrollTop;
 		const scrollLeft = parent.scrollLeft;
 		while (parent.firstChild) parent.removeChild(parent.firstChild);
-		renderSessionTimeline(parent, nodeId);
+		renderSessionTimeline(parent, nodeId, options);
 		parent.scrollTop = scrollTop;
 		parent.scrollLeft = scrollLeft;
 	});
 	toolbar.appendChild(protocolToggle);
 	content.appendChild(toolbar);
 
-	const timelineItems = buildRichTimelineItems(uiState.sessionEvents, {
+	const timelineItems = buildRichTimelineItems(visible.events, {
 		showProtocol,
 	});
-	const hasEventTimes = uiState.sessionEvents.some((event) =>
+	const hasEventTimes = visible.events.some((event) =>
 		Boolean(sessionEventTimestamp(event)),
 	);
 	if (!hasEventTimes) {

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -1500,8 +1500,26 @@ print(json.dumps(out,ensure_ascii=True))
     // Windows Python may expose stdin as GBK; decoding generated Chinese/emoji
     // source through that locale can create surrogateescape code points and make
     // ast.parse fail with "surrogates not allowed".
-    const result = spawnSync("python", ["-c", program], { input: Buffer.from(source, "utf8"), encoding: "utf8", maxBuffer: 4 * 1024 * 1024, windowsHide: true });
-    if (result.status !== 0 || !result.stdout.trim())
+    // POSIX images usually expose only `python3` (modern macOS has no `python`);
+    // Windows often has a real `python` plus a Microsoft Store `python3` stub.
+    // A missing interpreter must not silently degrade to empty payload shapes.
+    const interpreterCandidates = process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+    let result;
+    for (const interpreter of interpreterCandidates) {
+        const attempt = spawnSync(interpreter, ["-c", program], {
+            input: Buffer.from(source, "utf8"),
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true,
+        });
+        // Interpreter missing/unspawnable → try the next candidate. A spawned
+        // interpreter that exits nonzero analyzed real input; do not retry then.
+        if (attempt.error)
+            continue;
+        result = attempt;
+        break;
+    }
+    if (!result || result.status !== 0 || !result.stdout.trim())
         return new Map();
     try {
         const parsed = JSON.parse(result.stdout);

package/dist/workflows/dag/failure-category.js

@@ -29,6 +29,7 @@ const RAW_TO_NORMALIZED = {
     "decision-envelope-invalid": "decision-envelope",
     "nonzero-exit": "shell-command",
     "spawn-error": "shell-command",
+    "test-timeout": "timeout",
     "static-error": "static-error",
     "invalid-output": "validation",
     "structured-output-truncated": "validation",
@@ -44,6 +45,13 @@ const RAW_TO_NORMALIZED = {
     quota: "executor",
     "rate-limit": "executor",
     unavailable: "executor",
+    // Deterministic capability/policy refusal: missing verified launcher JS
+    // entry, capability allowlist rejection, or missing bounded write tool
+    // profile. These are environment/config defects the operator repairs
+    // before rerunning; classify as executor so recovery recommends
+    // rerun-after-fix WITHOUT forcing a human-decision gate on
+    // standaloneTaskRerun (run-failed same-task rerun).
+    "tool-policy": "executor",
     unknown: "unknown",
 };
 function isFinishedStatus(status) {

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -1723,7 +1723,11 @@ async function dropUnresolvedVerificationSymbols(input) {
     return changed;
 }
 function extractSingleOpenspecCitationsBlock(text) {
-    const blocks = text.match(/```openspec-citations[ \t]*\r?\n[\s\S]*?\r?\n```/g) ?? [];
+    // Line-anchored so a directly closed empty fence (no candidate rows) still
+    // counts as the one required block instead of "found 0" retry loops.
+    const blocks = [
+        ...text.matchAll(/^```openspec-citations[ \t]*\r?\n([\s\S]*?)^```[ \t]*$/gim),
+    ].map((match) => match[0]);
     if (blocks.length !== 1) {
         throw new Error(`frontend plan patch output must include exactly one fenced openspec-citations block (found ${blocks.length})`);
     }

package/dist/workflows/dag/frontend-repair.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { z } from "zod";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
+import { FRONTEND_NO_VERIFICATION_MARKER_TEXT, FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE, } from "./frontend-verification-trace.js";
 export const FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID = "frontend-repair-assessment-v1";
 export const frontendRepairFailureClassSchema = z.enum([
     "typecheck",
@@ -82,6 +83,12 @@ export function classifyFrontendFailure(input) {
     if (input.failureCategory === "write-guard") {
         return "path";
     }
+    if (`${input.stderr ?? ""}\n${input.stdout ?? ""}`.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT)) {
+        // Verification unavailability is a generation-time contract gap: no
+        // authorized verification command exists. Bounded repair cannot fix it;
+        // the operator must declare commands and regenerate the DAG.
+        return "contract";
+    }
     if (input.traceTarget || input.commandCategory === "trace") {
         return "trace";
     }
@@ -424,6 +431,13 @@ export async function runFrontendFailureAssessGate(input) {
             : !baseEligible
                 ? `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`
                 : `missing structured evidence for failureClass=${failureClass} on ${primary.nodeId}`;
+        if (!eligible &&
+            `${primary.record.stderr ?? ""}`.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT)) {
+            // Surface the actionable unavailable-verification reason in the
+            // assessment (and the non-repairable gate error) instead of a
+            // generic class label.
+            reason = FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE;
+        }
     }
     // fixScope and changedPaths must stay inside the implement writeSet.
     if (evidence.fixScope?.length) {

package/dist/workflows/dag/frontend-risk.js

@@ -2,6 +2,12 @@
  * Deterministic frontend-implementation risk classifier (M4).
  * Pure function: no I/O, no model, no side effects.
  */
+/**
+ * Dependency-installation language in task text. Mentioning package.json or
+ * allowing its path is NOT dependency introduction by itself; the manifest
+ * path check in classifyFrontendRisk requires this language to escalate.
+ */
+const DEPENDENCY_INSTALL_LANGUAGE = /new\s+dependency|add\s+dependencies?|install\s+dependencies?|npm\s+(?:install|i)\b|yarn\s+(?:add|install)\b|pnpm\s+(?:add|install)\b|bun\s+(?:add|install)\b|新增依赖|添加依赖|安装依赖|引入依赖/i;
 const HIGH_RISK_PATTERNS = [
     {
         id: "new-route",
@@ -25,7 +31,7 @@ const HIGH_RISK_PATTERNS = [
     },
     {
         id: "new-dependency",
-        re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖|package\.json/i,
+        re: DEPENDENCY_INSTALL_LANGUAGE,
     },
     {
         id: "schema-api-change",
@@ -88,7 +94,14 @@ export function classifyFrontendRisk(input) {
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     if (paths.some((p) => /package\.json|pnpm-lock|yarn\.lock|package-lock/.test(p))) {
-        signals.push("new-dependency");
+        if (DEPENDENCY_INSTALL_LANGUAGE.test(blob)) {
+            signals.push("new-dependency");
+        }
+        else {
+            // Editing manifest scripts/config is not dependency introduction;
+            // record the rejected escalation instead of forcing full gates.
+            rejectedSignals.push("new-dependency:manifest-path-without-install-language");
+        }
     }
     // Explicit multi-domain language only — path count alone is not high-risk
     if (spread >= 3 &&

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

@@ -1,16 +1,19 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { isPlaywrightCliCommand } from "../../shared/playwright-cli-command-policy.js";
+import { isTruncatedFrontendAcId, isTruncatedWhenUndeclaredFrontendAcId, } from "./frontend-test-result-contract.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;
 /** Standalone blockedReason / environment tokens (not executable commands). */
-const BLOCKED_REASON_TOKEN = /^(?:playwright-cli-unavailable|frontend-base-url-unreachable|curl-unavailable|browser-command-capability-unavailable|browser-command-evidence-missing|token-budget-exhausted|current-user-data-unavailable|data-ownership-unverifiable|safe-test-data-setup-unavailable|invalid-evidence-shape)(?:\s|$|[.,;:)`'"\]])/i;
+const BLOCKED_REASON_TOKEN = /^(?:playwright-cli-unavailable|frontend-base-url-unreachable|curl-unavailable|browser-command-capability-unavailable|browser-command-evidence-missing|token-budget-exhausted|current-user-data-unavailable|data-ownership-unverifiable|safe-test-data-setup-unavailable|unique-control-unavailable|invalid-evidence-shape)(?:\s|$|[.,;:)`'"\]])/i;
 const BLOCKED_PROSE_HINT = /(?:blockedReason|blocked\s*reason|environmentProbe|evidenceDir|\bunavailable\b|不可用|写\s*blocked|写入\s*blocked|伪命令|自然语言|元数据|fail-closed|探测失败)/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]+)`[.!?]?$/;
+/** Assertion-count annotations appended to a playwright-cli literal (e.g. `find "锚点">=1`, `>=N`, `≥N`, `（≥1）`) document an expected match count; they are documentation, not shell arguments. */
+const ASSERTION_COUNT_SUFFIX = /\s*[（(]?\s*(?:>=|≥|>|超过|至少)\s*\d+\s*[）)]?\s*$/;
 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]*)/;
@@ -44,6 +47,11 @@ function isBlockedReason(value) {
         return true;
     if (/^blockedReason\s*[:=]/i.test(trimmed))
         return true;
+    // Expected-outcome field lines ("status=blocked" / "status: failed") document
+    // the intended terminal state of a designed-negative case; they are
+    // case-result metadata, never executable commands.
+    if (/^["'`]?status["'`]?\s*[:=]\s*["'`]?(passed|failed|blocked)["'`]?\s*[.。]?$/i.test(trimmed))
+        return true;
     return false;
 }
 /**
@@ -238,6 +246,12 @@ function commandGateIssue(input) {
     if (input.instruction.fromFence && isBlockedReason(input.instruction.command)) {
         return null;
     }
+    // An expected-match-count annotation (`find "锚点">=1`, with or without a
+    // playwright-cli prefix) documents the assertion; it is not part of the
+    // command and never executable input.
+    if (/^(?:playwright-cli\s+)?find\s+"[^"]*"/i.test(input.instruction.command) && ASSERTION_COUNT_SUFFIX.test(input.instruction.command)) {
+        return null;
+    }
     const commandMatch = input.instruction.command.match(/^playwright-cli\s+([^\s`]+)/i);
     if (commandMatch) {
         const command = commandMatch[1].toLowerCase().replace(/^[`'"]+|[`'":,，。→]+$/g, "");
@@ -282,7 +296,13 @@ export async function validateFrontendCaseChecklist(input) {
     const manifestPath = await exists(draft) ? draft : await exists(final) ? final : "";
     if (!manifestPath)
         throw new Error("checklist: missing manifest.draft.json or manifest.json");
-    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error("checklist: manifest is malformed JSON");
+    }
     if (!Array.isArray(manifest.cases) || manifest.cases.length === 0)
         throw new Error("checklist: empty cases");
     const declaredAc = new Set(input.declaredAcIds ?? []);
@@ -334,6 +354,10 @@ export async function validateFrontendCaseChecklist(input) {
             for (const ac of item.acIds) {
                 if (typeof ac !== "string" || !acIdRe.test(ac))
                     issues.push({ ruleId: "ac-id-shape", caseId: id, casePath, detail: String(ac) });
+                else if (declaredAc.size > 0 && isTruncatedFrontendAcId(ac))
+                    issues.push({ ruleId: "ac-id-truncated", caseId: id, casePath, detail: `${ac} is a truncated acceptance id (missing feature prefix or sequence number)` });
+                else if (declaredAc.size === 0 && isTruncatedWhenUndeclaredFrontendAcId(ac))
+                    issues.push({ ruleId: "ac-id-truncated", caseId: id, casePath, detail: `${ac} is a truncated acceptance id (missing feature prefix or sequence number)` });
                 else if (declaredAc.size > 0 && !declaredAc.has(ac))
                     issues.push({ ruleId: "unknown-ac", caseId: id, casePath, detail: `${ac} not in sourceBinding` });
             }

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

@@ -1,5 +1,6 @@
 import { readFile, rename, unlink, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { isTruncatedFrontendAcId, isTruncatedWhenUndeclaredFrontendAcId, } from "./frontend-test-result-contract.js";
 const DIMENSIONS = new Set(["core", "boundary", "flow", "backend"]);
 function fail(ruleId, detail) {
     const msg = JSON.stringify({ ruleId, detail: String(detail ?? "") });
@@ -62,6 +63,10 @@ export async function materializeFrontendTestCaseManifest(input) {
         for (const ac of c.acIds) {
             if (typeof ac !== "string" || !acIdRe.test(ac))
                 fail("ac-id-shape", `acIds entry must be AC-* acceptance id, not caseId: ${ac}`);
+            if ((declaredAc.size > 0
+                ? isTruncatedFrontendAcId(ac)
+                : isTruncatedWhenUndeclaredFrontendAcId(ac)))
+                fail("ac-id-truncated", `acIds entry is a truncated acceptance id (missing feature prefix or sequence number): ${ac}`);
             if (declaredAc.size > 0 && !declaredAc.has(ac))
                 fail("unknown-ac", `${ac} not in sourceBinding; repair generator input or AC list`);
             acIds.push(ac);

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

@@ -7,6 +7,25 @@ import { readPlaywrightCliReceipts, summarizePlaywrightCliReceipts, } from "../.
 import { validateFrontendCaseContent } from "./frontend-test-case-quality.js";
 import { markdownH1Title, markdownList, markdownSection, } from "./frontend-test-markdown.js";
 export const FRONTEND_TEST_RESULT_SCHEMA_ID = "frontend-test-result-v1";
+/**
+ * Truncated acceptance-id shapes observed in generator output: a bare
+ * numeric segment ("AC-002" dropped its AC-FE-<FEATURE> prefix) or an
+ * AC-FE-<FEATURE> literal without the trailing -NNN sequence number
+ * ("AC-FE-CHAT"). Generic short ids like "AC-1"/"AC-FE-001" stay valid;
+ * declared-source cross-checks (unknown-ac) remain the primary guard when a
+ * sourceBinding exists.
+ */
+export function isTruncatedFrontendAcId(acId) {
+    return /^AC-FE-[A-Z]+$/i.test(acId.trim());
+}
+/**
+ * Bare numeric ids ("AC-002") only indicate truncation when no declared AC
+ * list exists to adjudicate them: with a sourceBinding they are ordinary
+ * unknown-ac findings ("AC-999" may be a legitimately declared id style).
+ */
+export function isTruncatedWhenUndeclaredFrontendAcId(acId) {
+    return /^AC-\d{3}$/i.test(acId.trim()) || isTruncatedFrontendAcId(acId);
+}
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
     !path.win32.isAbsolute(value) &&
     !value.includes("\\") &&
@@ -57,6 +76,8 @@ export const frontendTestResultContractSchema = z.object({
         passed: z.number().int().min(0),
         failed: z.number().int().min(0),
         blocked: z.number().int().min(0),
+        /** Stability metric: passed on attempt 0 (no rerun/self-heal retry). */
+        firstTryPassed: z.number().int().min(0).optional(),
     }).strict(),
     acceptanceCoverage: z.object({
         covered: z.array(z.string().min(1)),
@@ -110,7 +131,13 @@ export async function validateFrontendCaseEvidence(input) {
     catch {
         throw new Error("missing testcase/frontend/cases/manifest.json");
     }
-    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error("invalid frontend case manifest: malformed JSON");
+    }
     if (!Array.isArray(manifest.cases))
         throw new Error("invalid frontend case manifest");
     const statuses = new Set(["passed", "failed", "blocked"]);
@@ -195,11 +222,17 @@ export function evaluatePassedCaseBrowserReceipts(summary, caseId) {
     }
     return { ok: true };
 }
-async function loadCaseBrowserReceiptSummary(input) {
+async function loadCaseBrowserReceiptsWithSummary(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.
+        // stitch receipts across DAG nodes or accept ambiguous duplicate
+        // authority — with one exception: bounded rerun creates a second,
+        // later stream for the same case (the rerun overwrites the disk
+        // case-result, so the final attempt is the authoritative one). When
+        // multiple streams authorize, prefer the highest rerun round
+        // (rerun-frontend-case-rN-<idx> directories); ties within the same
+        // round remain ambiguous and fail closed.
         const authorizingStreams = [];
         for (const entry of entries) {
             if (!entry.isDirectory())
@@ -207,17 +240,99 @@ async function loadCaseBrowserReceiptSummary(input) {
             const nodeReceipts = (await readPlaywrightCliReceipts(input.runDir, entry.name))
                 .filter((item) => item.caseId === input.caseId);
             const summary = summarizePlaywrightCliReceipts(nodeReceipts);
-            if (summary.hasOrderedPassedReceiptChain)
-                authorizingStreams.push(summary);
+            if (summary.hasOrderedPassedReceiptChain) {
+                const roundMatch = /rerun-frontend-case-r(\d+)-/i.exec(entry.name);
+                authorizingStreams.push({
+                    receipts: nodeReceipts,
+                    summary,
+                    round: roundMatch ? Number(roundMatch[1]) : 0,
+                });
+            }
+        }
+        if (authorizingStreams.length === 0) {
+            return { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
         }
-        return authorizingStreams.length === 1
-            ? authorizingStreams[0]
-            : summarizePlaywrightCliReceipts([]);
+        const maxRound = Math.max(...authorizingStreams.map((s) => s.round));
+        const finalists = authorizingStreams.filter((s) => s.round === maxRound);
+        return finalists.length === 1
+            ? finalists[0]
+            : { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
+    }
+    catch {
+        return { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
+    }
+}
+/**
+ * Extract `find "literal" >=N` / `find "literal"` declarations from a case
+ * document. Only quoted literals are binding assertions — the count suffix
+ * (`>=N`, `==N`) is the expected minimum/exact match count from the ledger.
+ * Placeholder literals ("...", "…", "<字面>", "eX") appear in prose discussing
+ * the syntax itself; they are documentation, never declarations.
+ */
+export function extractDeclaredFindAssertions(caseMarkdown) {
+    const source = stripFencedCodeBlocks(caseMarkdown);
+    const out = [];
+    const seen = new Set();
+    const pattern = /find\s+"((?:[^"\\]|\\.)+)"\s*(>=|==)\s*(\d+)/g;
+    const isPlaceholder = (literal) => /^(?:\.{2,}|…+|<[^>]*>|e\d+)$/.test(literal.trim());
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        const literal = match[1].replace(/\\(.)/g, "$1");
+        if (isPlaceholder(literal))
+            continue;
+        const operator = match[2];
+        const expected = Number(match[3]);
+        const key = `${operator}:${literal}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ literal, expected, operator });
+    }
+    return out;
+}
+function stripFencedCodeBlocks(markdown) {
+    return markdown.replace(/```[\s\S]*?```/g, "");
+}
+async function readCaseMarkdownForAudit(workspaceRoot, casePath) {
+    try {
+        return await readFile(path.join(workspaceRoot, casePath), "utf8");
     }
     catch {
-        return summarizePlaywrightCliReceipts([]);
+        return "";
     }
 }
+/**
+ * Controller-side assertion audit: every find-family declaration in the case
+ * document must be backed by a successful find receipt whose parsed match
+ * count satisfies the declared operator. This moves pass authority from
+ * "the model says it asserted" to "receipts prove it asserted".
+ */
+export function auditDeclaredFindAssertions(declared, receipts) {
+    if (declared.length === 0)
+        return { ok: true };
+    const successfulFinds = receipts.filter((receipt) => (receipt.command === "find" || receipt.command === "find-unique") &&
+        receipt.exitCode === 0 &&
+        !receipt.timedOut);
+    const missing = [];
+    for (const decl of declared) {
+        const backing = successfulFinds.some((receipt) => receipt.argsRedacted.some((arg) => arg === decl.literal || arg === `"${decl.literal}"`) &&
+            typeof receipt.matchCount === "number" &&
+            (decl.operator === ">="
+                ? receipt.matchCount >= decl.expected
+                : receipt.matchCount === decl.expected));
+        if (!backing) {
+            missing.push(`${decl.operator}${decl.expected} "${decl.literal.slice(0, 40)}"`);
+        }
+    }
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            reason: "assertion-not-receipt-backed",
+            missing,
+        };
+    }
+    return { ok: true };
+}
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
@@ -324,7 +439,13 @@ export async function materializeFrontendTestResult(input) {
     }
     const manifestPath = "testcase/frontend/cases/manifest.json";
     const manifestAbsolute = path.resolve(input.workspaceRoot, manifestPath);
-    const manifest = JSON.parse(await readFile(manifestAbsolute, "utf-8"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestAbsolute, "utf-8"));
+    }
+    catch {
+        throw new Error("invalid or empty frontend case manifest: malformed JSON");
+    }
     if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.cases) || manifest.cases.length === 0) {
         throw new Error("invalid or empty frontend case manifest");
     }
@@ -387,7 +508,7 @@ export async function materializeFrontendTestResult(input) {
             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({
+            const { receipts: caseReceipts, summary: receiptSummary } = await loadCaseBrowserReceiptsWithSummary({
                 runDir: input.runDir,
                 caseId: item.caseId,
             });
@@ -401,6 +522,24 @@ export async function materializeFrontendTestResult(input) {
                     detail: "passed case lacks controller-owned open + interaction/assertion + cleanup receipts",
                 });
             }
+            else {
+                // Controller-side assertion audit: every `find "literal" >=N` declared
+                // in the case document must be backed by a successful find receipt
+                // whose parsed matchCount satisfies the operator. Pass authority moves
+                // from model prose to receipt evidence.
+                const caseMarkdown = await readCaseMarkdownForAudit(input.workspaceRoot, item.casePath);
+                const declared = extractDeclaredFindAssertions(caseMarkdown);
+                const audit = auditDeclaredFindAssertions(declared, caseReceipts);
+                if (!audit.ok) {
+                    status = "blocked";
+                    blockedReason = audit.reason;
+                    advisoryFindings.push({
+                        ruleId: "assertion-not-receipt-backed",
+                        caseId: item.caseId,
+                        detail: `declared find assertions without receipt backing: ${audit.missing.join("; ")}`,
+                    });
+                }
+            }
         }
         const { caseContent, testPoints } = await readFrontendCaseContent(input.workspaceRoot, item.casePath);
         // Parse bounded fixed sections from execution.md. Missing optional
@@ -451,6 +590,7 @@ export async function materializeFrontendTestResult(input) {
         passed: cases.filter((item) => item.status === "passed").length,
         failed: cases.filter((item) => item.status === "failed").length,
         blocked: cases.filter((item) => item.status === "blocked").length,
+        firstTryPassed: cases.filter((item) => item.status === "passed" && !item.rerunAttempt).length,
     };
     const outcome = totals.failed > 0 ? "failed" : totals.blocked > 0 || missing.length > 0 ? "incomplete" : "passed";
     const result = frontendTestResultContractSchema.parse({

package/dist/workflows/dag/frontend-verification-trace.js

@@ -2,6 +2,18 @@ import { readFile, stat, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
 export const FRONTEND_VERIFICATION_TRACE_SCHEMA_ID = "frontend-verification-trace-v1";
+/**
+ * Shared marker for a project that exposes no usable verification command at
+ * generation time. The marker command runs (and logs not-run honestly), but it
+ * must never count as successful verification evidence: labels carrying this
+ * text are excluded from successful evidence and targets bound to it fail the
+ * trace gate instead of passing it.
+ */
+export const FRONTEND_NO_VERIFICATION_MARKER_TEXT = "No frontend verification command configured";
+export function isFrontendNoVerificationMarkerLabel(label) {
+    return label.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT);
+}
+export const FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE = `frontend verification unavailable: the only frozen static command is the no-op not-run marker (${FRONTEND_NO_VERIFICATION_MARKER_TEXT}); declare verification commands via task.json --verify or 执行约束.md and regenerate the DAG`;
 async function readJsonFile(filePath) {
     return JSON.parse(await readFile(filePath, "utf8"));
 }
@@ -52,7 +64,14 @@ export async function evaluateVerificationTargets(input) {
     const hardIssues = [];
     for (const target of input.contract.verificationTargets) {
         const issues = [];
-        const owners = input.labelOwners.get(target.commandLabel);
+        if (isFrontendNoVerificationMarkerLabel(target.commandLabel)) {
+            // A target bound to the not-run marker has no verification behind it;
+            // passing it would let the run finish green without any check.
+            issues.push(`${target.id}: ${FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE}`);
+        }
+        const owners = isFrontendNoVerificationMarkerLabel(target.commandLabel)
+            ? []
+            : (input.labelOwners.get(target.commandLabel) ?? []);
         if (!owners?.length) {
             issues.push(`commandLabel not executed in current-run frozen evidence: ${target.commandLabel}`);
         }
@@ -189,11 +208,17 @@ export async function runFrontendVerificationTraceGate(input) {
         throw new Error("trace: selected Mock strategy requires successful Mock verification commands");
     }
     if (input.evidence) {
-        if (input.evidence.static.commandLabels.length === 0) {
-            throw new Error("trace: no successful static verification commands in current run");
+        // The no-op not-run marker never counts as successful verification
+        // evidence, even if it executed with exit code 0.
+        const effectiveStaticLabels = input.evidence.static.commandLabels.filter((label) => !isFrontendNoVerificationMarkerLabel(label));
+        const effectiveBehaviorLabels = input.evidence.behavior.commandLabels.filter((label) => !isFrontendNoVerificationMarkerLabel(label));
+        if (effectiveStaticLabels.length === 0) {
+            throw new Error(input.evidence.static.commandLabels.length > 0
+                ? `trace: ${FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE}`
+                : "trace: no successful static verification commands in current run");
         }
         if (requiresBehaviorVerification &&
-            input.evidence.behavior.commandLabels.length === 0) {
+            effectiveBehaviorLabels.length === 0) {
             throw new Error("trace: no successful behavior verification commands in current run");
         }
     }