@tea-agent/loop-agent 0.42.0-next.5 → 0.42.0-next.7

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

@@ -7,12 +7,72 @@ import { fetchJson } from "../api.js";
 import {
 	uiState,
 	updateDagTimelineViewportState,
-	computeFollowLatest,
 } from "../state.js";
 
 /** Default visible lines for tool result preview before expand. */
 export const TOOL_RESULT_PREVIEW_LINES = 20;
 
+function isTimelineAutoScrollEnabled() {
+	return uiState.dagTimelineAutoScrollEnabled !== false;
+}
+
+function scrollTimelineToLatest(content) {
+	content.scrollLeft = 0;
+	content.scrollTop = content.scrollHeight;
+	uiState.dagTimelineViewportState = updateDagTimelineViewportState(
+		uiState.dagTimelineViewportState,
+		uiState.currentDagRunId,
+		content.dataset.nodeId,
+		content.scrollLeft,
+		content.scrollTop,
+		true,
+	);
+}
+
+/** Floating, explicit live-follow control for the execution-record viewport. */
+export function createTimelineAutoScrollControl(content) {
+	const dock = el("div", "process-timeline-autoscroll-dock");
+	const button = document.createElement("button");
+	button.type = "button";
+	const signal = el("span", "process-timeline-autoscroll-signal");
+	signal.setAttribute("aria-hidden", "true");
+	const icon = el("i", "ri-arrow-down-line");
+	icon.setAttribute("aria-hidden", "true");
+	button.appendChild(signal);
+	button.appendChild(icon);
+
+	const sync = () => {
+		const enabled = isTimelineAutoScrollEnabled();
+		const actionLabel = enabled ? "关闭自动滚动" : "自动滚动";
+		button.className = `process-timeline-autoscroll${enabled ? " is-active" : ""}`;
+		button.setAttribute("aria-pressed", String(enabled));
+		button.setAttribute("aria-label", actionLabel);
+		button.setAttribute("data-tooltip", actionLabel);
+		icon.className = enabled ? "ri-arrow-down-line" : "ri-pause-mini-fill";
+	};
+
+	button.addEventListener("click", () => {
+		const enabled = !isTimelineAutoScrollEnabled();
+		uiState.dagTimelineAutoScrollEnabled = enabled;
+		if (enabled) scrollTimelineToLatest(content);
+		else {
+			uiState.dagTimelineViewportState = updateDagTimelineViewportState(
+				uiState.dagTimelineViewportState,
+				uiState.currentDagRunId,
+				content.dataset.nodeId,
+				content.scrollLeft,
+				content.scrollTop,
+				false,
+			);
+		}
+		sync();
+	});
+
+	sync();
+	dock.appendChild(button);
+	return dock;
+}
+
 export function normalizeSessionEventFields(event) {
 	if (!event || typeof event !== "object") return {};
 	const args = event.args ?? event.input ?? event.toolInput;
@@ -951,6 +1011,7 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 	});
 	toolbar.appendChild(exportBtn);
 	content.appendChild(toolbar);
