@tea-agent/loop-agent 0.42.0-next.14 → 0.42.0-next.16

package/dist/workflows/dag/frontend-design-policy.js

@@ -28,31 +28,37 @@ function sortFindings(findings) {
  * visual UI-state dimension (it cannot cover behavioural interactions). */
 export function checkUiDesignCoverage(contract) {
     const findings = [];
-    const purposes = new Set((contract.uiComponentChoices ?? []).map((choice) => choice.purpose));
-    const hasStyling = Boolean(contract.stylingStrategy?.trim());
-    // Reuse of an existing component/pattern covers behavioural interactions
-    // without forcing one uiComponentChoices row per interaction: the model
-    // should not enumerate every click/hover on a reused Button. Only
-    // interactions with no reuse and no explicit purpose are flagged.
-    const hasReuseChoice = (contract.uiComponentChoices ?? []).some((choice) => choice.decision === "reuse-existing");
+    // Explicit per-id coverage (dogfood r-plan-quality): one choice covers an
+    // interaction/state when its purpose equals the name OR the choice lists
+    // the name in covers. The old wildcards are gone — a single reuse-existing
+    // row no longer passes every interaction, and a non-empty stylingStrategy
+    // no longer passes every state.
+    const covered = new Set();
+    for (const choice of contract.uiComponentChoices ?? []) {
+        if (choice.purpose.trim())
+            covered.add(choice.purpose);
+        for (const id of choice.covers ?? []) {
+            if (id.trim())
+                covered.add(id);
+        }
+    }
     for (const state of contract.uiStates) {
         if (!state.applicable)
             continue;
-        const covered = purposes.has(state.name) || hasStyling;
-        if (!covered) {
+        if (!covered.has(state.name)) {
             findings.push({
                 code: "ui-design-coverage-missing",
-                message: `applicable UI state "${state.name}" has no matching uiComponentChoices.purpose or stylingStrategy`,
+                message: `applicable UI state "${state.name}" is not covered by any uiComponentChoices purpose or covers entry`,
                 path: state.name,
             });
         }
     }
     for (const interaction of contract.interactions) {
-        if (purposes.has(interaction.name) || hasReuseChoice)
+        if (covered.has(interaction.name))
             continue;
         findings.push({
             code: "ui-design-coverage-missing",
-            message: `interaction "${interaction.name}" has no matching uiComponentChoices.purpose and no reuse-existing choice covering it`,
+            message: `interaction "${interaction.name}" is not covered by any uiComponentChoices purpose or covers entry`,
             path: interaction.name,
         });
     }
@@ -158,7 +164,7 @@ export function checkMockStrategy(contract, allowedMockStrategies) {
  * A component specReference must still not point into clearly non-component
  * spec areas — templates and the ai_workspace governance subtree cannot be the
  * authoritative component definition. */
-export function checkComponentChoice(contract, componentSpecCandidatePaths) {
+export function checkComponentChoice(contract, componentSpecCandidatePaths, options) {
     const findings = [];
     const candidates = new Set(componentSpecCandidatePaths.map(normalizeRelativePath));
     const isNonComponentSpecArea = (path) => {
@@ -200,6 +206,23 @@ export function checkComponentChoice(contract, componentSpecCandidatePaths) {
                 });
             }
         }
+        else if (choice.decision === "reuse-existing") {
+            if (!(choice.evidencePath && choice.evidencePath.trim().length > 0)) {
+                findings.push({
+                    code: "component-reuse-evidence-missing",
+                    message: `reuse-existing component choice #${index} is missing evidencePath naming the existing repo file that proves the reuse; a greenfield path must use decision=new`,
+                    path: choice.purpose,
+                });
+            }
+            else if (options?.hasFreshPathEvidence &&
+                !options.hasFreshPathEvidence(choice.evidencePath)) {
+                findings.push({
+                    code: "component-reuse-path-not-fresh",
+                    message: `reuse-existing component choice #${index} evidencePath "${choice.evidencePath}" has no fresh existence evidence (path not found); reuse requires an existing file — use decision=new for greenfield paths`,
+                    path: choice.evidencePath,
+                });
+            }
+        }
         else if (choice.decision === "new") {
             if (!choice.specReference || !choice.specReference.path) {
                 findings.push({
@@ -236,7 +259,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
     if (contract.targets.files.length > MAX_WRITE_SET_FILES) {
         findings.push({
             code: "write-set-too-large",
-            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task (record_split_proposal) so no single implement node exceeds the bound`,
+            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task at the Contract boundary so no single implement node exceeds the bound; preserve all required files`,
         });
     }
     for (const file of contract.targets.files) {
@@ -371,6 +394,64 @@ export function checkDesignApproval(designApproval) {
     }
     return [];
 }
+/**
+ * UX vocabulary collisions (item ③, dogfood dag-1788504923861-0f7b17a9):
+ * prioritize-planner-task / prioritizePlannerTask / prioritize-planner-tasks
+ * are one behavior renamed three ways. Case/separator-insensitive duplicates
+ * inside interactions or inside uiStates are blocking.
+ */
+export function checkUxNameCollisions(contract) {
+    const findings = [];
+    const normalize = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const collisions = (names, kind) => {
+        const byNormalized = new Map();
+        const found = [];
+        for (const name of names) {
+            const key = normalize(name);
+            if (!key)
+                continue;
+            const existing = byNormalized.get(key);
+            if (existing !== undefined && existing !== name) {
+                found.push({
+                    code: "ux-name-collision",
+                    message: `"${name}" and "${existing}" are the same ${kind} name up to case/separator — one behavior must keep one stable name`,
+                    path: name,
+                });
+            }
+            else {
+                byNormalized.set(key, name);
+            }
+        }
+        return found;
+    };
+    findings.push(...collisions(contract.interactions.map((interaction) => interaction.name), "interaction"));
+    findings.push(...collisions(contract.uiStates.map((state) => state.name), "UI state"));
+    return findings;
+}
+/**
+ * Deliverable completeness (item ⑦): every file explicitly declared by Contract
+ * from frozen source fragments (projected into targets.requiredDeliverables)
+ * must be planned — bound by some requirement's implementationTargets or a
+ * verification target's file, or listed in targets.files. allowedPaths is a
+ * write boundary and never implies coverage.
+ */
+export function checkRequiredDeliverables(contract) {
+    const required = contract.targets.requiredDeliverables ?? [];
+    if (required.length === 0)
+        return [];
+    const planned = new Set([
+        ...contract.targets.files,
+        ...contract.requirements.flatMap((requirement) => requirement.implementationTargets),
+        ...contract.verificationTargets.map((target) => target.file),
+    ]);
+    return required
+        .filter((path) => !planned.has(path))
+        .map((path) => ({
+        code: "required-deliverable-unplanned",
+        message: `Contract declares required deliverable "${path}" but no requirement implementationTarget, verification target, or targets.files entry plans it`,
+        path,
+    }));
+}
 /** Aggregate the deterministic design-policy checks into a single
  * deterministic result. Any finding blocks; an empty finding list approves. */
 export function evaluateFrontendDesignPolicy(input) {
@@ -379,10 +460,14 @@ export function evaluateFrontendDesignPolicy(input) {
         ...checkUiDesignCoverage(input.contract),
         ...checkSourceFreshness(input.contract, input.sourceFreshness),
         ...checkMockStrategy(input.contract, input.allowedMockStrategies),
-        ...checkComponentChoice(input.contract, input.componentSpecCandidatePaths),
+        ...checkComponentChoice(input.contract, input.componentSpecCandidatePaths, input.hasFreshPathEvidence
+            ? { hasFreshPathEvidence: input.hasFreshPathEvidence }
+            : undefined),
         ...checkTargetPaths(input.contract, input.writeSetPatterns),
         ...checkDependencies(input.contract, input.allowedDependencies),
         ...checkUiStateAttribution(input.contract),
+        ...checkUxNameCollisions(input.contract),
+        ...checkRequiredDeliverables(input.contract),
     ]);
     const classification = findings.length > 0 ? "blocked" : "approved";
     const result = {

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

@@ -9,10 +9,12 @@ import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
+import { extractRequiredDeliverablePaths } from "./frontend-contract-facts.js";
+export { extractRequiredDeliverablePaths } from "./frontend-contract-facts.js";
 // Cycle-safe value imports: the check functions are hoisted declarations used
 // only at call time, so the contract module and the policy module can depend
 // on each other without module-init ordering issues.
-import { checkDependencies, checkTargetPaths, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
+import { checkDependencies, checkTargetPaths, checkUiDesignCoverage, checkUiStateAttribution, checkRequiredDeliverables, checkUxNameCollisions, } from "./frontend-design-policy.js";
 import { isDagSourceBindingV2 } from "./types.js";
 import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, persistRuntimeSkeleton, } from "./structured-output-repair.js";
 import { renderFrontendPlanMarkdown } from "./frontend-plan-render.js";
@@ -600,12 +602,30 @@ const uiComponentChoiceSchema = z
     decision: z.enum(["specified", "reuse-existing", "new"]),
     specReference: uiComponentSpecReferenceSchema.nullable().optional(),
     // Optional: the decision enum already carries the semantic (specified →
-    // specReference, new → task-source traceability, reuse-existing → no
-    // rationale needed).
-    // Omit for reuse-existing to keep plan output small.
+    // specReference, new → task-source traceability, reuse-existing →
+    // evidencePath). Omit for reuse-existing to keep plan output small.
     rationale: z.string().min(1).optional(),
+    // Multi-id coverage (dogfood r-plan-quality): ONE choice may cover many
+    // UI states/interactions explicitly instead of the old implicit
+    // "reuse-existing covers everything" wildcard.
+    covers: z.array(z.string().min(1)).optional(),
+    // reuse-existing evidence (dogfood dag-1788504923861-0f7b17a9: 18
+    // reuse-existing rows cited conventions in a not-yet-written
+    // src/planner.ts): a repo-relative path to the existing file that
+    // proves the reuse. Enforced by superRefine + fresh-existence checks.
+    evidencePath: safePath.optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((choice, ctx) => {
+    if (choice.decision === "reuse-existing" &&
+        !(choice.evidencePath && choice.evidencePath.trim().length > 0)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["evidencePath"],
+            message: "decision=reuse-existing requires evidencePath naming the existing repo file that proves the reuse; use decision=new for greenfield paths",
+        });
+    }
+});
 const uiComponentChoicesSchema = z.array(uiComponentChoiceSchema);
 /**
  * Normalize unstable model emissions before the strict schema sees them:
@@ -680,6 +700,11 @@ export const frontendImplementationContractSchema = z
         files: z.array(safePath).min(1),
         routes: z.array(z.string().startsWith("/")).optional(),
         publicApiChanges: z.array(z.string().min(1)).optional(),
+        // Runtime-owned deliverable contract (dogfood r-plan-quality):
+        // explicit, source-bound file inventory committed by Contract.
+        // The design-policy completeness gate checks ONLY these —
+        // allowedPaths is a write boundary, not a coverage obligation.
+        requiredDeliverables: z.array(safePath).optional(),
     })
         .strict(),
     requirements: z.array(z
@@ -1634,7 +1659,12 @@ export function compactFrontendImplementationContract(value) {
     const targets = asRecord(record.targets);
     if (targets) {
         const compactTargets = { ...targets };
-        for (const field of ["files", "routes", "publicApiChanges"]) {
+        for (const field of [
+            "files",
+            "routes",
+            "publicApiChanges",
+            "requiredDeliverables",
+        ]) {
             if (Object.hasOwn(compactTargets, field)) {
                 compactTargets[field] = dedupeJsonArray(compactTargets[field]);
             }
@@ -2425,6 +2455,16 @@ export async function analyzeFrontendImplementationContract(input) {
             files: referencedConcretePaths,
         };
     }
+    // Both Plan precheck and policy materialization consume this exact inventory.
+    // Never trust a Plan patch or infer delivery obligations from prose.
+    const contractRecords = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.contractNodeId ?? "frontend-contract-pi", "contract-typed-facts.jsonl"));
+    const requiredDeliverables = extractRequiredDeliverablePaths(contractRecords
+        .filter((record) => record.phase === "committed")
+        .map((record) => record.fact));
+    delete result.data.targets.requiredDeliverables;
+    if (requiredDeliverables.length > 0) {
+        result.data.targets.requiredDeliverables = requiredDeliverables;
+    }
     const blockingGaps = [
         ...(result.data.evidenceGaps ?? []),
         ...result.data.requirements.flatMap((item) => item.evidenceGap ? [item.evidenceGap] : []),
@@ -2632,6 +2672,7 @@ const FRONTEND_PLAN_PATCH_PROTECTED_PATHS = [
     "/sourceBinding",
     "/riskLevel",
     "/targets/files",
+    "/targets/requiredDeliverables",
     "/mockApi/productionDefaultOff",
 ];
 const PLAN_LEDGER_FACT_KINDS_FOR_COMPILE = [
@@ -2680,6 +2721,8 @@ function frontendPlanPatchProtectedPathViolations(patch) {
     const targets = asRecord(record.targets);
     if (targets && Object.hasOwn(targets, "files"))
         violations.push("/targets/files");
+    if (targets && Object.hasOwn(targets, "requiredDeliverables"))
+        violations.push("/targets/requiredDeliverables");
     const mockApi = asRecord(record.mockApi);
     if (mockApi && Object.hasOwn(mockApi, "productionDefaultOff"))
         violations.push("/mockApi/productionDefaultOff");
@@ -2864,6 +2907,8 @@ export async function analyzeFrontendPlanPatchCandidate(input) {
     const policyPreFindings = [
         ...checkUiDesignCoverage(analysis.canonical),
         ...checkUiStateAttribution(analysis.canonical),
+        ...checkRequiredDeliverables(analysis.canonical),
+        ...checkUxNameCollisions(analysis.canonical),
         ...checkDependencies(analysis.canonical, await deriveAllowedDependenciesFromRun(input.runDir)),
         ...checkTargetPaths(analysis.canonical, await deriveWriteSetFromRun(input.runDir)),
     ];
@@ -3082,9 +3127,11 @@ export async function buildContractFromCommittedFacts(input) {
     }
     // b. Committed contract terminal fact (contract-finalized).
     const contractRecords = await readTypedEventStoreFromJsonl(path.join(input.runDir, contractNodeId, "contract-typed-facts.jsonl"));
-    const contractKinds = new Set(contractRecords
+    const committedContractFacts = contractRecords
         .filter((record) => record.phase === "committed")
-        .map((record) => record.fact.kind)
+        .map((record) => record.fact);
+    const contractKinds = new Set(committedContractFacts
+        .map((fact) => fact?.kind)
         .filter((kind) => typeof kind === "string"));
     if (!contractKinds.has("contract-finalized")) {
         return {
@@ -3139,6 +3186,7 @@ export async function buildContractFromCommittedFacts(input) {
             runDir: input.runDir,
             rawContractText: serializeDeterministicJson(merged),
             sourceBinding: input.sourceBinding,
+            contractNodeId,
         });
         return {
             ok: true,

package/dist/workflows/dag/frontend-plan-render.js

@@ -12,8 +12,19 @@ function bulletList(items) {
         return "";
     return items.map((item) => `- ${item}`).join("\n");
 }
+/** The runtime's deterministic fallback for an outcome the plan did not
+ * author. It is bookkeeping for the schema's non-empty constraint, not user
+ * prose — the renderer must never present it as requirement content. */
+const IMPLIED_OUTCOME_PREFIX = "implied by contract:";
 function requirementsCoverage(contract) {
-    const lines = contract.requirements.map((requirement) => `- ${requirement.id}: ${requirement.expectedOutcome}`);
+    const lines = contract.requirements.map((requirement) => {
+        const targets = requirement.implementationTargets.join(", ");
+        const verificationTargets = requirement.verificationTargetIds.join(", ");
+        const authoredOutcome = requirement.expectedOutcome.startsWith(IMPLIED_OUTCOME_PREFIX)
+            ? ""
+            : ` — ${requirement.expectedOutcome}`;
+        return `- ${requirement.id} → ${targets || "(no targets)"} [${verificationTargets || "no VT"}]${authoredOutcome}`;
+    });
     return lines.length > 0 ? lines.join("\n") : "_(no requirements)_";
 }
 function uiStateHandling(contract) {
@@ -98,7 +109,7 @@ export function renderFrontendPlanMarkdown(contract) {
         interactionNotes(contract),
         "",
         "## Mock & API Strategy",
-        contract.mockApi.strategy,
+        contract.mockApi?.strategy || "_(not specified)_",
         "",
         "## Dependency Policy",
         contract.dependencyPolicy || "_(not specified)_",

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

@@ -70,8 +70,10 @@ function blobOf(input) {
     ].join("\n");
 }
 function pathSpreadScore(paths) {
+    const auxiliaryRoot = /^(?:test|tests|__tests__|e2e|cypress|spec|specs|docs|documentation)$/i;
     const tops = new Set(paths
         .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter((root) => !auxiliaryRoot.test(root))
         .filter(Boolean));
     return tops.size;
 }

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -226,6 +226,7 @@ export function parseTargetSurfaceFacts(text) {
 }
 export const PLAN_LEDGER_FACT_KINDS = [
     "target-surface",
+    "state-registry",
     "component-choice",
     "state-flow",
     "data-flow",
@@ -484,7 +485,22 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
     }
     const verificationTargets = verificationTargetOrder
         .map((id) => verificationTargetById.get(id))
-        .filter((entry) => Boolean(entry));
+        .filter((entry) => Boolean(entry))
+        .map((entry) => {
+        // Coverage precedes UX. A later state-flow fact explicitly naming
+        // this VT establishes the reverse binding without another model call.
+        // No path/name heuristics: unbound or ambiguous decisions stay subject
+        // to canonical validation. Recompute from live states after removals.
+        const boundStates = [...stateByName.values()]
+            .filter((state) => state.applicable === true &&
+            asStringArray(state.verificationTargetIds).includes(asString(entry.id)))
+            .map((state) => asString(state.name));
+        if (boundStates.length === 0)
+            return entry;
+        return { ...entry, uiStates: [...new Set([
+                    ...asStringArray(entry.uiStates), ...boundStates,
+                ])].sort() };
+    });
     if (verificationTargets.length > 0) {
         patch.verificationTargets = verificationTargets;
     }

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

@@ -46,8 +46,15 @@ const EXECUTABLE_SHAPE_RANK = {
     high: 3,
 };
 function pathSpreadScore(paths) {
+    // Verification-only roots are routinely authorized together with the
+    // implementation root (for example `src/**` + `test/**`). They do not make
+    // a UI change cross-domain, so exclude them from the topology spread signal.
+    // Keep product packages and source roots intact: `apps/**` + `packages/**`
+    // must still count as a real spread and prevent an unsafe small topology.
+    const auxiliaryRoot = /^(?:test|tests|__tests__|e2e|cypress|spec|specs|docs|documentation)$/i;
     const tops = new Set(paths
         .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter((root) => !auxiliaryRoot.test(root))
         .filter(Boolean));
     return tops.size;
 }
@@ -65,6 +72,13 @@ function collectEscalationSignals(blob, supervised) {
     }
     return [...new Set(signals)];
 }
+/** Negation applies to the API mention itself, never to unrelated Mock policy. */
+function hasFrontendRemoteSignal(blob) {
+    const remaining = blob
+        .replace(/\bno\s+api\b/gi, "")
+        .replace(/无\s*(?:api\b|接口)/gi, "");
+    return /\b(api|fetch|axios|graphql|endpoint)\b|远程|接口/i.test(remaining);
+}
 function resolveBaselineFrontendTaskShape(input) {
     const blob = [
         input.requirementMarkdown ?? "",
@@ -84,9 +98,7 @@ function resolveBaselineFrontendTaskShape(input) {
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     const concentrated = spread <= 1 && paths.length <= 4;
-    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
-            /无\s*api|无\s*接口/i.test(blob));
+    const hasApiSignal = hasFrontendRemoteSignal(blob);
     const complexity = (input.complexity ?? "").toLowerCase();
     // split-required wins over everything: it is a termination/escalation
     // signal, not an executable topology.
@@ -266,9 +278,7 @@ export function deriveFrontendRuntimeShapeFacts(input) {
     const supervised = /\bsupervised\b/i.test(blob);
     const escalationSignals = collectEscalationSignals(blob, supervised);
     const paths = input.allowedPaths ?? [];
-    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
-            /无\s*api|无\s*接口/i.test(blob));
+    const hasApiSignal = hasFrontendRemoteSignal(blob);
     const requiresFull = escalationSignals.length > 0 || pathSpreadScore(paths) > 1 || hasApiSignal;
     return {
         splitRequired: input.splitRequired,

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

@@ -0,0 +1,48 @@
+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());
+    let separator = "";
+    if (!direct) {
+        if (!npm)
+            return undefined;
+        let manifest;
+        try {
+            manifest = JSON.parse(await readFile(path.join(input.cwd, "package.json"), "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+        const script = manifest.scripts?.[npm[1] ?? "test"] ?? "";
+        if (!/^vitest\s+run(?:\s|$)/.test(script) || /[;&|<>`\n\r$]|--(?:reporter|outputFile)/.test(script))
+            return undefined;
+        if (npm[3]?.trim() && !/^--(?:\s|$)/.test(npm[3].trim()))
+            return undefined;
+        separator = npm[3]?.trim() ? "" : " --";
+    }
+    const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
+    return `${input.command}${separator} --reporter=json --outputFile=${quote(input.reportPath)}`;
+}
+const resultSchema = z.object({
+    testResults: z.array(z.object({
+        name: z.string().min(1),
+        assertionResults: z.array(z.object({
+            title: z.string(), fullName: z.string().optional(),
+            ancestorTitles: z.array(z.string()).optional(), status: z.string(),
+        })),
+    })),
+});
+export function parseFrontendTestExecutionReport(raw, cwd) {
+    return resultSchema.parse(raw).testResults.flatMap((suite) => suite.assertionResults.map((test) => ({
+        file: path.relative(cwd, path.resolve(cwd, suite.name)).replace(/\\/g, "/"),
+        title: test.fullName ?? [...(test.ancestorTitles ?? []), test.title].join(" "),
+        status: test.status,
+    })));
+}

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

@@ -95,6 +95,8 @@ export const CONTRACT_FACT_KINDS = [
     "open-question",
     "split-proposal",
     "openspec-selection",
+    "ui-state-declaration",
+    "required-deliverables",
     "contract-finalized",
 ];
 export const CONTRACT_TERMINAL_FACT_KINDS = ["contract-finalized"];
@@ -124,6 +126,7 @@ export const PLAN_RECORD_FACT_KINDS = [
     "plan-requirement",
     "plan-verification-target",
     "plan-evidence-gap",
+    "state-registry",
 ];
 /**
  * A+B (AC-009): typed issue category shared by review and design change

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

@@ -152,6 +152,7 @@ export function extractFrontendTestTitles(content) {
     const tokens = lexFrontendTestSource(content);
     const titles = [];
     const configurationModifiers = new Set(["each", "runIf", "skipIf"]);
+    const nonExecutingModifiers = new Set(["skip", "todo", "fails"]);
     function closingParenIndex(openIndex) {
         let depth = 0;
         for (let cursor = openIndex; cursor < tokens.length; cursor += 1) {
@@ -177,12 +178,21 @@ export function extractFrontendTestTitles(content) {
         }
         let cursor = index + 1;
         let hasConfigurationModifier = false;
+        let hasNonExecutingModifier = false;
+        let conditionalModifier;
         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)) {
                 hasConfigurationModifier = true;
+                if (["runIf", "skipIf"].includes(tokens[cursor + 1].value)) {
+                    conditionalModifier = tokens[cursor + 1].value;
+                }
+            }
+            if (tokens[cursor + 1]?.type === "identifier" &&
+                nonExecutingModifiers.has(tokens[cursor + 1].value)) {
+                hasNonExecutingModifier = true;
             }
             cursor += 2;
         }
@@ -191,6 +201,13 @@ export function extractFrontendTestTitles(content) {
             continue;
         }
         if (hasConfigurationModifier) {
+            if (conditionalModifier && tokens[cursor + 1]?.type === "identifier" &&
+                tokens[cursor + 2]?.value === ")") {
+                const condition = tokens[cursor + 1].value;
+                if ((conditionalModifier === "runIf" && condition === "false") ||
+                    (conditionalModifier === "skipIf" && condition === "true"))
+                    hasNonExecutingModifier = true;
+            }
             const close = closingParenIndex(cursor);
             if (close === null ||
                 tokens[close + 1]?.type !== "punctuation" ||
@@ -199,6 +216,11 @@ export function extractFrontendTestTitles(content) {
             }
             cursor = close + 1;
         }
+        if (hasNonExecutingModifier) {
+            // A skipped suite also skips every nested test title in its body.
+            index = closingParenIndex(cursor) ?? tokens.length;
+            continue;
+        }
         if (tokens[cursor + 1]?.type !== "string")
             continue;
         titles.push(tokens[cursor + 1].value);
@@ -302,6 +324,15 @@ export async function evaluateVerificationTargets(input) {
             target,
         });
         issues.push(...fileTrace.issues);
+        const executed = input.executedTests?.get(target.commandLabel);
+        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));
+            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}`);
+            }
+        }
         const status = issues.length ? "failed" : "ok";
         if (issues.length)
             hardIssues.push(...issues.map((i) => `${target.id}: ${i}`));
@@ -473,6 +504,7 @@ export async function runFrontendVerificationTraceGate(input) {
         contract,
         labelOwners,
         workspaceRoot: input.workspaceRoot,
+        executedTests: input.evidence?.behavior.executedTests,
     });
     if (hardIssues.length) {
         throw new Error(`trace: ${hardIssues.join("; ")}`);