@tea-agent/loop-agent 0.43.0-next.8 → 0.43.0

package/dist/workflows/dag/frontend-session-budget.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readdir, rename, rm, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { readFrontendToolProgress } from "./frontend-durable-tools.js";
 import { frontendModelCapabilities } from "../../shared/frontend-execution-policy.js";
@@ -229,7 +229,7 @@ export async function observeFrontendSession(input, execute) {
     await waitForWrite(save());
     return result;
 }
-export function summarizeFrontendSessions(receipts) {
+function uniqueFrontendSessions(receipts) {
     const byId = new Map();
     for (const receipt of receipts) {
         const previous = byId.get(receipt.identity.sessionId);
@@ -240,10 +240,124 @@ export function summarizeFrontendSessions(receipts) {
         if (!previous || difference > 0)
             byId.set(receipt.identity.sessionId, receipt);
     }
-    const unique = [...byId.values()];
+    return [...byId.values()];
+}
+export function summarizeFrontendSessions(receipts) {
+    const unique = uniqueFrontendSessions(receipts);
     return { sessions: unique.length, failedSessions: unique.filter(r => r.terminal?.ok === false).length, incompleteSessions: unique.filter(r => r.completion === "incomplete").length,
         failureLayers: Object.fromEntries([...new Set(unique.flatMap(r => r.terminal && r.terminal.failureLayer !== "none" ? [r.terminal.failureLayer] : []))].sort().map(layer => [layer, unique.filter(r => r.terminal?.failureLayer === layer).length])),
         progress: Object.fromEntries(["durableCommittedDelta", "durableSubmissions", "durableReplacements", "failedRecords", "duplicateRecords", "successfulReadBytes", "duplicateReadBytes"].map(key => [key, sumKnown(unique.map(r => r.progress[key]))])),
         totalTokens: sumKnown(unique.flatMap(r => r.attempts.length ? r.attempts.map(a => a.actual?.totalTokens ?? null) : [r.actual.totalTokens])),
         sessionDurationSumMs: sumKnown(unique.map(r => r.terminal?.durationMs ?? null)) };
 }
+/** Read the persisted session receipts for one Plan node. This is deliberately
+ * an observation-only projection: missing or malformed receipts remain
+ * missing, never zero, so a canary cannot manufacture an improvement. */
+export async function readFrontendSessionBudgetReceipts(runDir, nodeId = "frontend-plan-pi") {
+    const root = path.join(runDir, nodeId);
+    const files = [];
+    const unreadable = [];
+    const visit = async (dir, insideBudget = false) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                unreadable.push(dir);
+            return;
+        }
+        for (const entry of entries) {
+            const absolute = path.join(dir, entry.name);
+            if (entry.isDirectory() && (insideBudget || entry.name === "session-budget" || entry.name === "parallel" || /^coverage-\d+$/.test(entry.name)))
+                await visit(absolute, insideBudget || entry.name === "session-budget");
+            else if (insideBudget)
+                files.push(absolute);
+        }
+    };
+    await visit(root);
+    const receipts = [];
+    for (const file of [...files, ...unreadable].sort()) {
+        try {
+            const value = JSON.parse(await readFile(file, "utf8"));
+            if (!isCanaryReceipt(value))
+                throw new Error("Invalid session receipt");
+            receipts.push(value);
+        }
+        catch {
+            // Keep a visible incomplete receipt so canary aggregation cannot turn a
+            // truncated artifact into an apparent zero-cost improvement.
+            receipts.push({
+                schemaVersion: 1,
+                policyVersion: "frontend-session-observation-v1",
+                identity: { sessionId: `invalid:${file}`, phase: "unknown", scopeIds: [], taskId: null, runId: null, nodeId, attempt: null, sourceDigest: null, contractDigest: null },
+                startedAt: new Date(0).toISOString(), finishedAt: null, completion: "incomplete",
+                planned: { prompt: { sha256: "", chars: 0, bytes: 0, estimatedTokens: 0 }, userMessage: { sha256: "", chars: 0, bytes: 0, estimatedTokens: 0 }, toolSchemas: null, estimatorVersion: "unknown", capabilities: { ...frontendModelCapabilities(undefined), model: null }, unmeasuredComponents: [] },
+                actual: { ...collectFrontendUsage([]) }, attempts: [],
+                progress: { memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
+            });
+        }
+    }
+    return receipts;
+}
+export function summarizeFrontendPlanCanary(receipts) {
+    const unique = uniqueFrontendSessions(receipts);
+    const complete = unique.length > 0 && unique.every(receipt => isCanaryReceipt(receipt) && receipt.completion === "complete");
+    const known = (values, sum) => {
+        if (!complete || values.length === 0)
+            return null;
+        const present = values.filter((value) => value !== null && value !== undefined);
+        return present.length === values.length ? sum(present) : null;
+    };
+    return {
+        planModelRequests: known(unique.map((receipt) => receipt.actual.requestCount), (items) => items.reduce((total, value) => total + value, 0)),
+        planSessions: complete ? unique.length : null,
+        // Receipt envelope includes gaps and overlapping sessions only once. The
+        // run reader below replaces this with the authoritative node interval.
+        planWallClockMs: complete ? Math.max(...unique.map(r => Date.parse(r.finishedAt))) - Math.min(...unique.map(r => Date.parse(r.startedAt))) : null,
+        planTokens: known(unique.map((receipt) => receipt.actual.totalTokens), (items) => items.reduce((total, value) => total + value, 0)),
+        toolRejections: known(unique.map((receipt) => receipt.progress.failedRecords), (items) => items.reduce((total, value) => total + value, 0)),
+        retries: complete ? unique.reduce((total, receipt) => total + Math.max(0, receipt.attempts.length - 1), 0) : null,
+    };
+}
+/** Validate the fields consumed by aggregation before accessing nested values.
+ * Valid JSON with the wrong shape is missing evidence too. */
+function isCanaryReceipt(value) {
+    const r = record(value), identity = record(r.identity), actual = record(r.actual), progress = record(r.progress);
+    const nullableCount = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && Number.isInteger(v) && v >= 0);
+    return r.schemaVersion === 1 && r.policyVersion === "frontend-session-observation-v1"
+        && typeof identity.sessionId === "string" && identity.sessionId.length > 0
+        && typeof r.startedAt === "string" && Number.isFinite(Date.parse(r.startedAt))
+        && (r.completion === "incomplete" || (r.completion === "complete" && typeof r.finishedAt === "string" && Date.parse(r.finishedAt) >= Date.parse(r.startedAt)))
+        && Array.isArray(r.attempts) && r.attempts.every(a => a !== null && typeof a === "object")
+        && nullableCount(actual.requestCount) && nullableCount(actual.totalTokens) && nullableCount(progress.failedRecords);
+}
+/** Read one frozen canary run. The optional artifact may add only run-level
+ * timing/review/recovery observations; Plan session counts, retries, tokens,
+ * request usage and tool rejections always come from session receipts. */
+export async function readFrontendPlanCanaryRunMetrics(runDir, nodeId = "frontend-plan-pi") {
+    const sessionMetrics = summarizeFrontendPlanCanary(await readFrontendSessionBudgetReceipts(runDir, nodeId));
+    let supplemental = {};
+    try {
+        const parsed = JSON.parse(await readFile(path.join(runDir, "frontend-plan-canary-metrics.json"), "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            supplemental = parsed;
+        }
+    }
+    catch {
+        // Missing or malformed supplemental evidence remains unavailable.
+    }
+    const optionalNumber = (key) => {
+        const value = supplemental[key];
+        return typeof value === "number" && Number.isFinite(value) && value >= 0
+            ? value
+            : null;
+    };
+    return {
+        ...sessionMetrics,
+        dagWallClockMs: optionalNumber("dagWallClockMs"),
+        designReviewRejectRate: optionalNumber("designReviewRejectRate"),
+        finalReviewDefectRate: optionalNumber("finalReviewDefectRate"),
+        recoveryCount: optionalNumber("recoveryCount"),
+    };
+}

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

@@ -9,6 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { collectFrontendSharedSignals, isNarrowProductSurface } from "./frontend-risk.js";
 /** Fixture-only node counts. They are NOT the authoritative 15/13/11
  * topology: split-required has no count. */
 export const FRONTEND_SHAPE_NODE_COUNTS = {
@@ -17,16 +18,6 @@ export const FRONTEND_SHAPE_NODE_COUNTS = {
     standard: 11,
     high: 11,
 };
-const SHAPE_ESCALATION_PATTERNS = [
-    { id: "auth-permission", re: /\bauth\b|\bpermission\b|\brbac\b|登录|权限|\bjwt\b|\bsession\b/i },
-    { id: "sensitive-action", re: /\bpayment\b|delete\s+account|支付|删除用户|\bdestructive\b/i },
-    { id: "ssr-boundary", re: /\bssr\b|\brsc\b|server\s+component|\bhydration\b|server-client/i },
-    { id: "new-route", re: /new\s+route|新增路由|createBrowserRouter|add\s+route/i },
-    { id: "shared-public-api", re: /public\s+api|shared\s+component|公共组件|破坏性|breaking\s+change/i },
-    { id: "schema-api-change", re: /\bopenapi\b|graphql\s+schema|api\s+contract|接口变更|schema\s+change/i },
-    { id: "new-dependency", re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖/i },
-    { id: "cross-domain-paths", re: /多个领域|cross-module|multiple\s+packages/i },
-];
 const SHAPE_SMALL_PATTERNS = [
     { id: "single-component", re: /single\s+component|单一组件|局部样式|style\s+tweak|css\s+only|文案|copy\s+change/i },
     { id: "no-remote", re: /no\s+api|无\s*api|无\s*接口|本地状态|local\s+state\s+only|pure\s+ui/i },
@@ -59,48 +50,13 @@ function pathSpreadScore(paths) {
     return tops.size;
 }
 function collectEscalationSignals(blob, supervised) {
-    const signals = [];
-    for (const pattern of SHAPE_ESCALATION_PATTERNS) {
-        if (hasAffirmativeShapeSignal(blob, pattern))
-            signals.push(pattern.id);
-    }
-    if (supervised)
-        signals.push("supervised-profile");
+    const signals = collectFrontendSharedSignals(blob, supervised);
     if (SHAPE_SPLIT_REQUIRED_PATTERN.test(blob) &&
         !SHAPE_SPLIT_REQUIRED_NEGATION.test(blob)) {
         signals.push("large-requirement-split");
     }
     return [...new Set(signals)];
 }
-function isExplicitShapeExclusion(clause, pattern) {
-    const match = new RegExp(pattern.re.source, "i").exec(clause);
-    if (!match)
-        return false;
-    const prefix = clause.slice(0, match.index).trim();
-    const suffix = clause.slice(match.index + match[0].length).trim();
-    const actionInSignal = ["new-route", "new-dependency"].includes(pattern.id);
-    if (suffix && !(actionInSignal && /^no$/i.test(prefix) && /^is\s+(?:required|needed)$/i.test(suffix)))
-        return false;
-    if (/^(?:不涉及|不(?:修改|变更|调整|改变|新增|添加)|无需(?:修改|变更|调整|改变|新增|添加)|no\s+changes?\s+to|(?:do\s+not|don't)\s+(?:change|modify))$/i.test(prefix))
-        return true;
-    return actionInSignal && /^(?:不|禁止|无需|无须|不需要|no|without|do\s+not|don't)$/i.test(prefix);
-}
-/** Only a complete, independent scope exclusion can suppress a risk signal.
- * Nested negation, conditions and trailing consequences remain risk evidence;
- * an excluded occurrence never cancels another occurrence elsewhere. */
-function hasAffirmativeShapeSignal(blob, pattern) {
-    for (const sentence of blob.split(/[\n。.;；!?！？]/)) {
-        if (!pattern.re.test(sentence))
-            continue;
-        // Commas can attach a condition to an exclusion. A comma-separated list
-        // is independent only when every item is itself an explicit exclusion.
-        const clauses = sentence.split(/[，,、]/).map(part => part.trim().replace(/^(?:[-*+]|\d+\))\s+/, ""));
-        if (clauses.every(clause => SHAPE_ESCALATION_PATTERNS.some(candidate => isExplicitShapeExclusion(clause, candidate))))
-            continue;
-        return true;
-    }
-    return false;
-}
 /** Negation applies to the API mention itself, never to unrelated Mock policy. */
 function hasFrontendRemoteSignal(blob) {
     const remaining = blob
@@ -126,7 +82,7 @@ function resolveBaselineFrontendTaskShape(input) {
     }
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
-    const concentrated = spread <= 1 && paths.length <= 4;
+    const concentrated = paths.length > 0 && spread <= 1 && paths.length <= 4;
     const hasApiSignal = hasFrontendRemoteSignal(blob);
     const complexity = (input.complexity ?? "").toLowerCase();
     // split-required wins over everything: it is a termination/escalation
@@ -172,17 +128,17 @@ function resolveBaselineFrontendTaskShape(input) {
             reason: "micro scope: trivial single-file change without remote API",
         };
     }
-    // small: no escalation, no supervised, small keywords, concentrated paths,
-    // no remote API signal.
-    if (smallHits.length > 0 &&
-        concentrated &&
-        !hasApiSignal &&
-        (complexity === "small" || complexity === "low")) {
+    // small: no escalation, no supervised, narrow single-domain delivery
+    // surface, no remote API signal, and not an explicitly large task. Keyword
+    // and explicit "small/low" complexity hints are no longer required — they
+    // were a fragile proxy for "this is genuinely a small change" and blocked
+    // genuinely-small tasks whose authors used different wording.
+    if (isNarrowProductSurface(paths) && !hasApiSignal && complexity !== "large") {
         return {
             shape: "small",
-            signals: smallHits,
+            signals: smallHits.length > 0 ? smallHits : ["structured-small"],
             rejectedSignals: [],
-            reason: `small signals without escalation: ${smallHits.join(", ")}`,
+            reason: "narrow single-domain delivery surface without remote API or escalation; small topology",
         };
     }
     const rejected = smallHits.map((id) => `small:${id}:blocked-by-${hasApiSignal ? "api-signal" : "path-spread"}`);

package/dist/workflows/dag/frontend-test-execution-evidence.js

@@ -1,21 +1,18 @@
 import path from "node:path";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
-/** Observe supported frozen Vitest commands without changing their selection. */
-export async function withFrontendTestReporter(input) {
-    // Compound commands/wrappers need their own adapter: never append flags to
-    // a different shell command, change selection, or override a user reporter.
-    if (/[;&|<>`\n\r$]/.test(input.command) || /--(?:reporter|outputFile)/.test(input.command))
-        return undefined;
-    const direct = /^(?:(?:npx|pnpm exec|yarn exec)\s+)?vitest\s+run(?:\s|$)/.test(input.command.trim());
-    const npm = /^npm\s+(?:run\s+([\w:-]+)|(test))(?=\s|$)(.*)$/.exec(input.command.trim());
+/** Decide whether a bare vitest/npm-test command is observable and, if so,
+ * return the command with the separator (" --") a reporter would need. */
+async function adaptPlainTestCommand(command, cwd) {
+    const direct = /^(?:(?:npx|pnpm exec|yarn exec)\s+)?vitest\s+run(?:\s|$)/.test(command.trim());
+    const npm = /^npm\s+(?:run\s+([\w:-]+)|(test))(?=\s|$)(.*)$/.exec(command.trim());
     let separator = "";
     if (!direct) {
         if (!npm)
             return undefined;
         let manifest;
         try {
-            manifest = JSON.parse(await readFile(path.join(input.cwd, "package.json"), "utf8"));
+            manifest = JSON.parse(await readFile(path.join(cwd, "package.json"), "utf8"));
         }
         catch {
             return undefined;
@@ -27,8 +24,36 @@ export async function withFrontendTestReporter(input) {
             return undefined;
         separator = npm[3]?.trim() ? "" : " --";
     }
+    return `${command}${separator}`;
+}
+/** Observe supported frozen Vitest commands without changing their selection. */
+export async function withFrontendTestReporter(input) {
+    // Compound commands/wrappers need their own adapter: never append flags to
+    // a different shell command, change selection, or override a user reporter.
+    if (/[;&|<>`\n\r$]/.test(input.command) || /--(?:reporter|outputFile)/.test(input.command))
+        return undefined;
+    // Frozen verify commands are env-prefixed bash wrappers —
+    // `HARNESS_ALLOW_ACTIVE_DAG_RUNS=1 'bash' '-lc' 'npm test'` — so the JSON
+    // reporter must be injected INSIDE the quoted payload; appending it to the
+    // wrapper would target bash's own CLI and produce no test report at all
+    // (smoke r54: every behavior verification target then failed the trace
+    // gate with "test execution report unavailable").
+    const bashWrapped = /^((?:[A-Za-z_][A-Za-z0-9_]*=(?:'[^']*'|[^\s'"]+)\s+)*)'bash'\s+'-lc'\s+'([^']*)'\s*$/.exec(input.command);
+    if (bashWrapped) {
+        const inner = bashWrapped[2];
+        if (/[;&|<>`\n\r$]/.test(inner) || /--(?:reporter|outputFile)/.test(inner))
+            return undefined;
+        const adaptedInner = await adaptPlainTestCommand(inner, input.cwd);
+        if (!adaptedInner)
+            return undefined;
+        const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
+        return input.command.replace(`'${inner}'`, `'${adaptedInner} --reporter=json --outputFile=${quote(input.reportPath)}'`);
+    }
+    const adapted = await adaptPlainTestCommand(input.command, input.cwd);
+    if (!adapted)
+        return undefined;
     const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
-    return `${input.command}${separator} --reporter=json --outputFile=${quote(input.reportPath)}`;
+    return `${adapted} --reporter=json --outputFile=${quote(input.reportPath)}`;
 }
 const resultSchema = z.object({
     testResults: z.array(z.object({

package/dist/workflows/dag/frontend-typed-event-store.js

@@ -31,18 +31,11 @@ export const TYPED_EVENT_FACT_KINDS = [
     "provider-ended-without-terminal",
     "read-only-fact-channel",
 ];
-/**
- * M2 shadow-only fact catalog (AC-001 shadow dual write). These facts are
- * audit-only observations derived from the authoritative text/JSON outputs of
- * the frontend-contract-pi / frontend-scout-pi / frontend-plan-pi nodes. They
- * are never branch-control signals and never participate in writer admission.
- *
- * Kept deliberately separate from `TYPED_EVENT_FACT_KINDS`: widening the shadow
- * catalog must never widen the provider capability matrix (which stays frozen
- * at its seven kinds). `target-surface` is shared by the scout and plan
- * origins, so the union of the two catalogs is 12 unique kinds.
- */
-export const SHADOW_FACT_KINDS = [
+/** Frontend DAG decision facts. These are committed runtime facts, not a
+ * secondary text channel; Policy, Admission and Plan compilation read them
+ * directly. Kept separate from provider capability facts so the provider
+ * matrix remains frozen. */
+export const FRONTEND_DAG_FACT_KINDS = [
     "requirement",
     "constraint",
     "open-question",
@@ -56,11 +49,26 @@ export const SHADOW_FACT_KINDS = [
     "design-deviation",
     "dependency",
 ];
+/** Experimental decision Plan fact catalog. The decision tools emit semantic
+ * decisions (module placement, reuse, state ownership, Mock boundary, behavior
+ * verification focus); `data-flow` and `dependency` reuse the DAG catalog above.
+ * Kept as a dedicated catalog so widening the decision surface never widens the
+ * frozen provider / event / review / design catalogs. */
+export const FRONTEND_DECISION_FACT_KINDS = [
+    "module-placement",
+    "reuse-decision",
+    "state-ownership",
+    "api-mock-boundary",
+    "verification-focus",
+];
+/** Terminal fact for the experimental decision Plan path. Kept separate from the
+ * decision fact catalog so it never gets collected as a decision entry. */
+export const DECISION_TERMINAL_FACT_KINDS = ["finalize_decision"];
 /**
  * M5 review terminal fact catalog (AC-001). These two committed typed tools are
  * the authoritative terminal verdict of `frontend-review-pi`. They are kept in
  * a dedicated catalog so widening the review terminal surface never widens the
- * frozen 7/7/12 provider/shadow/event catalogs.
+ * frozen provider/event catalogs.
  */
 export const REVIEW_TERMINAL_FACT_KINDS = [
     "approve_review",
@@ -72,7 +80,7 @@ export const REVIEW_TERMINAL_FACT_KINDS = [
  * `approve_design` / `request_design_changes` instead of the legacy first-line
  * `VERDICT: pass|request-revision` text protocol. Kept in a dedicated catalog
  * so widening the design terminal surface never widens the frozen provider /
- * shadow / event / review catalogs.
+ * event / review catalogs.
  */
 export const DESIGN_TERMINAL_FACT_KINDS = [
     "approve_design",
@@ -84,7 +92,7 @@ export const DESIGN_TERMINAL_FACT_KINDS = [
  * open-question/split-proposal facts plus the `contract-finalized` terminal
  * fact carrying the terminal disposition (`ready | ready-with-assumptions |
  * blocked` + optional `blockingOwner`). Kept in a dedicated catalog so
- * widening the contract surface never widens the frozen provider / shadow /
+ * widening the contract surface never widens the frozen provider /
  * event / review / design catalogs.
  */
 export const CONTRACT_FACT_KINDS = [
@@ -142,8 +150,8 @@ export const FRONTEND_ISSUE_CATEGORY_VALUES = [
 ];
 export const frontendIssueCategorySchema = z.enum(FRONTEND_ISSUE_CATEGORY_VALUES);
 /** Runtime control facts committed at frontend shape boundaries. Kept outside
- * the frozen provider/shadow catalogs so adding control authority cannot widen
- * either legacy capability surface. */
+ * the frozen provider catalog so adding control authority cannot widen that
+ * capability surface. */
 export const FRONTEND_SHAPE_FACT_KINDS = ["frontend-shape"];
 export const typedEventPhaseSchema = z.enum([
     "staged",
@@ -153,7 +161,9 @@ export const typedEventPhaseSchema = z.enum([
 const ALL_TYPED_EVENT_FACT_KIND_VALUES = [
     ...new Set([
         ...TYPED_EVENT_FACT_KINDS,
-        ...SHADOW_FACT_KINDS,
+        ...FRONTEND_DAG_FACT_KINDS,
+        ...FRONTEND_DECISION_FACT_KINDS,
+        ...DECISION_TERMINAL_FACT_KINDS,
         ...REVIEW_TERMINAL_FACT_KINDS,
         ...DESIGN_TERMINAL_FACT_KINDS,
         ...FRONTEND_SHAPE_FACT_KINDS,
@@ -166,7 +176,7 @@ const ALL_TYPED_EVENT_FACT_KIND_VALUES = [
 export const typedEventFactKindSchema = z.enum(ALL_TYPED_EVENT_FACT_KIND_VALUES);
 /** A typed event fact is a `kind`-discriminated record. The schema stays
  * permissive beyond `kind` (arbitrary JSON-safe payload) so provider/model
- * shadow facts can carry their own fields, but `kind` is always validated. */
+ * provider facts can carry their own fields, but `kind` is always validated. */
 export const typedEventFactSchema = z
     .record(z.unknown())
     .superRefine((value, ctx) => {
@@ -178,8 +188,7 @@ export const typedEventFactSchema = z
         });
     }
 });
-/** A single review finding shared by both typed terminal verdicts. Mirrors the
- * legacy JSON review finding shape so typed↔JSON equivalence stays total. */
+/** A single review finding shared by both typed terminal verdicts. */
 export const reviewFindingSchema = z
     .object({
     severity: z.enum(["Critical", "Important", "Minor", "Info"]),
@@ -190,8 +199,7 @@ export const reviewFindingSchema = z
 })
     .strict();
 /** `approve_review` terminal fact payload. Approval may carry informational
- * findings (Minor/Info) but never Critical/Important — the same rule the legacy
- * JSON verdict applies to `verdict: "pass"`. */
+ * findings (Minor/Info) but never Critical/Important. */
 export const approveReviewFactSchema = z
     .object({
     kind: z.literal("approve_review"),
@@ -221,8 +229,7 @@ export const requestReviewChangesFactSchema = z
 })
     .strict();
 /** `approve_design` terminal fact payload. Approval may carry informational
- * findings (Minor/Info) but never Critical/Important — the same rule the legacy
- * text protocol applies to `VERDICT: pass`. */
+ * findings (Minor/Info) but never Critical/Important. */
 export const approveDesignFactSchema = z
     .object({
     kind: z.literal("approve_design"),

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

@@ -170,6 +170,8 @@ export function extractFrontendTestTitles(content) {
     }
     for (let index = 0; index < tokens.length; index += 1) {
         const token = tokens[index];
+        if (token === undefined)
+            continue;
         if (token?.type !== "identifier" ||
             !["describe", "it", "test"].includes(token.value) ||
             (tokens[index - 1]?.type === "punctuation" &&
@@ -183,15 +185,16 @@ export function extractFrontendTestTitles(content) {
         while (tokens[cursor]?.type === "punctuation" &&
             tokens[cursor]?.value === "." &&
             tokens[cursor + 1]?.type === "identifier") {
-            if (tokens[cursor + 1]?.type === "identifier" &&
-                configurationModifiers.has(tokens[cursor + 1].value)) {
+            const modifier = tokens[cursor + 1];
+            if (modifier === undefined)
+                break;
+            if (configurationModifiers.has(modifier.value)) {
                 hasConfigurationModifier = true;
-                if (["runIf", "skipIf"].includes(tokens[cursor + 1].value)) {
-                    conditionalModifier = tokens[cursor + 1].value;
+                if (["runIf", "skipIf"].includes(modifier.value)) {
+                    conditionalModifier = modifier.value;
                 }
             }
-            if (tokens[cursor + 1]?.type === "identifier" &&
-                nonExecutingModifiers.has(tokens[cursor + 1].value)) {
+            if (nonExecutingModifiers.has(modifier.value)) {
                 hasNonExecutingModifier = true;
             }
             cursor += 2;
@@ -221,54 +224,23 @@ export function extractFrontendTestTitles(content) {
             index = closingParenIndex(cursor) ?? tokens.length;
             continue;
         }
-        if (tokens[cursor + 1]?.type !== "string")
+        const titleToken = tokens[cursor + 1];
+        if (titleToken?.type !== "string")
             continue;
-        titles.push(tokens[cursor + 1].value);
+        titles.push(titleToken.value);
     }
     return titles;
 }
-function traceKeyMatchesTitle(traceKey, title) {
-    const escaped = traceKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`(?:^|[^A-Za-z0-9_-])${escaped}(?:$|[^A-Za-z0-9_-])`).test(title);
-}
-function formatObservedTestTitles(titles) {
-    if (titles.length === 0)
-        return "(none)";
-    const limit = 8;
-    const preview = titles
-        .slice(0, limit)
-        .map((title) => title.length > 120 ? `${title.slice(0, 117)}...` : title)
-        .join(" | ");
-    return titles.length > limit
-        ? `${preview} | ... (${titles.length - limit} more)`
-        : preview;
-}
 async function evaluateTargetFileTrace(input) {
     const fileIssues = await assertFileAndSymbol({
         workspaceRoot: input.workspaceRoot,
         file: input.target.file,
     });
-    if (fileIssues.length || input.target.mode === "static") {
-        return { issues: fileIssues };
-    }
-    const absolute = path.resolve(input.workspaceRoot, input.target.file);
-    const content = await readFile(absolute, "utf8");
-    const observedTestTitles = extractFrontendTestTitles(content);
-    if (observedTestTitles.some((title) => traceKeyMatchesTitle(input.target.id, title))) {
-        return { issues: [], observedTestTitles };
-    }
-    const observed = formatObservedTestTitles(observedTestTitles);
-    return {
-        issues: [
-            `trace key not found in test title: ${input.target.id} in ${input.target.file}; observed test titles: ${observed}`,
-        ],
-        observedTestTitles,
-    };
+    return { issues: fileIssues };
 }
 /**
- * Lightweight writer-boundary check. It validates file existence and stable
- * behavior trace tokens only; frozen commands remain the final trace gate's
- * responsibility after command execution.
+ * Lightweight writer-boundary check. It validates declared file existence;
+ * frozen commands remain the final trace gate's responsibility after execution.
  */
 export async function evaluateFrontendWriterTracePreflight(input) {
     const targets = [];
@@ -287,8 +259,9 @@ export async function evaluateFrontendWriterTracePreflight(input) {
             commandLabel: target.commandLabel,
             file: target.file,
             ...(target.symbol ? { symbol: target.symbol } : {}),
-            ...(target.mode !== "static" ? { traceKey: target.id } : {}),
             status: fileTrace.issues.length ? "failed" : "ok",
+            evidence: fileTrace.issues.length ? "unavailable" : "file-exists",
+            behaviorCoverage: "unconfirmed",
             matchedNodeIds: [],
             issues: fileTrace.issues,
         });
@@ -298,8 +271,8 @@ export async function evaluateFrontendWriterTracePreflight(input) {
 /**
  * Pure verification-target evaluation shared by the trace gate and the repair
  * assess gate. It derives, for each contract verification target, whether the
- * target bound to frozen evidence (commandLabel owners), and whether the file
- * and stable behavior-target id exist in a real test title. It performs no
+ * target bound to frozen evidence (commandLabel owners), whether its file exists,
+ * and whether the declared test file was exercised by the observed runner. It performs no
  * writes and throws nothing: failures are returned as `hardIssues` plus
  * per-target `status`.
  */
@@ -325,10 +298,13 @@ export async function evaluateVerificationTargets(input) {
         });
         issues.push(...fileTrace.issues);
         const executed = input.executedTests?.get(target.commandLabel);
-        if (target.mode !== "static" && executed !== undefined) {
+        if (target.mode !== "static" && executed === undefined) {
+            issues.push(`test execution report unavailable for behavior target: ${target.id}`);
+        }
+        else if (target.mode !== "static" && executed !== undefined) {
             // safePath permits "./" prefixes; reporter files are cwd-relative.
             const targetFile = path.posix.normalize(target.file.replace(/\\/g, "/"));
-            const matching = executed.filter((test) => test.file === targetFile && traceKeyMatchesTitle(target.id, test.title));
+            const matching = executed.filter((test) => test.file === targetFile);
             if (matching.length === 0 || matching.some((test) => test.status !== "passed")) {
                 issues.push(`behavior target was not fully executed and passed: ${target.id} in ${target.file}`);
             }
@@ -342,8 +318,11 @@ export async function evaluateVerificationTargets(input) {
             commandLabel: target.commandLabel,
             file: target.file,
             symbol: target.symbol,
-            ...(target.mode !== "static" ? { traceKey: target.id } : {}),
             status,
+            evidence: issues.length
+                ? "unavailable"
+                : target.mode === "static" ? "command-execution" : "test-file-execution",
+            behaviorCoverage: "unconfirmed",
             matchedNodeIds: owners ?? [],
             issues,
         });
@@ -353,16 +332,16 @@ export async function evaluateVerificationTargets(input) {
 /**
  * Legacy deterministic symbol resolvability check retained by canonical
  * normalization (`dropUnresolvedVerificationSymbols`). New plan tools do not
- * expose symbol and runtime trace binding uses the stable target id. This
+ * expose symbol and runtime trace binding uses the command and test file. This
  * helper still handles old `all describe blocks`, `describe('title')`, and
  * slash-delimited labels so existing run artifacts normalize consistently.
  */
 export function verificationSymbolMatchesContent(symbol, content) {
     if (symbol.trim().toLowerCase() === "all describe blocks")
         return content.includes("describe(");
+    const separatorHead = symbol.split(/[（(]/, 1)[0];
     const symbols = symbol.includes(" / ")
-        ? symbol
-            .split(/[（(]/, 1)[0]
+        ? (separatorHead ?? symbol)
             .split("/")
             .map((item) => item.trim())
             .filter(Boolean)
@@ -462,7 +441,7 @@ export async function runFrontendVerificationTraceGate(input) {
     const mockCommandLabels = input.evidence?.mock?.commandLabels ?? [];
     const mockCommandNodeId = input.evidence?.mock?.nodeId;
     const mockCommandTexts = input.evidence?.mock?.commandTexts ?? [];
-    if (input.evidence && contract.mockApi.strategy !== "not-needed" && mockCommandLabels.length === 0) {
+    if (input.evidence && contract.verificationTargets.some((target) => target.mode === "behavior") && contract.mockApi.strategy !== "not-needed" && mockCommandLabels.length === 0) {
         throw new Error("trace: selected Mock strategy requires successful Mock verification commands");
     }
     if (input.evidence) {
@@ -550,7 +529,7 @@ export function formatFrontendVerificationTraceStdout(result) {
         `Browser: ${result.browserStatus}`,
         `Visual: ${result.visualStatus}`,
         `Targets: ${result.targets.length}`,
-        ...result.targets.map((target) => `- ${target.id}: ${target.status} label=${JSON.stringify(target.commandLabel)} file=${target.file}`),
+        ...result.targets.map((target) => `- ${target.id}: execution=${target.status} evidence=${target.evidence} behavior-coverage=${target.behaviorCoverage} label=${JSON.stringify(target.commandLabel)} file=${target.file}`),
     ];
     if (result.artifactPath) {
         lines.push(`Artifact: ${result.artifactPath}`);