@tea-agent/loop-agent 0.30.0 → 0.31.1

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

@@ -0,0 +1,313 @@
+/**
+ * DAG 执行轨迹 storyboard（Observe UI R5 / P1）。
+ *
+ * 将 detail 响应内嵌的有界 executionTrajectory 渲染为自上而下的 lane：
+ * 「初始执行」「修复轮次 N-1」「最终收敛」（仅内容 lane）。raw pass=1（scope
+ * base 或 convergence-pass）均显示「初始执行」，raw pass>=2 显示「修复轮次
+ * N-1」；raw pass 编号仅保留在 occurrence 卡 hover/title 诊断（AC-001/AC-002）。
+ * lane 内按真实
+ * sequence 左→右；occurrence 卡含节点名/状态/耗时/语义 verdict；多 attempt
+ * 显示中文紧凑尝试条；lane 间短箭头加中文原因；不画跨 lane 回环（P2 路由
+ * 算法不在 P1 范围）。布局异常降级为纵向事件列表，不空白页。
+ */
+import { el } from "../dom.js";
+import { statusLabel, formatMs } from "../format.js";
+import {
+	attemptFailureLabel,
+	semanticVerdictLabel,
+	transitionReasonLabel,
+} from "../dag-history-labels.js";
+import { setDagGraphViewMode } from "../state.js";
+import { selectDagExecution } from "./dag-inspector.js";
+
+export const TRAJECTORY_EMPTY_TEXT = "本次运行没有可展开的执行轨迹";
+export const TRAJECTORY_UNAVAILABLE_TEXT = "执行历史暂不可用";
+export const TRAJECTORY_PARTIAL_TEXT = "历史证据不完整";
+
+const SUCCESS_STATUSES = new Set([
+	"finished",
+	"completed",
+	"succeeded",
+	"done",
+	"success",
+]);
+const FAILURE_STATUSES = new Set([
+	"error",
+	"failed",
+	"partial_failed",
+	"partial-failed",
+	"interrupted",
+	"failure",
+	"superseded",
+]);
+const RUNNING_STATUSES = new Set(["running", "started", "paused", "queued"]);
+
+function occurrenceStatusBadge(status) {
+	const normalized = String(status ?? "").toLowerCase();
+	if (SUCCESS_STATUSES.has(normalized)) {
+		return { cls: "succeeded", label: "成功" };
+	}
+	if (FAILURE_STATUSES.has(normalized)) {
+		return { cls: "failed", label: "失败" };
+	}
+	if (RUNNING_STATUSES.has(normalized)) {
+		return { cls: "pending", label: "运行中" };
+	}
+	return { cls: "pending", label: statusLabel(status) ?? status ?? "未知" };
+}
+
+/** Lane grouping key from an occurrence (pre-sorted by the projection). */
+function laneKeyOf(occurrence) {
+	if (occurrence.scope === "final") return "final";
+	if (occurrence.scope === "base") return "base";
+	return `pass-${occurrence.pass ?? 0}`;
+}
+
+function laneTitle(laneKey, occurrence) {
+	if (laneKey === "base") return "初始执行";
+	if (laneKey === "final") return "最终收敛";
+	// raw pass=1 的 convergence-pass lane 也显示「初始执行」；raw pass>=2
+	// 映射为人类修复轮次 N-1（AC-001/AC-002），主文案不出现 raw 轮次直译。
+	const pass = occurrence.pass ?? 0;
+	if (pass <= 1) return "初始执行";
+	return `修复轮次 ${pass - 1}`;
+}
+
+/** 中文紧凑尝试条：首次尝试 / 第 N 次尝试（AC-002，主 UI 不出现裸 A1/A2）。 */
+function attemptStripLabel(occurrence) {
+	const attempts = occurrence.attempts;
+	if (!Array.isArray(attempts) || attempts.length <= 1) return null;
+	return attempts
+		.map((attempt) => {
+			const name =
+				attempt.attempt === 1 ? "首次尝试" : `第 ${attempt.attempt} 次尝试`;
+			// 失败 attempt 显示表一中文原因（AC-001），未知/缺失分类
+			// fail-closed 为「其他失败原因」；成功 attempt 保持「成功」。
+			const outcome =
+				attempt.status === "success"
+					? "成功"
+					: attemptFailureLabel(attempt.failureCategory);
+			return `${name} ${outcome}`;
+		})
+		.join(" → ");
+}
+
+function buildOccurrenceCard(dagRunId, occurrence) {
+	const badge = occurrenceStatusBadge(occurrence.status);
+	const recovered =
+		occurrence.recovered === true ||
+		occurrence.supersededBy?.length > 0 ||
+		false;
+	const card = document.createElement("button");
+	card.type = "button";
+	const extraClasses = [
+		recovered ? "is-recovered" : "",
+		occurrence.availability === "partial" ? "is-partial" : "",
+	]
+		.filter(Boolean)
+		.join(" ");
+	card.className = extraClasses
+		? `dag-trajectory-occurrence ${extraClasses}`
+		: "dag-trajectory-occurrence";
+	// 原始 pass/attempt 编号仅出现在 hover/title 诊断中，不作主标题（AC-003）。
+	const diagnostic = [
+		occurrence.executionId,
+		occurrence.status,
+		...(occurrence.pass ? [`pass ${occurrence.pass}`] : []),
+		...(occurrence.failureCategory
+			? [`failureCategory ${occurrence.failureCategory}`]
+			: []),
+	].join("\n");
+	card.setAttribute("title", diagnostic);
+	// 语义 verdict 主文案与 aria-label 均显示表二中文（AC-002）。
+	const verdictLabel = semanticVerdictLabel(occurrence.semanticVerdict);
+	card.setAttribute(
+		"aria-label",
+		`${occurrence.nodeId}，${badge.label}${occurrence.semanticVerdict ? `，语义 ${verdictLabel}` : ""}${recovered ? "，历史失败 · 已恢复/已覆盖" : ""}`,
+	);
+
+	const nodeLine = el("span", "dag-trajectory-occurrence-node", occurrence.nodeId);
+	card.appendChild(nodeLine);
+	const statusBadge = el(
+		"span",
+		`badge badge-${badge.cls} dag-trajectory-occurrence-status`,
+		badge.label,
+	);
+	card.appendChild(statusBadge);
+	if (occurrence.durationMs !== undefined) {
+		card.appendChild(
+			el(
+				"span",
+				"dag-trajectory-occurrence-meta",
+				formatMs(occurrence.durationMs),
+			),
+		);
+	}
+	if (occurrence.semanticVerdict) {
+		card.appendChild(
+			el("span", "dag-trajectory-occurrence-verdict", verdictLabel),
+		);
+	}
+	const strip = attemptStripLabel(occurrence);
+	if (strip) {
+		card.appendChild(el("span", "dag-trajectory-attempt-strip", strip));
+	}
+	if (recovered) {
+		const label =
+			occurrence.supersededBy?.length > 0
+				? "历史失败 · 已覆盖"
+				: "历史失败 · 已恢复";
+		card.appendChild(el("span", "dag-trajectory-recovered", label));
+	}
+	if (occurrence.availability === "partial") {
+		card.appendChild(
+			el("span", "dag-trajectory-partial", TRAJECTORY_PARTIAL_TEXT),
+		);
+	}
+	card.addEventListener("click", () => {
+		// @pass-<n> 映射为 Inspector 既有 pass-<n> key；@base/@final 默认最新。
+		selectDagExecution(
+			dagRunId,
+			occurrence.nodeId,
+			occurrence.pass ? `pass-${occurrence.pass}` : null,
+		);
+	});
+	return card;
+}
+
+function buildEmptyState(dagRunId, rerender) {
+	const root = el("div", "dag-trajectory-empty");
+	root.appendChild(el("p", "dag-trajectory-empty-text", TRAJECTORY_EMPTY_TEXT));
+	const back = document.createElement("button");
+	back.type = "button";
+	back.className = "dag-trajectory-back";
+	back.textContent = "返回逻辑拓扑";
+	back.addEventListener("click", () => {
+		setDagGraphViewMode(dagRunId, "topology");
+		rerender();
+	});
+	root.appendChild(back);
+	return root;
+}
+
+/**
+ * 渲染执行轨迹视图到图区域 viewport。`rerender` 由 dag-graph 注入，用于
+ * 空态「返回逻辑拓扑」就地切回拓扑（避免模块环）。
+ */
+export function renderTrajectoryStoryboard(dag, dagRunId, viewport, rerender) {
+	const trajectory = dag.executionTrajectory;
+	const fallback = (occurrences) => {
+		const list = el("ul", "dag-trajectory-fallback");
+		const items = Array.isArray(occurrences)
+			? occurrences
+			: trajectory?.occurrences ?? [];
+		if (items.length === 0) {
+			list.appendChild(
+				el("li", "dag-trajectory-fallback-item", TRAJECTORY_UNAVAILABLE_TEXT),
+			);
+		} else {
+			let rendered = 0;
+			for (const occurrence of items) {
+				if (!occurrence || typeof occurrence !== "object") continue;
+				// 纵向降级列表同样经表三/表二映射拼接，不出现裸英文 token（AC-002）。
+				const reason =
+					transitionReasonLabel(occurrence.nextReason) ||
+					semanticVerdictLabel(occurrence.semanticVerdict) ||
+					"";
+				list.appendChild(
+					el(
+						"li",
+						"dag-trajectory-fallback-item",
+						`${occurrence.nodeId} · ${statusLabel(occurrence.status)}${reason ? ` · ${reason}` : ""}`,
+					),
+				);
+				rendered += 1;
+			}
+			if (rendered === 0) {
+				list.appendChild(
+					el(
+						"li",
+						"dag-trajectory-fallback-item",
+						TRAJECTORY_UNAVAILABLE_TEXT,
+					),
+				);
+			}
+		}
+		viewport.appendChild(list);
+	};
+	try {
+		if (!trajectory || !Array.isArray(trajectory.occurrences)) {
+			// 无 executionTrajectory 或空轨迹：空态 + 返回逻辑拓扑入口。
+			viewport.appendChild(buildEmptyState(dagRunId, rerender));
+			return;
+		}
+		const root = el("div", "dag-trajectory");
+		if (trajectory.projectionError === true) {
+			root.appendChild(
+				el("div", "dag-trajectory-banner is-error", TRAJECTORY_UNAVAILABLE_TEXT),
+			);
+		}
+		if (Array.isArray(trajectory.warnings) && trajectory.warnings.length > 0) {
+			root.appendChild(
+				el(
+					"div",
+					"dag-trajectory-banner",
+					`${TRAJECTORY_PARTIAL_TEXT}：${trajectory.warnings.join("；")}`,
+				),
+			);
+		}
+		if (trajectory.occurrences.length === 0) {
+			root.appendChild(buildEmptyState(dagRunId, rerender));
+			viewport.appendChild(root);
+			return;
+		}
+		// 按投影排序连续分组为 lane（仅内容 lane），lane 间插入带中文原因的短箭头。
+		const lanes = [];
+		let currentLaneKey = null;
+		for (const occurrence of trajectory.occurrences) {
+			const laneKey = laneKeyOf(occurrence);
+			if (laneKey !== currentLaneKey) {
+				currentLaneKey = laneKey;
+				lanes.push({
+					laneKey,
+					title: laneTitle(laneKey, occurrence),
+					occurrences: [],
+				});
+			}
+			lanes[lanes.length - 1].occurrences.push(occurrence);
+		}
+		for (const [index, lane] of lanes.entries()) {
+			const laneRoot = el("div", "dag-trajectory-lane");
+			const head = el("div", "dag-trajectory-lane-head");
+			head.appendChild(el("span", "dag-trajectory-lane-title", lane.title));
+			head.appendChild(
+				el("span", "dag-trajectory-lane-meta", `${lane.occurrences.length} 次执行`),
+			);
+			laneRoot.appendChild(head);
+			const laneCards = el("div", "dag-trajectory-lane-cards");
+			for (const occurrence of lane.occurrences) {
+				laneCards.appendChild(buildOccurrenceCard(dagRunId, occurrence));
+			}
+			laneRoot.appendChild(laneCards);
+			root.appendChild(laneRoot);
+			if (index < lanes.length - 1) {
+				const lastOccurrence = lane.occurrences[lane.occurrences.length - 1];
+				const reason = transitionReasonLabel(lastOccurrence?.nextReason);
+				if (reason) {
+					const transition = el("div", "dag-trajectory-transition");
+					transition.appendChild(
+						el("span", "dag-trajectory-transition-arrow", "↓"),
+					);
+					transition.appendChild(
+						el("span", "dag-trajectory-transition-reason", reason),
+					);
+					root.appendChild(transition);
+				}
+			}
+		}
+		viewport.appendChild(root);
+	} catch {
+		// 布局/渲染异常降级：纵向事件列表，不空白页（AC-006）。
+		fallback(null);
+	}
+}

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

