@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.11

package/dist/worker/observe/static/views/dag.d.ts

@@ -0,0 +1,13 @@
+export interface DagNodeRemark {
+	failed: boolean;
+	text: string;
+	isErrorSummary: boolean;
+}
+
+export function resolveNodeRemark(node: {
+	status?: string | null;
+	errorPreview?: string | null;
+	label?: string | null;
+	nodeId: string;
+	rank?: string | number | null;
+} | null | undefined): DagNodeRemark;

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

@@ -70,6 +70,7 @@ import {
 	dashboardVisibleFeatures,
 	findDagForRun,
 } from "../dag-model.js";
+import { describeDagNodePurpose } from "../dag-node-purpose.js";
 import { layoutDag } from "../dag-layout.js";
 import {
 	showView,
@@ -136,7 +137,7 @@ export function extractFirstErrorSummary(errorPreview) {
 	return effective ?? "";
 }
 
-/** Resolve 备注 cell content for a DAG node (failed → summary; else label). */
+/** Resolve 备注 cell content for a DAG node (failed → summary; else purpose). */
 export function resolveNodeRemark(node) {
 	const failed = isNodeFailed(node?.status);
 	if (failed) {
@@ -147,10 +148,10 @@ export function resolveNodeRemark(node) {
 			isErrorSummary: Boolean(summary),
 		};
 	}
-	const label = typeof node?.label === "string" ? node.label.trim() : "";
+	const purpose = describeDagNodePurpose(node?.nodeId, node);
 	return {
 		failed: false,
-		text: label || "—",
+		text: purpose || "—",
 		isErrorSummary: false,
 	};
 }
@@ -363,7 +364,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 			"page-action-btn",
 			"在操作台中止此运行 →",
 		);
-		interruptLink.href = `/#/recovery?dagRunId=${encodeURIComponent(dag.dagRunId)}&intent=interrupt`;
+		interruptLink.href = `/#/operate/recovery?dagRunId=${encodeURIComponent(dag.dagRunId)}&intent=interrupt`;
 		interruptLink.setAttribute("data-testid", "inspect-dag-interrupt-link");
 		interruptLink.title = "只跳转到操作台 Recovery，不会在观测页执行中止";
 		primaryEntries.push(["协作中止", interruptLink]);
