@tea-agent/loop-agent 0.42.0-next.9 → 0.43.0-next.1

package/dist/worker/observe/static/views/dag.js

@@ -76,6 +76,7 @@ import {
 	findDagForRun,
 } from "../dag-model.js";
 import { describeDagNodePurpose } from "../dag-node-purpose.js";
+import { inspectorValueLabel } from "../dag-inspector-humanize.js";
 import { layoutDag } from "../dag-layout.js";
 import {
 	showView,
@@ -197,7 +198,9 @@ export function buildDagNodeTable(dagRunId, nodes) {
 				index + 1,
 				node.nodeId,
 				node.rank ?? "—",
-				node.executor ?? "—",
+				node.executor
+					? inspectorValueLabel("executor", node.executor)
+					: "—",
 				node.model ?? "—",
 				node.status ? badge(node.status) : "—",
 				formatMs(node.durationMs),
@@ -211,10 +214,10 @@ export function buildDagNodeTable(dagRunId, nodes) {
 	const nodeTable = buildTable(
 		[
 			"序号",
-			"节点 ID",
-			"依赖层",
+			"步骤编号",
+			"执行层级",
 			"执行方式",
-			"模型",
+			"实际模型",
 			"状态",
 			"耗时",
 			"执行历史",
@@ -261,7 +264,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	const metaEl = document.getElementById("dag-meta");
 	const ranksEl = document.getElementById("dag-ranks");
 	const nodesEl = document.getElementById("dag-nodes");
-	if (initial && metaEl) mountViewState(metaEl, "loading", "加载 DAG…");
+	if (initial && metaEl) mountViewState(metaEl, "loading", "正在加载运行流程…");
 	uiState.dagGraphViewportState = captureDagGraphViewportState(
 		uiState.dagGraphViewportState,
 		dagRunId,
@@ -281,7 +284,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	}
 	if (!dag) {
 		clearNode(metaEl);
-		mountViewState(metaEl, "error", "找不到该 DAG 运行。");
+		mountViewState(metaEl, "error", "找不到这次运行。运行记录可能已被清理。");
 		mountRelationBar("dag-relations", {}, snapshot);
 		closeDagInspector();
 		return false;
@@ -354,7 +357,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		LIVENESS_LABELS[dag.liveness] ?? dag.liveness ?? LIVENESS_LABELS.unknown;
 	const primaryEntries = [
 		["标题", dag.title || dag.dagRunId],
-		["DAG 运行 ID", dag.dagRunId],
+		["运行编号", dag.dagRunId],
 		["状态", dagStatusBadge(dag.effectiveStatus ?? dag.status)],
 	];
 	if (visibility.showExecutorStatus)
@@ -383,7 +386,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		["总耗时", formatDuration(dag.durationMs)],
 		["进度", `${progress.finished}/${progress.total}`],
 		["成功/失败/跳过", `${succeededCount}/${failedCount}/${skippedCount}`],
-		["DAG 路径", dag.dagPath ?? "—"],
+		["记录保存位置", dag.dagPath ?? "—"],
 	);
 	const lintSummary = frontendLintSummary(dag.frontendLint);
 	if (lintSummary) {
@@ -429,7 +432,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	);
 	if (nodes.length === 0) {
 		clearNode(ranksEl);
-		ranksEl.appendChild(el("h3", null, "DAG 依赖图"));
+		ranksEl.appendChild(el("h3", null, "执行步骤关系"));
 		ranksEl.appendChild(el("p", "empty", UI_TEXT.noNodes));
 	} else if (reuseShell && existingGraphWrap?.parentNode === ranksEl) {
 		// reuse-dag-graph-wrap + viewport identity: keep wrap/viewport alive.
@@ -440,16 +443,16 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		}
 	} else {
 		clearNode(ranksEl);
-		ranksEl.appendChild(el("h3", null, "DAG 依赖图"));
+		ranksEl.appendChild(el("h3", null, "执行步骤关系"));
 		ranksEl.appendChild(renderDagGraph(dag, dagRunId, null));
 	}
 
 	const nodesScrollLeft = nodesEl.scrollLeft;
 	clearNode(nodesEl);
 	const nodeHeading = el("div", "dag-section-heading");
-	nodeHeading.appendChild(el("h3", null, "节点"));
+	nodeHeading.appendChild(el("h3", null, "执行步骤"));
 	nodeHeading.appendChild(
-		el("span", "dag-section-meta", `共 ${nodes.length} 个节点`),
+		el("span", "dag-section-meta", `共 ${nodes.length} 个步骤`),
 	);
 	nodesEl.appendChild(nodeHeading);
 
@@ -479,6 +482,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		dagRunId,
 		nodes.find((node) => node.nodeId === uiState.selectedDagNodeId),
 		initial,
+		dag,
 	);
 	return isDagRunActive(dag);
 }

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

@@ -1116,9 +1116,11 @@ function rerenderSessionTimeline(content, nodeId, options) {
 	const scrollLeft = content.scrollLeft;
 	const autoScrollEnabled = isTimelineAutoScrollEnabled();
 	const preserved = [...content.children].filter((child) =>
-		String(child.className ?? "")
-			.split(/\s+/)
-			.includes("dag-inspector-attempt-bar"),
+		["dag-inspector-attempt-bar", "inspector-page-lead"].some((className) =>
+			String(child.className ?? "")
+				.split(/\s+/)
+				.includes(className),
+		),
 	);
 	while (content.firstChild) content.removeChild(content.firstChild);
 	for (const child of preserved) content.appendChild(child);

package/dist/workflows/dag/backend-test-plan-protocol.js

@@ -101,6 +101,110 @@ export function lookupRequiredVariantSlotsForMarkdownPath(inventory, markdownPat
         .replace(/\.md$/i, "");
     return inventory.modules.find((item) => item.stem === stem)?.requiredVariantSlots ?? [];
 }
+const MODULE_INDEX_HEADER = [
+    "Module Stem",
+    "Business Resource",
+    "Owned Operations",
+    "Owned Rule Keys",
+    "Case IDs",
+    "Split Reason",
+    "Markdown Path",
+    "Pytest Path",
+];
+function markdownTableCells(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+        return undefined;
+    return trimmed
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => cell.trim().replace(/^`|`$/g, ""));
+}
+function isMarkdownSeparatorRow(cells) {
+    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+/** Validate the minimum complete run-owned Markdown protocol before N2 succeeds. */
+export function assessBackendTestPlanProtocol(markdown) {
+    const canonical = canonicalizeBackendTestPlanProtocolHeadings(markdown).markdown;
+    const lines = canonical.split("\n");
+    const issues = [];
+    if (lines.some((line) => /^(?:```|~~~)/.test(line.trim()))) {
+        issues.push({
+            code: "fenced-plan-output",
+            detail: "return the final Markdown plan directly, without a code fence",
+        });
+    }
+    const headingIndexes = new Map();
+    for (const heading of [
+        "Coverage Scope",
+        "Coverage Matrix",
+        "Scenario Partitions",
+        "Module Index",
+    ]) {
+        headingIndexes.set(heading, lines.flatMap((line, index) => line.trim() === `## ${heading}` ? [index] : []));
+    }
+    const requireUnique = (heading, missingCode, duplicateCode) => {
+        const count = headingIndexes.get(heading)?.length ?? 0;
+        if (count === 0) {
+            issues.push({
+                code: missingCode,
+                detail: `require exactly one exact ## ${heading} section`,
+            });
+        }
+        else if (count > 1) {
+            issues.push({
+                code: duplicateCode,
+                detail: `found ${count}; require exactly one exact ## ${heading} section`,
+            });
+        }
+    };
+    // Module Index is first so retry diagnostics lead with the shard authority.
+    requireUnique("Module Index", "missing-module-index", "duplicate-module-index");
+    requireUnique("Coverage Scope", "missing-coverage-scope", "duplicate-coverage-scope");
+    requireUnique("Coverage Matrix", "missing-coverage-matrix", "duplicate-coverage-matrix");
+    const scenarioCount = headingIndexes.get("Scenario Partitions")?.length ?? 0;
+    if (scenarioCount > 1) {
+        issues.push({
+            code: "duplicate-scenario-partitions",
+            detail: `found ${scenarioCount}; require at most one exact ## Scenario Partitions section`,
+        });
+    }
+    const moduleIndexes = headingIndexes.get("Module Index") ?? [];
+    if (moduleIndexes.length === 1) {
+        const start = moduleIndexes[0] + 1;
+        const nextHeading = lines
+            .slice(start)
+            .findIndex((line) => /^##\s+\S/.test(line.trim()));
+        const end = nextHeading < 0 ? lines.length : start + nextHeading;
+        const rows = lines
+            .slice(start, end)
+            .map(markdownTableCells)
+            .filter((cells) => cells !== undefined);
+        const headerIndex = rows.findIndex((cells) => cells.length === MODULE_INDEX_HEADER.length &&
+            MODULE_INDEX_HEADER.every((name, index) => cells[index] === name));
+        if (headerIndex < 0) {
+            issues.push({
+                code: "invalid-module-index-header",
+                detail: `require exact Module Index header: ${MODULE_INDEX_HEADER.join(" | ")}`,
+            });
+        }
+        else {
+            const dataRows = rows
+                .slice(headerIndex + 1)
+                .filter((cells) => !isMarkdownSeparatorRow(cells));
+            if (!dataRows.some((cells) => cells.length === MODULE_INDEX_HEADER.length &&
+                Boolean(cells[0]?.trim()) &&
+                Boolean(cells[6]?.trim()) &&
+                Boolean(cells[7]?.trim()))) {
+                issues.push({
+                    code: "empty-module-index",
+                    detail: "Module Index must contain at least one complete 8-cell module row",
+                });
+            }
+        }
+    }
+    return { ok: issues.length === 0, issues };
+}
 export function isCanonicalPlanHeadingLine(line) {
     return CANONICAL_HEADING_LINE.test(line.trim());
 }

package/dist/workflows/dag/dag-retry-schema.js

@@ -32,7 +32,10 @@ export const DEFAULT_DAG_RETRY_CATEGORIES = [
     "rate-limit",
     "unavailable",
     "empty-output",
+    "output-limit",
 ];
+/** Provider stopReason=length: output/context capacity ended the turn early. */
+export const OUTPUT_LIMIT_RETRY_CATEGORY = "output-limit";
 export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
 export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
 /** Recoverable model artifact/schema formatting failure on read-only structured nodes. */

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

@@ -0,0 +1,130 @@
+import { z } from "zod";
+/** Shared projections of committed frontend facts. Callers filter commit phase. */
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** Join requirement-owned identity with separately committed evidence by id.
+ * Later evidence declarations replace only the lanes they explicitly name. */
+export function resolveFrontendContractRequirements(facts) {
+    const contractFacts = facts.map(object).filter((fact) => fact?.origin === "contract");
+    const evidenceById = new Map();
+    for (const fact of contractFacts) {
+        if (fact.kind !== "evidence-expectation" ||
+            typeof fact.requirementId !== "string")
+            continue;
+        evidenceById.set(fact.requirementId, {
+            ...evidenceById.get(fact.requirementId),
+            ...object(fact.evidence),
+        });
+    }
+    return contractFacts.flatMap((fact) => fact.kind === "requirement" && typeof fact.id === "string"
+        ? [{
+                ...fact,
+                id: fact.id,
+                evidence: { ...object(fact.evidence), ...evidenceById.get(fact.id) },
+            }]
+        : []);
+}
+function names(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+}
+const evidenceStatus = z.enum(["required", "optional", "not-applicable"]);
+export const frontendEvidenceExpectationSchema = z.object({
+    requirementId: z.string().min(1),
+    evidence: z.object({
+        static: evidenceStatus.optional(),
+        behavior: evidenceStatus.optional(),
+        mock: evidenceStatus.optional(),
+        "real-integration": evidenceStatus.optional(),
+    }).strict().refine((evidence) => Object.keys(evidence).length > 0, "declare at least one evidence lane"),
+}).strict();
+const concretePath = z.string().min(1).refine((value) => value === value.trim() &&
+    !/^[A-Za-z]:/.test(value) &&
+    !/[\\*?\[\]{}\0]/.test(value) &&
+    value.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "must be a concrete relative POSIX file path without traversal");
+export const frontendRequiredDeliverablesSchema = z.object({
+    items: z.array(z.object({
+        path: concretePath,
+        requirementId: z.string().min(1),
+        sourceFragmentId: z.string().min(1),
+    }).strict()),
+}).strict();
+/** Validate structure and provenance; the Contract model owns the distinction
+ * between delivery obligations, permissions, prohibitions and references. */
+export function validateFrontendRequiredDeliverables(value, requirements) {
+    const declaration = frontendRequiredDeliverablesSchema.parse(value);
+    for (const item of declaration.items) {
+        const requirement = requirements.get(item.requirementId);
+        if (!requirement?.sourceFragmentIds.includes(item.sourceFragmentId)) {
+            throw new Error(`required deliverable ${item.path} has an unknown requirement/fragment binding`);
+        }
+        const text = requirement.sourceFragments?.get(item.sourceFragmentId);
+        const escaped = item.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // A sentence-ending period is punctuation; a dot followed by filename
+        // characters is still part of the token (app.ts must not match app.ts.map).
+        const exactPath = new RegExp(`(^|[^\\p{L}\\p{N}_./-])${escaped}(?=$|[^\\p{L}\\p{N}_./-]|\\.(?=$|[^\\p{L}\\p{N}_./-]))`, "u");
+        if (!text || !exactPath.test(text)) {
+            throw new Error(`required deliverable ${item.path} is not an exact path in frozen source fragment ${item.sourceFragmentId}`);
+        }
+    }
+    return declaration;
+}
+/** Read the latest explicit inventory. Never infer obligations from prose. */
+export function extractRequiredDeliverablePaths(facts) {
+    const declaration = facts.map(object).filter((fact) => fact?.origin === "contract" && fact.kind === "required-deliverables").at(-1);
+    if (!declaration)
+        return [];
+    const { items } = frontendRequiredDeliverablesSchema.parse({ items: declaration.items });
+    return [...new Set(items.map((item) => item.path))].sort();
+}
+/** Apply state-flow replacement/removal semantics exactly as the plan compiler does. */
+export function collectCanonicalStateFlowNames(committedFacts, includeRegistry = false) {
+    const uiStateNames = new Set();
+    const interactionNames = new Set();
+    for (const value of committedFacts) {
+        const record = object(value);
+        if (!record || (record.phase !== undefined && record.phase !== "committed"))
+            continue;
+        const fact = object(record.fact) ?? record;
+        if (fact.origin !== "plan")
+            continue;
+        if (includeRegistry && fact.kind === "state-registry") {
+            uiStateNames.clear();
+            interactionNames.clear();
+            for (const name of names(fact.uiStateNames))
+                uiStateNames.add(name);
+            for (const name of names(fact.interactionNames))
+                interactionNames.add(name);
+        }
+        if (fact.kind !== "state-flow")
+            continue;
+        for (const name of names(fact.removeUiStateNames)) {
+            uiStateNames.delete(name);
+        }
+        for (const name of names(fact.removeInteractionNames)) {
+            interactionNames.delete(name);
+        }
+        for (const state of Array.isArray(fact.uiStates) ? fact.uiStates : []) {
+            if (!state || typeof state !== "object" || Array.isArray(state))
+                continue;
+            const name = state.name;
+            if (typeof name === "string" && name.trim())
+                uiStateNames.add(name);
+        }
+        for (const interaction of Array.isArray(fact.interactions)
+            ? fact.interactions
+            : []) {
+            if (!interaction || typeof interaction !== "object" || Array.isArray(interaction)) {
+                continue;
+            }
+            const name = interaction.name;
+            if (typeof name === "string" && name.trim())
+                interactionNames.add(name);
+        }
+    }
+    return { uiStateNames, interactionNames };
+}

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) {
@@ -249,7 +272,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
         }
     }
     for (const target of contract.verificationTargets) {
-        if (target.type === "static")
+        if (target.mode === "static")
             continue;
         if (!matches(target.file)) {
             findings.push({
@@ -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 = {