@@ -62,7 +62,7 @@ import {
 	mountViewState,
 	makeSessionEventIdentity,
 } from "../state.js";
-import { uiState, dagGraphViewportStates } from "../state.js";
+import { uiState, dagGraphViewportStates, dagGraphViewModes } from "../state.js";
 import { sortPoolTasks } from "../format-pool.js";
 import {
 	dagMetaVisibility,
@@ -108,9 +108,12 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		uiState.sessionEventIdentity = null;
 		uiState.dagInspectorOpen = false;
 		uiState.dagInspectorTab = "output";
+		uiState.dagInspectorAttempt = null;
 		uiState.dagGraphViewportState = null;
 		uiState.dagTimelineViewportState = null;
 	}
+	// AC-001：同会话内重新进入同一 dagRunId 保持当前图视图模式（不切回逻辑拓扑）。
+	uiState.dagGraphViewMode = dagGraphViewModes.get(dagRunId) ?? "topology";
 
 	const metaEl = document.getElementById("dag-meta");
 	const ranksEl = document.getElementById("dag-ranks");
@@ -167,6 +170,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	) {
 		uiState.selectedDagNodeId = null;
 		uiState.dagInspectorOpen = false;
+		uiState.dagInspectorAttempt = null;
 		if (initial) {
 			uiState.sessionEventOffset = 0;
 			uiState.sessionEvents = [];
@@ -325,17 +329,30 @@ export async function renderDagDetail(dagRunId, initial = true) {
 					node.model ?? "—",
 					node.status ? badge(node.status) : "—",
 					formatMs(node.durationMs),
+					(typeof node.executionSummary?.historyLabel === "string" &&
+						node.executionSummary.historyLabel.trim()) ||
+						"—",
 					node.errorPreview ?? node.label ?? "—",
 				],
 			};
 		});
 		const nodeTable = buildTable(
-			["序号", "节点 ID", "依赖层", "执行方式", "模型", "状态", "耗时", "备注"],
+			[
+				"序号",
+				"节点 ID",
+				"依赖层",
+				"执行方式",
+				"模型",
+				"状态",
+				"耗时",
+				"执行历史",
+				"备注",
+			],
 			rows,
 		);
 		nodeTable.classList.add("dag-node-table");
 		for (const row of nodeTable.tBodies[0]?.rows ?? []) {
-			for (const columnIndex of [1, 4, 7]) {
+			for (const columnIndex of [1, 4, 8]) {
 				const cell = row.cells[columnIndex];
 				if (cell?.textContent) cell.title = cell.textContent;
 			}

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -11,12 +11,16 @@ export const backendPytestCollectionFindingSchema = z.object({
     detail: z.string().min(1),
 }).strict();
 export const backendPytestCollectionFactsSchema = z.object({
-    schemaId: z.literal("backend-test-pytest-collection-v2"),
+    schemaId: z.literal("backend-test-pytest-collection-v3"),
     phase: z.enum(["initial", "final", "effective"]),
     status: z.enum(["PASS", "REPAIRABLE", "BLOCKED"]),
     repairEligible: z.boolean(),
     repairAttempt: z.number().int().min(0).max(1),
     collectionAttempted: z.boolean(),
+    fixtureResolutionAttempted: z.boolean(),
+    fixtureResolutionStatus: z.enum(["NOT_RUN", "PASS", "REPAIRABLE", "BLOCKED"]),
+    fixtureResolutionExitCode: z.number().int().nullable(),
+    repairPaths: z.array(z.string()),
     mappedScripts: z.array(z.string()).min(1),
     existingMappedScripts: z.array(z.string()),
     missingMappedScripts: z.array(z.string()),
@@ -28,17 +32,37 @@ export const backendPytestCollectionFactsSchema = z.object({
     findings: z.array(backendPytestCollectionFindingSchema),
     stdoutExcerpt: z.string(),
     stderrExcerpt: z.string(),
+    fixtureStdoutExcerpt: z.string(),
+    fixtureStderrExcerpt: z.string(),
     collectionSource: z.enum(["initial", "final"]).optional(),
 }).strict().superRefine((facts, context) => {
     if (facts.status === "PASS") {
-        if (!facts.collectionAttempted || facts.pytestExitCode !== 0 || facts.missingMappedScripts.length > 0 || facts.assetFiles.length === 0) {
-            context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection PASS requires attempted collection, exit 0, complete mapped scripts and bound assets" });
+        if (!facts.collectionAttempted || facts.pytestExitCode !== 0 || !facts.fixtureResolutionAttempted || facts.fixtureResolutionStatus !== "PASS" || facts.fixtureResolutionExitCode !== 0 || facts.missingMappedScripts.length > 0 || facts.assetFiles.length === 0) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection PASS requires collection and fixture-resolution PASS, complete mapped scripts and bound assets" });
         }
     }
     if (!facts.collectionAttempted && facts.pytestExitCode !== null) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection without an attempt cannot have an exit code" });
     }
+    if (!facts.fixtureResolutionAttempted && facts.fixtureResolutionExitCode !== null) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest fixture resolution without an attempt cannot have an exit code" });
+    }
 });
+export const backendTestExecutionReadinessSchema = z.object({
+    schemaId: z.literal("backend-test-execution-readiness-v1"),
+    status: z.enum(["PASS", "PARTIAL", "BLOCKED"]),
+    collectionStatus: z.literal("PASS"),
+    fixtureResolutionStatus: z.literal("PASS"),
+    scenarioParamStatus: z.enum(["PASS", "PARTIAL", "FAIL", "UNAVAILABLE"]),
+    repairAttempts: z.object({
+        collection: z.number().int().min(0).max(1),
+        scenarioParam: z.number().int().min(0).max(1),
+    }).strict(),
+    mappedScripts: z.array(z.string()).min(1),
+    collectedItemIds: z.array(z.string()),
+    fixtureIssues: z.array(z.string()),
+    assetHashes: z.record(z.string(), z.string().regex(SHA256)),
+}).strict();
 function repoRef(workspaceRoot, absolutePath) {
     return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, "/");
 }
@@ -106,6 +130,28 @@ function collectionItems(stdout) {
             return /^testcase\//.test(line.replaceAll("\\", "/"));
         }).map((line) => line.replaceAll("\\", "/")))];
 }