@@ -481,6 +482,7 @@ export function startDagPolling(dagRunId, initial = true) {
 		const active = await renderDagDetail(dagRunId, isInitial);
 		if (generation !== uiState.pollingGeneration || !active) return;
 		const delay = detailPollDelay("running", isPageVisible());
+		if (delay == null) return;
 		uiState.dagPollTimer = setTimeout(() => {
 			uiState.dagPollTimer = null;
 			void poll(false);

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

@@ -84,7 +84,7 @@ let dashboardLoadingNode = null;
 
 /**
  * 「昨夜班次」条带：夜间结果在观测侧的唯一一级呈现（替代旧「夜间任务」tab）。
- * 管理动作（晨审处置）始终落在操作侧 /#/night，保持 Inspect 只读不变式。
+ * 管理动作（晨审处置）始终落在操作侧 /#/operate/night，保持 Inspect 只读不变式。
  */
 async function renderNightStrip() {
 	const strip = document.getElementById("dashboard-night");
@@ -118,14 +118,14 @@ async function renderNightStrip() {
 
 	const actions = el("div", "night-strip-actions");
 	const detail = el("a", "page-action-btn", "夜间详情");
-	detail.href = "#/night";
+	detail.href = "/#/inspect/night";
 	detail.addEventListener("click", (e) => {
 		e.preventDefault();
 		navigate("/night");
 	});
 	actions.appendChild(detail);
 	const manage = el("a", "page-action-btn night-strip-manage", "晨审处置 →");
-	manage.href = "/#/night";
+	manage.href = "/#/operate/night";
 	manage.title = "夜间计划的管理与晨审处置在操作台完成（Inspect 保持只读）";
 	actions.appendChild(manage);
 	strip.appendChild(actions);
@@ -738,10 +738,12 @@ export function startDashboardPolling(scrollTo) {
 	const poll = async (initialScrollTo) => {
 		await renderDashboard(initialScrollTo);
 		if (generation !== uiState.pollingGeneration) return;
+		const delay = dashboardPollDelay();
+		if (delay == null) return;
 		uiState.dashboardTimer = setTimeout(() => {
 			uiState.dashboardTimer = null;
 			void poll();
-		}, dashboardPollDelay());
+		}, delay);
 	};
 	void poll(scrollTo);
 }

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

@@ -46,8 +46,8 @@ export async function renderNightJobs(scheduleId) {
 	showView("night");
 	bindNightToolbar();
 	const crumbs = [
-		{ label: UI_TEXT.dashboard, href: "#/" },
-		{ label: UI_TEXT.nightJobs, href: "#/night" },
+		{ label: UI_TEXT.dashboard, href: "/#/inspect" },
+		{ label: UI_TEXT.nightJobs, href: "/#/inspect/night" },
 	];
 	if (scheduleId) crumbs.push({ label: scheduleId });
 	setBreadcrumb(crumbs);

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

@@ -93,6 +93,7 @@ function startPoolAutoPolling() {
 		if (generation !== uiState.pollingGeneration) return;
 		if (!poolAutoRefreshEnabled()) return;
 		const delay = isPageVisible() ? POOL_POLL_MS : dashboardPollDelay();
+		if (delay == null) return;
 		uiState.poolTimer = setTimeout(() => {
 			uiState.poolTimer = null;
 			void poll();

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

@@ -50,6 +50,7 @@ import {
 } from "../relations.js";
 import { copyText, renderRecommendedCommand } from "../copy.js";
 import {
+	fetchWithWorkspaceScope,
 	isPageVisible,
 	detailPollDelay,
 	dashboardPollDelay,
@@ -126,7 +127,7 @@ export function renderInlineArtifactList(container, artifacts) {
 		list.appendChild(li);
 		void (async () => {
 			try {
-				const res = await fetch(artifactUrl(artifactPath));
+				const res = await fetchWithWorkspaceScope(artifactUrl(artifactPath));
 				const text = await res.text();
 				if (!res.ok) {
 					let message = text;
@@ -444,6 +445,7 @@ export function startRunPolling(workerRunId, initial = true) {
 		const active = await renderRun(workerRunId, isInitial);
 		if (generation !== uiState.pollingGeneration || !active) return;
 		const delay = detailPollDelay("running", isPageVisible());
+		if (delay == null) return;
 		uiState.runPollTimer = setTimeout(() => {
 			uiState.runPollTimer = null;
 			void poll(false);

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

@@ -34,6 +34,7 @@ import {
 	repoBaseName,
 	parseMarkdownBlocks,
 	markdownLinkHref,
+	formatLedgerSummary,
 } from "../format.js";
 import { parseRoute, navigate, buildHashPath } from "../router.js";
 import {
@@ -85,7 +86,7 @@ export async function renderTaskDetail(featureId, taskId) {
 	showView("task");
 	setBreadcrumb([
 		{ label: UI_TEXT.dashboard, href: "#/" },
-		{ label: "资源池", href: "#/pool" },
+		{ label: "资源池", href: "/#/inspect/pool" },
 		{ label: displayLabel },
 	]);
 
@@ -94,6 +95,7 @@ export async function renderTaskDetail(featureId, taskId) {
 	const linksEl = document.getElementById("task-links");
 	const evidenceEl = document.getElementById("task-evidence");
 	const runsEl = document.getElementById("task-runs");
+	const ledgerEl = document.getElementById("task-ledger");
 	if (!metaEl || !linksEl || !evidenceEl || !runsEl) return false;
 	if (titleEl) titleEl.textContent = displayLabel;
 	mountViewState(metaEl, "loading", "加载 Task…");
@@ -252,9 +254,62 @@ export async function renderTaskDetail(featureId, taskId) {
 	const active = ["running", "pending", "blocked", "stale"].includes(
 		(task.status ?? "").toLowerCase(),
 	);
+	if (ledgerEl) {
+		void renderTaskLedger(ledgerEl, taskId);
+	}
 	return active;
 }
 
+/**
+ * Task 详情页 ledger 安全摘要（AC-009）：从只读 GET /api/tasks/:id/ledger 拉取，
+ * 计数/状态/failure code + 有界排除理由；无 ledger 显示空态，失败安全降级。
+ */
+async function renderTaskLedger(ledgerEl, taskId) {
+	clearNode(ledgerEl);
+	ledgerEl.appendChild(el("h3", "section-heading", "Source fidelity ledger"));
+	mountViewState(ledgerEl, "loading", "加载 ledger…");
+	let body = null;
+	try {
+		body = await fetchJson(`/api/tasks/${encodeURIComponent(taskId)}/ledger`);
+	} catch {
+		body = null;
+	}
+	if (!body) {
+		mountViewState(ledgerEl, "error", "ledger 只读接口失败（安全降级）。");
+		return;
+	}
+	if (body.present !== true) {
+		mountViewState(
+			ledgerEl,
+			body.error ? "error" : "empty",
+			body.error
+				? `ledger 不可用（${body.error}）。`
+				: "无 source fidelity ledger（任务无引用或 ledger 缺失，不伪造计数）。",
+		);
+		return;
+	}
+	const pre = el(
+		"pre",
+		"cmd",
+		formatLedgerSummary({
+			present: true,
+			fragmentCount: body.fragmentCount,
+			canonicalRequirementCount: body.canonicalRequirementCount,
+			contextOnlyCount: body.contextOnlyCount,
+			duplicateCount: body.duplicateCount,
+			unresolvedCount: body.unresolvedCount,
+			conflictCount: body.conflictCount,
+			gateStatus: body.gateStatus,
+			failureCode: body.failureCode,
+			exclusions: body.exclusions ?? [],
+		}),
+	);
+	pre.dataset.testid = "task-ledger-summary";
+	clearNode(ledgerEl);
+	ledgerEl.appendChild(el("h3", "section-heading", "Source fidelity ledger"));
+	ledgerEl.appendChild(pre);
+}
+
 export async function loadOlderTaskRuns(featureId, taskId, before, runsEl) {
 	if (runsEl === undefined) {
 		runsEl = before;

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

@@ -5,8 +5,10 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { resolveBackendTestManifestModules, backendManifestStatusFinding } from "./backend-test-markdown-workflow.js";
 import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
+import { inferScenarioParamIntent } from "./backend-test-scenario-param.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
 const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{3}\b/g;
 const NON_CANONICAL_CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-(?:\d{2}|\d{2,3}[A-Z]+))\b.*$/gm;
@@ -280,6 +282,80 @@ export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
     entries: z.array(correspondenceEntrySchema),
     findings: z.array(z.string()),
 }).strict();
+function bindingCounts(entry) {
+    const counts = new Map();
+    for (const point of [...entry.variantTestPoints, ...entry.assertionTestPoints, ...entry.crossCuttingTestPoints]) {
+        counts.set(point, (counts.get(point) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Classify correspondence defects by the only writer that can safely repair
+ * them. Markdown-owned contract defects must be fixed before pytest generation;
+ * pytest-owned generated-asset defects may enter the single bounded N11 repair.
+ */
+export function classifyBackendTestCorrespondenceRepair(facts, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const scriptRoot = resolved.scriptDir.replace(/\/$/, "");
+    const safePytestPath = (candidate) => {
+        const normalized = candidate.replaceAll("\\", "/").replace(/^\.\//, "");
+        return normalized.endsWith(".py") && (normalized === scriptRoot || normalized.startsWith(`${scriptRoot}/`));
+    };
+    const markdownBlockingEntries = [];
+    const pytestRepairEntries = [];
+    for (const entry of facts.entries) {
+        const markdownReasons = [];
+        const pytestReasons = [];
+        const counts = bindingCounts(entry);
+        if (entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1) ||
+            [...counts.keys()].some((point) => !entry.testPoints.includes(point))) {
+            markdownReasons.push("markdown-test-point-binding-invalid");
+        }
+        if (entry.declaredScript && entry.declaredScript !== entry.expectedScript) {
+            markdownReasons.push("markdown-script-declaration-invalid");
+        }
+        if (entry.cardinality === "1:0")
+            pytestReasons.push("missing-pytest-symbol");
+        if (entry.cardinality === "1:N")
+            pytestReasons.push("multiple-pytest-symbols");
+        if (entry.cardinality === "0:1")
+            pytestReasons.push("extra-pytest-symbol");
+        if (entry.actualScripts.some((script) => script !== entry.expectedScript))
+            pytestReasons.push("pytest-script-mismatch");
+        if (entry.declaredPrimarySymbol && entry.pytestSymbols.some((symbol) => symbol !== entry.declaredPrimarySymbol)) {
+            pytestReasons.push("pytest-primary-symbol-mismatch");
+        }
+        if (entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point)))
+            pytestReasons.push("variant-parameter-missing");
+        if (entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+            pytestReasons.push("assertion-binding-missing");
+        if (entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+            pytestReasons.push("cross-cutting-binding-missing");
+        if (entry.parameterIds.some((point) => !entry.testPoints.includes(point)))
+            pytestReasons.push("pytest-test-point-binding-extra");
+        if (entry.payloadAssessment.status === "UNSAFE")
+            pytestReasons.push("pytest-payload-shape-mismatch");
+        if (entry.status !== "EXACT_1_TO_1" &&
+            !["TEST_POINT_BINDING_DUPLICATE", "PAYLOAD_CONTRACT_UNAVAILABLE"].includes(entry.status)) {
+            pytestReasons.push(`correspondence-${entry.status.toLowerCase().replaceAll("_", "-")}`);
+        }
+        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE") {
+            markdownReasons.push("markdown-payload-contract-unavailable");
+        }
+        const paths = orderedUnique([entry.expectedScript, ...entry.actualScripts].filter(safePytestPath));
+        if (markdownReasons.length > 0) {
+            markdownBlockingEntries.push({ ...(entry.caseId ? { caseId: entry.caseId } : {}), reasonCodes: orderedUnique(markdownReasons), paths });
+        }
+        if (pytestReasons.length > 0 && paths.length > 0) {
+            pytestRepairEntries.push({ ...(entry.caseId ? { caseId: entry.caseId } : {}), reasonCodes: orderedUnique(pytestReasons), paths });
+        }
+    }
+    return {
+        markdownBlockingEntries,
+        pytestRepairEntries,
+        pytestRepairPaths: orderedUnique(pytestRepairEntries.flatMap((entry) => entry.paths)).sort(),
+    };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -592,6 +668,19 @@ function automationLabelBody(body, labels) {
     const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
     return match?.[1]?.replaceAll("`", "").trim() ?? "";
 }
+export function inspectBackendTestMarkdownTestPointBindings(markdown) {
+    const headings = [...markdown.matchAll(CASE_HEADING)];
+    return headings.map((heading, index) => {
+        const body = markdown.slice(heading.index, headings[index + 1]?.index ?? markdown.length);
+        const testPoints = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+        const bindings = testPointBindingFacts(body, testPoints);
+        return {
+            caseId: canonicalCaseId(heading[1]),
+            unclassifiedTestPoints: bindings.unclassifiedTestPoints,
+            duplicateBindingTestPoints: bindings.duplicateBindingTestPoints,
+        };
+    });
+}
 function testPointBindingFacts(body, testPoints) {
     const bindings = TEST_POINT_BINDING_MODES.flatMap((mode) => {
         const value = automationLabelBody(body, AUTOMATION_BINDING_LABELS[mode]);
@@ -659,10 +748,18 @@ async function markdownModuleFiles(workspaceRoot, layout) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
     const dir = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
     const entries = await readdir(dir, { withFileTypes: true });
-    return entries
+    const all = entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md") && entry.name.toLowerCase() !== "readme.md")
         .map((entry) => path.join(dir, entry.name))
         .sort();
+    // Current-round Markdown scope is the README Module Index manifest: unmanifested
+    // legacy .md files must not enter Case/coverage/partition statistics. Workspaces
+    // without a Module Index fall back to the whole directory (prior behaviour).
+    const manifest = await resolveBackendTestManifestModules(workspaceRoot, resolved);
+    if (manifest.manifestStatus !== "valid")
+        return [];
+    const declaredAbs = new Set(manifest.declaredMdFiles.map((rel) => path.join(workspaceRoot, ...rel.split("/")).toLowerCase()));
+    return all.filter((file) => declaredAbs.has(file.toLowerCase())).sort();
 }
 async function parseMarkdownCases(workspaceRoot, layout) {
     const result = [];
@@ -874,6 +971,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
     findings.push(...coverageScope.findings);
     const matrix = parseCoverageMatrix(readme);
     findings.push(...matrix.findings);
+    const manifest = await resolveBackendTestManifestModules(input.workspaceRoot, layout);
+    // Fail closed on README Module Index entries declared but never materialized.
+    if (manifest.declaredMissing.length > 0) {
+        findings.push(`declared Markdown module is missing (Module Index): ${manifest.declaredMissing.join(", ")}`);
+    }
+    // Fail closed on every non-valid Module Index state: without a valid unique
+    // Module Index the current round must not re-scan historical `.md` files.
+    if (manifest.manifestStatus !== "valid") {
+        findings.push(backendManifestStatusFinding(manifest.manifestStatus, manifest.moduleIndexHeadingCount));
+    }
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     for (const file of await markdownModuleFiles(input.workspaceRoot, layout)) {
         const markdown = await readFile(file, "utf8");
@@ -1109,6 +1216,15 @@ export async function analyzeBackendTestCaseCoverage(input) {
         "",
         facts.status,
         "",
+        `- Manifest scope: ${manifest.manifestStatus === "valid" ? "declared-modules" : `fails-closed:${manifest.manifestStatus}`} (declared-missing=${manifest.declaredMissing.length}, unmanifested-advisory=${manifest.unmanifested.length}, module-index-heading-count=${manifest.moduleIndexHeadingCount})`,
+        "",
+        "## Unmanifested Markdown Modules",
+        "",
+        "- Advisory: existing .md files not declared by the README Module Index are excluded from Case/coverage/partition statistics for this round.",
+        ...(manifest.unmanifested.length > 0
+            ? manifest.unmanifested.map((item) => `- ${item}`)
+            : ["- None"]),
+        "",
         "## Coverage Scope",
         "",
         `- Change Classification: ${facts.coverageScope.changeClassification}`,
@@ -1376,6 +1492,11 @@ def payload_expr_nodes(expr, assigned, parameters, seen=None):
                 if isinstance(key,ast.Constant) and key.value == expr.slice.value:
                     result.extend(shape_only(item) for item in payload_expr_nodes(value,assigned,parameters,set(seen)))
         return result
+    if isinstance(expr,ast.IfExp):
+        result=[]
+        result.extend(payload_expr_nodes(expr.body,assigned,parameters,set(seen)))
+        result.extend(payload_expr_nodes(expr.orelse,assigned,parameters,set(seen)))
+        return result
     if isinstance(expr,ast.Call):
         result=[]
         if isinstance(expr.func,ast.Name) and expr.func.id in FUNCTION_PAYLOADS:
@@ -1416,6 +1537,30 @@ def decorator_payload_nodes(parameters,assigned):
         for value in values: result.extend(payload_expr_nodes(value,assigned,parameters))
     return result
 
+def decorator_payload_nodes_by_tp(fn,assigned):
+    result={}
+    for dec in fn.decorator_list:
+        if not isinstance(dec,ast.Call) or not isinstance(dec.func,ast.Attribute) or dec.func.attr != 'parametrize' or len(dec.args) < 2: continue
+        if not isinstance(dec.args[0],ast.Constant) or not isinstance(dec.args[0].value,str): continue
+        names=[item.strip() for item in dec.args[0].value.split(',')]
+        rows=dec.args[1]
+        if isinstance(rows,ast.Name) and rows.id in GLOBAL_VALUES: rows=GLOBAL_VALUES[rows.id]
+        for node in ast.walk(rows):
+            if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute) or node.func.attr != 'param': continue
+            tp=None
+            for keyword in node.keywords:
+                if keyword.arg == 'id' and isinstance(keyword.value,ast.Constant) and isinstance(keyword.value.value,str) and keyword.value.value.startswith('TP-'):
+                    tp=keyword.value.value
+            if not tp: continue
+            parameters={}
+            for index,name in enumerate(names):
+                if index < len(node.args): parameters.setdefault(name,[]).append(node.args[index])
+            payload_nodes=decorator_payload_nodes(parameters,assigned)
+            paths=set(); values={}
+            for payload_node in payload_nodes: collect_dict(payload_node,'',paths,values)
+            result[tp]={key:sorted(items) for key,items in sorted(values.items())}
+    return result
+
 def fallback_payload_nodes(fn):
     result=[]
     assigned={}
@@ -1445,7 +1590,7 @@ def fallback_payload_nodes(fn):
 
 def is_direct_transport_call(node):
     if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute): return False
-    if node.func.attr.lower() not in {'get','post','put','patch','delete','request'}: return False
+    if node.func.attr.lower() not in {'get','post','put','patch','delete','request','call'}: return False
     receiver_tokens=[]
     current=node.func.value
     while isinstance(current,ast.Attribute):
@@ -1493,6 +1638,7 @@ for fn in ast.walk(tree):
             'values':{key:sorted(items) for key,items in sorted(values.items())},
             'fallbackPaths':sorted(fallback_paths),
             'fallbackValues':{key:sorted(items) for key,items in sorted(fallback_values.items())},
+            'valuesByTestPoint':decorator_payload_nodes_by_tp(fn,{}),
         }
 print(json.dumps(out,ensure_ascii=True))
 `;
@@ -1623,6 +1769,7 @@ function pytestSymbols(script, source) {
             payloadValues: payloadShape.values,
             fallbackPayloadPaths: payloadShape.fallbackPaths ?? [],
             fallbackPayloadValues: payloadShape.fallbackValues ?? {},
+            payloadValuesByTestPoint: payloadShape.valuesByTestPoint ?? {},
         };
     });
 }
@@ -1636,6 +1783,33 @@ function executionSignature(testCase) {
         .join("\n");
     return createHash("sha256").update(normalized).digest("hex");
 }
+function normalizePythonLiteralValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function intentionalInvalidEnumVariant(input) {
+    if (!input.testCase.testPointBindings.some((binding) => binding.mode === "variant" && binding.testPoint === input.testPoint))
+        return false;
+    const inferred = inferScenarioParamIntent({ tpId: input.testPoint, caseBody: input.testCase.body });
+    if (inferred.intentSource !== "machine-line" || inferred.field?.toLowerCase() !== input.field.toLowerCase())
+        return false;
+    const observed = normalizePythonLiteralValue(input.observedValue);
+    if (input.allowed.includes(observed))
+        return false;
+    if (inferred.intent === "enum-invalid" || inferred.intent === "wrong-type")
+        return true;
+    if (inferred.intent === "null")
+        return observed === "None" || observed === "null";
+    if (inferred.intent === "empty")
+        return observed === "";
+    if (!inferred.intent.startsWith("custom-literal:"))
+        return false;
+    const expected = normalizePythonLiteralValue(inferred.example ?? inferred.intent.slice("custom-literal:".length));
+    return observed === expected;
+}
 function assessPayloadContract(testCase, refs) {
     const requiredPaths = testCase.payloadContract.requiredPaths;
     const directObservedPaths = orderedUnique(refs.flatMap((item) => item.payloadPaths));
@@ -1657,13 +1831,17 @@ function assessPayloadContract(testCase, refs) {
             ? observedPaths.filter((item) => !allowedPaths.includes(item) && !allowedPaths.some((allowed) => item.startsWith(`${allowed}.`)))
             : [];
     const enumMismatches = [];
-    const delegatesInvalidEnumToScenarioGate = testCase.testPointBindings
-        .filter((binding) => binding.mode === "variant")
-        .some((binding) => /(?:ENUM|CATEGORY).*(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE)|(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE).*(?:ENUM|CATEGORY)/.test(binding.testPoint));
     for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []).map((value) => value.replace(/^['"]|['"]$/g, "")));
-        for (const value of observed) {
-            if (!allowed.includes(value) && !delegatesInvalidEnumToScenarioGate)
+        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        for (const rawValue of observed) {
+            const value = normalizePythonLiteralValue(rawValue);
+            if (allowed.includes(value))
+                continue;
+            const associatedTestPoints = orderedUnique(refs.flatMap((item) => Object.entries(item.payloadValuesByTestPoint)
+                .filter(([, values]) => (values[field] ?? []).includes(rawValue))
+                .map(([testPoint]) => testPoint)));
+            const intentionallyInvalid = associatedTestPoints.length > 0 && associatedTestPoints.every((testPoint) => intentionalInvalidEnumVariant({ testCase, testPoint, field, observedValue: rawValue, allowed }));
+            if (!intentionallyInvalid)
                 enumMismatches.push(`${field}=${value}; allowed=${allowed.join("|")}`);
         }
     }