+	content.appendChild(createTimelineAutoScrollControl(content));
 
 	const timelineItems = filterExecutionRecordItems(
 		buildRichTimelineItems(visible.events, { showProtocol }),
@@ -1030,23 +1091,18 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 	content.addEventListener(
 		"scroll",
 		() => {
-			const followLatest = computeFollowLatest(
-				content.scrollTop,
-				content.scrollHeight,
-				content.clientHeight,
-			);
 			uiState.dagTimelineViewportState = updateDagTimelineViewportState(
 				uiState.dagTimelineViewportState,
 				uiState.currentDagRunId,
 				nodeId,
 				content.scrollLeft,
 				content.scrollTop,
-				followLatest,
+				isTimelineAutoScrollEnabled(),
 			);
 		},
 		{ passive: true },
 	);
-	if (timelineState?.followLatest ?? true) {
+	if (isTimelineAutoScrollEnabled()) {
 		content.scrollLeft = timelineState?.scrollLeft ?? 0;
 		content.scrollTop = content.scrollHeight;
 	} else {
@@ -1058,6 +1114,7 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 function rerenderSessionTimeline(content, nodeId, options) {
 	const scrollTop = content.scrollTop;
 	const scrollLeft = content.scrollLeft;
+	const autoScrollEnabled = isTimelineAutoScrollEnabled();
 	const preserved = [...content.children].filter((child) =>
 		String(child.className ?? "")
 			.split(/\s+/)
@@ -1066,6 +1123,8 @@ function rerenderSessionTimeline(content, nodeId, options) {
 	while (content.firstChild) content.removeChild(content.firstChild);
 	for (const child of preserved) content.appendChild(child);
 	renderSessionTimeline(content, nodeId, options);
-	content.scrollTop = scrollTop;
-	content.scrollLeft = scrollLeft;
+	if (!autoScrollEnabled) {
+		content.scrollTop = scrollTop;
+		content.scrollLeft = scrollLeft;
+	}
 }

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

@@ -36,7 +36,12 @@ import {
 	markdownLinkHref,
 	formatLedgerSummary,
 } from "../format.js";
-import { parseRoute, navigate, buildHashPath } from "../router.js";
+import {
+	parseRoute,
+	navigate,
+	buildHashPath,
+	inspectPathToCanonicalHref,
+} from "../router.js";
 import {
 	fetchJson,
 	fetchJsonResult,
@@ -133,7 +138,7 @@ export async function renderTaskDetail(featureId, taskId) {
 					if (!c?.featureId || !c?.taskId) continue;
 					const path = `/feature/${encodeURIComponent(c.featureId)}/task/${encodeURIComponent(c.taskId)}`;
 					const a = el("a", "object-link", `${c.featureId}::${c.taskId}`);
-					a.href = `#${path}`;
+					a.href = inspectPathToCanonicalHref(path);
 					a.addEventListener("click", (e) => {
 						e.preventDefault();
 						navigate(path);

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

@@ -1463,7 +1463,7 @@ for top in ast.walk(tree):
                     returned_names.add(node.value.id)
             if isinstance(node,ast.Call):
                 for keyword in node.keywords:
-                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
+                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
                         transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
                 if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
                     candidate=node.args[1]
@@ -1484,7 +1484,7 @@ for top in ast.walk(tree):
         for node in ast.walk(top):
             if not isinstance(node,ast.Call): continue
             for keyword in node.keywords:
-                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
+                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
                     transport_shapes.append(assigned[keyword.value.id])
         if candidates: FUNCTION_PAYLOADS[top.name]=candidates
         if transport_shapes: FUNCTION_TRANSPORT_SHAPES[top.name]=transport_shapes
@@ -1540,8 +1540,9 @@ def literal(node):
         return repr(node.value)
     return None
 
-def collect_dict(node, prefix, paths, values):
+def collect_dict(node, prefix, paths, values, parameters=None):
     if not isinstance(node, ast.Dict): return
+    parameters = parameters or {}
     for key,value in zip(node.keys,node.values):
         if not isinstance(key, ast.Constant) or not isinstance(key.value,str): continue
         # Ignore writer helper/meta keys that are not DTO request fields.
@@ -1551,12 +1552,16 @@ def collect_dict(node, prefix, paths, values):
         paths.add(current)
         lv=literal(value)
         if lv is not None: values.setdefault(current,set()).add(lv)
-        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values)
+        elif isinstance(value, ast.Name) and value.id in parameters:
+            for bound in parameters[value.id]:
+                bound_lv=literal(bound)
+                if bound_lv is not None: values.setdefault(current,set()).add(bound_lv)
+        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values,parameters)
         elif isinstance(value,(ast.List,ast.Tuple)):
             for item in value.elts:
-                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values)
+                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values,parameters)
 
-PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body'}
+PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'}
 
 def shape_only(node):
     if isinstance(node,ast.Dict):
@@ -1637,6 +1642,7 @@ def decorator_payload_nodes(parameters,assigned):
 
 def decorator_payload_nodes_by_tp(fn,assigned):
     result={}
+    function_payload_nodes=payload_nodes(fn)
     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
@@ -1653,9 +1659,11 @@ def decorator_payload_nodes_by_tp(fn,assigned):
             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)
+            payload_nodes_for_tp=decorator_payload_nodes(parameters,assigned)
+            if not payload_nodes_for_tp:
+                payload_nodes_for_tp=function_payload_nodes
             paths=set(); values={}
-            for payload_node in payload_nodes: collect_dict(payload_node,'',paths,values)
+            for payload_node in payload_nodes_for_tp: collect_dict(payload_node,'',paths,values,parameters)
             result[tp]={key:sorted(items) for key,items in sorted(values.items())}
     return result
 
@@ -1729,8 +1737,8 @@ for fn in ast.walk(tree):
     if isinstance(fn,(ast.FunctionDef,ast.AsyncFunctionDef)) and fn.name.startswith('test_'):
         paths=set(); values={}
         fallback_paths=set(); fallback_values={}
-        for node in payload_nodes(fn): collect_dict(node,'',paths,values)
-        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values)
+        for node in payload_nodes(fn): collect_dict(node,'',paths,values,{})
+        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values,{})
         out[fn.name]={
             'paths':sorted(paths),
             'values':{key:sorted(items) for key,items in sorted(values.items())},
@@ -1782,14 +1790,39 @@ function metadataTestPoints(region, label) {
     const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
     return orderedUnique(match?.[1]?.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
 }
+function isPytestDecoratorOrContinuationLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith("#"))
+        return true;
+    if (trimmed.startsWith("@"))
+        return true;
+    // Multi-line decorator argument lists: @pytest.mark.parametrize(\n    "x", [\n      pytest.param(..., id="TP-...")\n    ]\n)
+    return /^[\]\),]/.test(trimmed) || /[\(\[{,]$/.test(trimmed) || /\bpytest\.param\s*\(/.test(trimmed);
+}
 function pytestFunctionRegionStart(source, functionIndex) {
     let regionStart = source.lastIndexOf("\n", functionIndex - 1) + 1;
     let cursor = regionStart;
+    let blankRun = 0;
     while (cursor > 0) {
         const previousEnd = cursor - 1;
         const previousStart = source.lastIndexOf("\n", previousEnd - 1) + 1;
         const previous = source.slice(previousStart, previousEnd).replace(/\r$/, "");
-        if (!previous.trim())
+        const trimmed = previous.trim();
+        if (!trimmed) {
+            blankRun += 1;
+            // Keep walking across a small blank gap so a decorator is still bound to
+            // the following test when writers insert one empty line before `def`.
+            if (blankRun > 2)
+                break;
+            cursor = previousStart;
+            continue;
+        }
+        blankRun = 0;
+        if (/^(?:async\s+)?def\s+/.test(trimmed) || /^(?:async\s+)?class\s+/.test(trimmed))
+            break;
+        if (!isPytestDecoratorOrContinuationLine(previous))
             break;
         regionStart = previousStart;
         cursor = previousStart;
@@ -1819,12 +1852,14 @@ function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
 }
 function pytestParameterCollections(source) {
     const collections = new Map();
-    for (const match of source.matchAll(/^(_?[A-Z][A-Z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
+    for (const match of source.matchAll(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
         const explicitIds = [...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]);
         const factoryIds = explicitIds.length === 0
             ? [...match[2].matchAll(/["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])
             : [];
-        collections.set(match[1], orderedUnique([...explicitIds, ...factoryIds]));
+        const ids = orderedUnique([...explicitIds, ...factoryIds]);
+        if (ids.length > 0)
+            collections.set(match[1], ids);
     }
     return collections;
 }
@@ -1886,6 +1921,12 @@ function normalizePythonLiteralValue(value) {
     if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
         return trimmed.slice(1, -1);
     }
+    if (trimmed === "True")
+        return "true";
+    if (trimmed === "False")
+        return "false";
+    if (trimmed === "None")
+        return "null";
     return trimmed;
 }
 function intentionalInvalidEnumVariant(input) {
@@ -1930,13 +1971,15 @@ function assessPayloadContract(testCase, refs) {
             : [];
     const enumMismatches = [];
     for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const aggregated = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const byTestPoint = orderedUnique(refs.flatMap((item) => Object.values(item.payloadValuesByTestPoint).flatMap((values) => values[field] ?? [])));
+        const observed = orderedUnique([...aggregated, ...byTestPoint]);
         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))
+                .filter(([, values]) => (values[field] ?? []).some((itemValue) => itemValue === rawValue || normalizePythonLiteralValue(itemValue) === value))
                 .map(([testPoint]) => testPoint)));
             const intentionallyInvalid = associatedTestPoints.length > 0 && associatedTestPoints.every((testPoint) => intentionalInvalidEnumVariant({ testCase, testPoint, field, observedValue: rawValue, allowed }));
             if (!intentionallyInvalid)

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

@@ -0,0 +1,106 @@
+/**
+ * Deterministic backend-test plan protocol helpers.
+ *
+ * English canonical `##` headings remain the parse authority. Known Chinese
+ * aliases are rewritten only as an exact whole-line `##` heading, never as
+ * prose. Partition slot coverage follows Scheme A: Case count may be smaller
+ * than the enum count, but every exact `TP-SP-...` slot must appear as an
+ * independent variant Test Point.
+ */
+export const BACKEND_TEST_PLAN_HEADING_ALIASES = {
+    "模块索引": "Module Index",
+    "覆盖范围": "Coverage Scope",
+    "覆盖矩阵": "Coverage Matrix",
+    "场景分区": "Scenario Partitions",
+};
+export const BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID = "backend-test-scenario-partition-slots-v1";
+const CANONICAL_HEADING_LINE = /^##\s+(Module Index|Coverage Scope|Coverage Matrix|Scenario Partitions)\s*$/;
+const ALIAS_HEADING_LINE = /^##\s+(模块索引|覆盖范围|覆盖矩阵|场景分区)\s*$/;
+const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b/;
+const SECTION_HEADING = /^###\s+/;
+const TEST_POINT_RE = /\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
+const VARIANT_LABEL = /变体测试点|Variant Test Points/i;
+const FORBIDDEN_SLOT_ALIASES = new Set(["SINGLE", "MULTIPLE"]);
+export function canonicalizeBackendTestPlanProtocolHeadings(markdown) {
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const rewrittenHeadings = [];
+    const next = lines.map((line) => {
+        const trimmed = line.trim();
+        const alias = ALIAS_HEADING_LINE.exec(trimmed);
+        if (!alias)
+            return line;
+        const canonical = BACKEND_TEST_PLAN_HEADING_ALIASES[alias[1]];
+        rewrittenHeadings.push(canonical);
+        return `## ${canonical}`;
+    });
+    return {
+        markdown: next.join("\n"),
+        changed: rewrittenHeadings.length > 0,
+        rewrittenHeadings,
+    };
+}
+export function countCanonicalPlanHeading(markdown, heading) {
+    const canonical = canonicalizeBackendTestPlanProtocolHeadings(markdown).markdown;
+    return canonical
+        .split("\n")
+        .filter((line) => line.trim() === `## ${heading}`).length;
+}
+function orderedUnique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function collectSectionTokens(body, headingNeedle) {
+    const lines = body.split("\n");
+    const start = lines.findIndex((line) => line.trim() === `### ${headingNeedle}`);
+    if (start < 0)
+        return [];
+    const tokens = [];
+    for (const line of lines.slice(start + 1)) {
+        if (SECTION_HEADING.test(line) || CASE_HEADING.test(line.trim()))
+            break;
+        tokens.push(...(line.match(TEST_POINT_RE) ?? []));
+    }
+    return tokens;
+}
+function collectLabeledTokens(body, label) {
+    return body
+        .split("\n")
+        .filter((line) => label.test(line))
+        .flatMap((line) => line.match(TEST_POINT_RE) ?? []);
+}
+export function collectMarkdownPartitionSlotCoverage(markdown, requiredVariantSlots) {
+    const declaredTestPoints = [];
+    const variantTestPoints = [];
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const headingIndexes = lines.flatMap((line, index) => CASE_HEADING.test(line.trim()) ? [index] : []);
+    for (let i = 0; i < headingIndexes.length; i += 1) {
+        const start = headingIndexes[i];
+        const end = headingIndexes[i + 1] ?? lines.length;
+        const body = lines.slice(start, end).join("\n");
+        declaredTestPoints.push(...collectSectionTokens(body, "测试点"));
+        variantTestPoints.push(...collectLabeledTokens(body, VARIANT_LABEL));
+    }
+    const declaredSet = new Set(orderedUnique(declaredTestPoints));
+    const variantSet = new Set(orderedUnique(variantTestPoints));
+    const required = requiredVariantSlots.filter((slotId) => !FORBIDDEN_SLOT_ALIASES.has(slotId));
+    return {
+        declaredTestPoints: orderedUnique(declaredTestPoints),
+        variantTestPoints: orderedUnique(variantTestPoints),
+        missingFromDeclared: required.filter((slotId) => !declaredSet.has(slotId)),
+        missingFromVariant: required.filter((slotId) => !variantSet.has(slotId)),
+    };
+}
+export function isForbiddenPartitionSlotAlias(token) {
+    return FORBIDDEN_SLOT_ALIASES.has(token.trim().toUpperCase());
+}
+export function lookupRequiredVariantSlotsForMarkdownPath(inventory, markdownPath) {
+    if (!inventory)
+        return [];
+    const stem = markdownPath
+        .replace(/\\/g, "/")
+        .replace(/^.*\//, "")
+        .replace(/\.md$/i, "");
+    return inventory.modules.find((item) => item.stem === stem)?.requiredVariantSlots ?? [];
+}
+export function isCanonicalPlanHeadingLine(line) {
+    return CANONICAL_HEADING_LINE.test(line.trim());
+}

package/dist/workflows/dag/backend-test-scenario-param.js

@@ -1116,7 +1116,11 @@ function compareIntent(intent, observed, bound, example, field) {
                             ? "UNDETERMINED"
                             : "MISMATCH";
                 }
-                return literal === expected
+                const comparableObserved = observed.kind === "boolean"
+                    ? (observed.literal === "True" ? "true" : observed.literal === "False" ? "false" : literal)
+                    : literal;
+                const comparableExpected = expected === "True" ? "true" : expected === "False" ? "false" : expected;
+                return comparableObserved === comparableExpected
                     ? "MATCH"
                     : observed.kind === "unknown"
                         ? "UNDETERMINED"
@@ -1207,6 +1211,12 @@ function boundedScenarioText(value, logicalLength) {
     const suffix = `<truncated length=${logicalLength ?? value.length}>`;
     return `${value.slice(0, Math.max(0, MAX_PERSISTED_SCENARIO_TEXT - suffix.length - 3))}...${suffix}`;
 }
+/** Facts schema forbids negative lengths. Internal helper sentinels stay in-memory only. */
+function persistedObservedLength(length) {
+    return typeof length === "number" && Number.isFinite(length) && length >= 0
+        ? Math.trunc(length)
+        : undefined;
+}
 function localPythonFunctionRegion(source, functionName) {
     const escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const startMatch = new RegExp(`^def\\s+${escaped}\\s*\\(`, "m").exec(source);
@@ -1449,11 +1459,12 @@ function scenarioParamDiagnosticValues(intent, observed) {
     const expectedRaw = intent.startsWith("custom-literal:")
         ? intent.slice("custom-literal:".length)
         : intent === "unknown" ? undefined : intent;
+    const persistedLength = persistedObservedLength(observed.length);
     return {
         expectedRaw,
-        observedRaw: boundedScenarioText(observed.text, observed.length),
+        observedRaw: boundedScenarioText(observed.text, persistedLength),
         expectedNormalized: expectedRaw === undefined ? undefined : normalizeCustomLiteralExpected(expectedRaw).slice(0, 512),
-        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), observed.length),
+        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), persistedLength),
     };
 }
 export async function assessBackendScenarioParamConsistency(input) {
@@ -1539,8 +1550,8 @@ export async function assessBackendScenarioParamConsistency(input) {
                 tpId,
                 field: inferred.field,
                 intent: inferred.intent,
-                observed: boundedScenarioText(observed.text, observed.length),
-                observedLength: observed.length,
+                observed: boundedScenarioText(observed.text, persistedObservedLength(observed.length)),
+                observedLength: persistedObservedLength(observed.length),
                 status,
                 repairability,
                 reasonCode: status === "MATCH" ? "SCENARIO_PARAM_MATCH" : status === "MISMATCH" ? "SCENARIO_PARAM_MISMATCH" : "SCENARIO_PARAM_UNDETERMINED",

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
 import { canonicalizeBackendTestMarkdownTestPointBindings, inspectBackendTestMarkdownTestPointBindings, } from "./backend-test-case-coverage-analysis.js";
+import { BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID, canonicalizeBackendTestPlanProtocolHeadings, collectMarkdownPartitionSlotCoverage, lookupRequiredVariantSlotsForMarkdownPath, } from "./backend-test-plan-protocol.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -127,10 +128,8 @@ function looksLikeValidModuleStem(raw) {
     return moduleStemInvalidReason(raw) === undefined;
 }
 function extractCanonicalModuleIndexSection(readme) {
-    const lines = readme
-        .replaceAll("\r\n", "\n")
-        .replaceAll("\r", "\n")
-        .split("\n");
+    const canonical = canonicalizeBackendTestPlanProtocolHeadings(readme).markdown;
+    const lines = canonical.split("\n");
     const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
     if (headings.length === 0) {
         return { section: "", structureIssues: ["missing-module-index"] };
@@ -519,6 +518,19 @@ export async function loadBackendTestWriterProgressForRetry(runDir, taskId) {
  * child's own target file(s): md children are checked for structural
  * completeness, pytest children for parseability. Sibling modules are ignored.
  */
+async function loadScenarioPartitionSlotInventory(runDir) {
+    if (!runDir)
+        return undefined;
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "contracts", "backend-test-scenario-partition-slots.json"), "utf8"));
+        if (raw?.schemaId !== BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID)
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function assessBackendTestShardChildCompleteness(input) {
     const role = input.role;
     const targetPaths = input.writeSet
@@ -531,6 +543,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
     let canonicalizationOutcome = role === "md-generate" ? "already-canonical" : undefined;
     let canonicalizedTestPointCount = 0;
     let lightweightRepairEligible = false;
+    const slotInventory = role === "md-generate"
+        ? await loadScenarioPartitionSlotInventory(input.runDir)
+        : undefined;
     for (const target of targetPaths) {
         // Rendered map-child writeSet entries are concrete (e.g.
         // testcase/md/health.md / testcase/test_orders.py); glob-only entries are
@@ -565,6 +580,27 @@ export async function assessBackendTestShardChildCompleteness(input) {
                 .filter((entry) => entry.unclassifiedTestPoints.length > 0 || entry.duplicateBindingTestPoints.length > 0)
                 .map((entry) => entry.caseId);
             const structural = moduleStructurallyComplete(body);
+            const requiredSlots = lookupRequiredVariantSlotsForMarkdownPath(slotInventory, target);
+            const slotCoverage = requiredSlots.length > 0
+                ? collectMarkdownPartitionSlotCoverage(body, requiredSlots)
+                : undefined;
+            const missingSlots = orderedUnique([
+                ...(slotCoverage?.missingFromDeclared ?? []),
+                ...(slotCoverage?.missingFromVariant ?? []),
+            ]);
+            if (missingSlots.length > 0) {
+                lightweightRepairEligible = true;
+                if (!brokenPaths.includes(target))
+                    brokenPaths.push(target);
+                issues.push({
+                    code: "T5",
+                    path: target,
+                    detail: `incomplete-partition-slot-set: missing ${missingSlots.join(", ")}; Scheme A requires each exact slot as an independent variant Test Point, not Case count or SINGLE/MULTIPLE aliases`,
+                    recoverable: true,
+                    affectedCases: afterBindings.map((entry) => entry.caseId),
+                    testPointIds: missingSlots,
+                });
+            }
             if (!structural.ok) {
                 lightweightRepairEligible = bindingCases.length > 0;
                 if (bindingCases.length > 0)
@@ -651,7 +687,7 @@ export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layou
     }
     else {
         actualPaths.push(readmeRel);
-        readme = await readFile(readmePath, "utf8");
+        readme = canonicalizeBackendTestPlanProtocolHeadings(await readFile(readmePath, "utf8")).markdown;
         if (!readme.includes("## Coverage Scope")) {
             brokenPaths.push(readmeRel);
             issues.push({
@@ -985,7 +1021,7 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot, layout)
     }
     else {
         actualPaths.push(planReadmeRel);
-        const readme = await readFile(readmePath, "utf8");
+        const readme = canonicalizeBackendTestPlanProtocolHeadings(await readFile(readmePath, "utf8")).markdown;
         if (!readme.includes("## Coverage Scope")) {
             brokenPaths.push(planReadmeRel);
             issues.push({

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

@@ -659,10 +659,13 @@ function latestCommittedScoutTargetSurface(records) {
 }
 /**
  * Scout owns discovery. A complete fact must explicitly say so, name at least
- * one target candidate, leave no unresolved paths, and include fresh runtime
- * evidence for a named target file. This deliberately accepts an empty test
- * path list: some small changes have no existing focused test file, but they
- * still need a proven implementation entrypoint.
+ * one target candidate and leave no unresolved paths. Existing surfaces must
+ * include fresh runtime evidence for a named target path. Greenfield
+ * surfaces are the one explicit exception: when runtime-injected source
+ * declarations prove that every named path was specified by the task source,
+ * all paths may be future (not yet on disk). This keeps create-new work
+ * possible without allowing Scout to invent an arbitrary path under the
+ * writer boundary. An empty test path list remains valid.
  */
 export function readCompleteScoutTargetSurface(records) {
     const fact = latestCommittedScoutTargetSurface(records);
@@ -704,11 +707,35 @@ export function readCompleteScoutTargetSurface(records) {
             .map((item) => asString(item.path))
             .filter(Boolean)
         : []);
-    if (!namedPaths.some((candidate) => freshPaths.has(candidate)))
+    const pathEvidence = Array.isArray(fact.pathEvidence)
+        ? fact.pathEvidence.filter(isRecord)
+        : [];
+    const hasSourceDeclarationLedger = Array.isArray(fact.sourceDeclaredPaths);
+    const undeclaredFuturePaths = hasSourceDeclarationLedger
+        ? namedPaths.filter((candidate) => {
+            const evidence = pathEvidence.find((item) => asString(item.path) === candidate);
+            return evidence?.fresh !== true && evidence?.sourceDeclared !== true;
+        })
+        : [];
+    if (undeclaredFuturePaths.length > 0)
         return {
             ok: false,
-            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path; record_target_surface enriches every declared entrypoint/implementation/test path against the real workspace, so at least one named path must exist on disk (an existing directory counts; a file to be created later cannot count)",
+            reason: `frontend scout target surface has future paths not declared by the task source: ${undeclaredFuturePaths.join(", ")}; test path is not declared by the task source, so do not guess test/ vs tests/ or other target directories`,
         };
+    if (!namedPaths.some((candidate) => freshPaths.has(candidate))) {
+        const allPathsAreSourceDeclaredFuturePaths = hasSourceDeclarationLedger &&
+            namedPaths.length > 0 &&
+            namedPaths.every((candidate) => {
+                const evidence = pathEvidence.find((item) => asString(item.path) === candidate);
+                return evidence?.fresh !== true && evidence?.sourceDeclared === true;
+            });
+        if (allPathsAreSourceDeclaredFuturePaths)
+            return { ok: true, surface };
+        return {
+            ok: false,
+            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path; greenfield exceptions require runtime-injected source declarations for every future path",
+        };
+    }
     return { ok: true, surface };
 }
 /** Paths with Scout ownership that Plan may read for a specific decision. */