+function testcasePythonPaths(output) {
+    return [...new Set((output.replaceAll("\\", "/").match(/testcase\/[A-Za-z0-9_./-]+\.py/gi) ?? []).map((item) => item.replace(/:\d+$/, "")))].sort();
+}
+function classifyFixtureResolutionFailure(output) {
+    const normalized = output.replaceAll("\\", "/");
+    const paths = testcasePythonPaths(normalized);
+    const generatedProviderPaths = paths.filter((item) => /testcase\/(?:helpers|factories)\//.test(item));
+    if (/fixture ['"][^'"]+['"] not found/i.test(normalized) && generatedProviderPaths.length > 0) {
+        return {
+            status: "REPAIRABLE",
+            kind: "missing-generated-fixture",
+            detail: "generated pytest fixture dependency or plugin registration is incomplete",
+            repairPaths: generatedProviderPaths,
+        };
+    }
+    return {
+        status: "BLOCKED",
+        kind: "unresolved-fixture-dependency",
+        detail: "fixture resolution failed without a safely attributable generated provider",
+        repairPaths: paths,
+    };
+}
 function classifyCollectionFailure(output) {
     const normalized = output.replaceAll("\\", "/");
     const blockedPatterns = [
@@ -134,14 +180,19 @@ function classifyCollectionFailure(output) {
 }
 export function assessBackendPytestCollection(input) {
     const items = collectionItems(input.stdout);
-    if (input.exitCode === 0) {
+    const fixtureResolution = input.fixtureResolution ?? { exitCode: 0, stdout: "fixture resolution assumed by direct assessor", stderr: "" };
+    if (input.exitCode === 0 && fixtureResolution.exitCode === 0) {
         return backendPytestCollectionFactsSchema.parse({
-            schemaId: "backend-test-pytest-collection-v2",
+            schemaId: "backend-test-pytest-collection-v3",
             phase: input.phase,
             status: "PASS",
             repairEligible: false,
             repairAttempt: input.phase === "final" ? 1 : 0,
             collectionAttempted: true,
+            fixtureResolutionAttempted: true,
+            fixtureResolutionStatus: "PASS",
+            fixtureResolutionExitCode: 0,
+            repairPaths: [],
             mappedScripts: input.inventory.mappedScripts,
             existingMappedScripts: input.inventory.mappedScripts,
             missingMappedScripts: [],
@@ -153,16 +204,55 @@ export function assessBackendPytestCollection(input) {
             findings: [],
             stdoutExcerpt: bounded(input.stdout),
             stderrExcerpt: bounded(input.stderr),
+            fixtureStdoutExcerpt: bounded(fixtureResolution.stdout),
+            fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
+        });
+    }
+    if (input.exitCode === 0) {
+        const classification = classifyFixtureResolutionFailure(`${fixtureResolution.stdout}\n${fixtureResolution.stderr}`);
+        return backendPytestCollectionFactsSchema.parse({
+            schemaId: "backend-test-pytest-collection-v3",
+            phase: input.phase,
+            status: classification.status,
+            repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
+            repairAttempt: input.phase === "final" ? 1 : 0,
+            collectionAttempted: true,
+            fixtureResolutionAttempted: true,
+            fixtureResolutionStatus: classification.status,
+            fixtureResolutionExitCode: fixtureResolution.exitCode,
+            repairPaths: classification.repairPaths,
+            mappedScripts: input.inventory.mappedScripts,
+            existingMappedScripts: input.inventory.mappedScripts,
+            missingMappedScripts: [],
+            assetFiles: input.inventory.assetFiles,
+            inputHashes: input.inventory.inputHashes,
+            pytestExitCode: input.exitCode,
+            collectedItemCount: items.length,
+            collectedItemIds: items,
+            findings: [{
+                    kind: classification.kind,
+                    classification: "test-asset-defect",
+                    repairability: classification.status === "REPAIRABLE" ? "repairable" : "blocked",
+                    detail: classification.detail,
+                }],
+            stdoutExcerpt: bounded(input.stdout),
+            stderrExcerpt: bounded(input.stderr),
+            fixtureStdoutExcerpt: bounded(fixtureResolution.stdout),
+            fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
         });
     }
     const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
     return backendPytestCollectionFactsSchema.parse({
-        schemaId: "backend-test-pytest-collection-v2",
+        schemaId: "backend-test-pytest-collection-v3",
         phase: input.phase,
         status: classification.status,
         repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
         repairAttempt: input.phase === "final" ? 1 : 0,
         collectionAttempted: true,
+        fixtureResolutionAttempted: false,
+        fixtureResolutionStatus: "NOT_RUN",
+        fixtureResolutionExitCode: null,
+        repairPaths: testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
         mappedScripts: input.inventory.mappedScripts,
         existingMappedScripts: input.inventory.mappedScripts,
         missingMappedScripts: [],
@@ -179,16 +269,22 @@ export function assessBackendPytestCollection(input) {
             }],
         stdoutExcerpt: bounded(input.stdout),
         stderrExcerpt: bounded(input.stderr),
+        fixtureStdoutExcerpt: "",
+        fixtureStderrExcerpt: "",
     });
 }
 export function assessMissingBackendPytestScripts(input) {
     return backendPytestCollectionFactsSchema.parse({
-        schemaId: "backend-test-pytest-collection-v2",
+        schemaId: "backend-test-pytest-collection-v3",
         phase: "initial",
         status: "REPAIRABLE",
         repairEligible: true,
         repairAttempt: 0,
         collectionAttempted: false,
+        fixtureResolutionAttempted: false,
+        fixtureResolutionStatus: "NOT_RUN",
+        fixtureResolutionExitCode: null,
+        repairPaths: [...input.missingMappedScripts],
         mappedScripts: [...input.mappedScripts],
         existingMappedScripts: [...input.existingMappedScripts],
         missingMappedScripts: [...input.missingMappedScripts],
@@ -205,6 +301,8 @@ export function assessMissingBackendPytestScripts(input) {
         })),
         stdoutExcerpt: "",
         stderrExcerpt: "",
+        fixtureStdoutExcerpt: "",
+        fixtureStderrExcerpt: "",
     });
 }
 export function renderBackendPytestCollectionReport(facts) {
@@ -219,6 +317,10 @@ export function renderBackendPytestCollectionReport(facts) {
         `- Repair attempt: ${facts.repairAttempt}`,
         `- Collection attempted: ${facts.collectionAttempted}`,
         `- Pytest exit code: ${facts.pytestExitCode ?? "not-run"}`,
+        `- Fixture resolution attempted: ${facts.fixtureResolutionAttempted}`,
+        `- Fixture resolution status: ${facts.fixtureResolutionStatus}`,
+        `- Fixture resolution exit code: ${facts.fixtureResolutionExitCode ?? "not-run"}`,
+        `- Repair paths: ${facts.repairPaths.join(", ") || "none"}`,
         `- Mapped scripts: ${facts.mappedScripts.length}`,
         `- Existing mapped scripts: ${facts.existingMappedScripts.length}`,
         `- Missing mapped scripts: ${facts.missingMappedScripts.length}`,
@@ -245,6 +347,18 @@ export function renderBackendPytestCollectionReport(facts) {
         facts.stderrExcerpt,
         "```",
         "",
+        "## Fixture Resolution stdout",
+        "",
+        "```text",
+        facts.fixtureStdoutExcerpt,
+        "```",
+        "",
+        "## Fixture Resolution stderr",
+        "",
+        "```text",
+        facts.fixtureStderrExcerpt,
+        "```",
+        "",
     ].join("\n");
 }
 export async function writeBackendPytestCollectionArtifacts(input) {
@@ -289,6 +403,47 @@ function assertSameInventory(expected, actual) {
             throw new Error(`backend pytest collection hash drift: ${file}`);
     }
 }
+export async function materializeBackendTestExecutionReadiness(input) {
+    if (input.effective.phase !== "effective" || input.effective.status !== "PASS" || input.effective.fixtureResolutionStatus !== "PASS") {
+        throw new Error("backend-test execution readiness requires effective collection and fixture-resolution PASS");
+    }
+    const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.effective.mappedScripts);
+    assertSameInventory(input.effective, current);
+    const status = input.scenarioParamStatus === "FAIL"
+        ? "BLOCKED"
+        : input.scenarioParamStatus === "PASS"
+            ? "PASS"
+            : "PARTIAL";
+    const readiness = backendTestExecutionReadinessSchema.parse({
+        schemaId: "backend-test-execution-readiness-v1",
+        status,
+        collectionStatus: "PASS",
+        fixtureResolutionStatus: "PASS",
+        scenarioParamStatus: input.scenarioParamStatus,
+        repairAttempts: {
+            collection: input.effective.repairAttempt,
+            scenarioParam: input.scenarioParamRepairAttempt,
+        },
+        mappedScripts: input.effective.mappedScripts,
+        collectedItemIds: input.effective.collectedItemIds,
+        fixtureIssues: input.effective.findings.filter((item) => /fixture/i.test(item.kind)).map((item) => item.detail),
+        assetHashes: input.effective.inputHashes,
+    });
+    const contractsDir = path.join(input.runDir, "contracts");
+    await mkdir(contractsDir, { recursive: true });
+    await writeFile(path.join(contractsDir, "backend-test-execution-readiness.json"), `${JSON.stringify(readiness, null, 2)}\n`, "utf8");
+    return readiness;
+}
+export async function readBackendTestExecutionReadiness(filePath) {
+    return backendTestExecutionReadinessSchema.parse(JSON.parse(await readFile(filePath, "utf8")));
+}
+export async function assertBackendTestExecutionReadinessFresh(workspaceRoot, readiness) {
+    if (!["PASS", "PARTIAL"].includes(readiness.status)) {
+        throw new Error(`backend pytest execution readiness is ${readiness.status}`);
+    }
+    const current = await buildBackendPytestAssetInventory(workspaceRoot, readiness.mappedScripts);
+    assertSameInventory({ mappedScripts: readiness.mappedScripts, assetFiles: Object.keys(readiness.assetHashes), inputHashes: readiness.assetHashes }, current);
+}
 export async function assertBackendPytestCollectionFresh(workspaceRoot, effective) {
     if (effective.phase !== "effective" || effective.status !== "PASS") {
         throw new Error("backend pytest execution requires effective collection PASS facts");