@tea-agent/loop-agent 0.38.2 → 0.38.4

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

@@ -90,6 +90,7 @@ import {
 	closeDagInspector,
 	selectDagNode,
 	renderDagInspector,
+	mergeNodeProcess,
 } from "./dag-inspector.js";
 import { mergeSessionEvents } from "./session-timeline.js";
 
@@ -451,13 +452,19 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	nodesEl.scrollLeft = nodesScrollLeft;
 
 	if (uiState.dagInspectorOpen && uiState.selectedDagNodeId) {
+		const selectedNode = nodes.find(
+			(node) => node.nodeId === uiState.selectedDagNodeId,
+		);
 		if (!uiState.sessionEventIdentity) {
 			uiState.sessionEventIdentity = makeSessionEventIdentity(
 				dagRunId,
 				uiState.selectedDagNodeId,
 			);
 		}
-		await mergeSessionEvents(dagRunId, uiState.selectedDagNodeId);
+		await Promise.all([
+			mergeSessionEvents(dagRunId, uiState.selectedDagNodeId),
+			selectedNode ? mergeNodeProcess(dagRunId, selectedNode) : Promise.resolve(),
+		]);
 	}
 	renderDagInspector(
 		dagRunId,

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

@@ -101,11 +101,14 @@ export async function renderFailures() {
 
 	if (tasks.length === 0) {
 		clearNode(listEl);
+		// 2026-08-22 (B-FIND-02): 空态文案与静态 #failures-empty / 页面标题
+		// 「异常 Task」保持一致；旧文案「当前没有失败或阻塞的 Task。」与静态
+		// HTML 及回归目录 AC-FE-INS-004 漂移，导致 frontend-test 字面 find 0 命中。
 		if (emptyEl) {
 			emptyEl.hidden = false;
-			mountViewState(emptyEl, "empty", "当前没有失败或阻塞的 Task。");
+			mountViewState(emptyEl, "empty", "当前没有异常 Task");
 		} else {
-			mountViewState(listEl, "empty", "当前没有失败或阻塞的 Task。");
+			mountViewState(listEl, "empty", "当前没有异常 Task");
 		}
 		return;
 	}

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

@@ -250,6 +250,54 @@ export function buildSessionTimelineItems(events) {
 	return items;
 }
 
+/**
+ * Split a node's shared session-events log into per-attempt segments. Every
+ * attempt appends one agent run beginning with agent_start; events recorded
+ * before the first agent_start (defensive) stay in an implicit first segment.
+ */
+export function splitSessionEventsByAttempt(events) {
+	const segments = [];
+	let current = null;
+	for (const event of events) {
+		if (typeof event?.type === "string" && event.type === "agent_start") {
+			current = [];
+			segments.push(current);
+		}
+		if (current === null) {
+			current = [];
+			segments.push(current);
+		}
+		current.push(event);
+	}
+	return segments;
+}
+
+/**
+ * Resolve the events visible in the「执行过程」tab for the selected execution
+ * key. attempt-N shows only that attempt's segment when the shared log carries
+ * multiple attempts; other keys (pass-N, null) keep the full stream.
+ */
+export function resolveTimelineVisibleEvents(events, executionKey) {
+	const match =
+		typeof executionKey === "string"
+			? /^attempt-(\d+)$/.exec(executionKey)
+			: null;
+	if (!match) return { events, note: null };
+	const segments = splitSessionEventsByAttempt(events);
+	if (segments.length <= 1) return { events, note: null };
+	const requested = Number(match[1]);
+	if (requested >= 1 && requested <= segments.length) {
+		return {
+			events: segments[requested - 1],
+			note: `已按第 ${requested} 次执行过滤 · 共 ${segments.length} 次执行`,
+		};
+	}
+	return {
+		events,
+		note: `未检测到第 ${requested} 次执行的边界（共 ${segments.length} 次执行），暂显示全部事件`,
+	};
+}
+
 /**
  * Build rich timeline items: merge tool start/end by toolCallId, collapse
  * protocol noise, surface turn thinking/text without dumping agent_end.messages.
@@ -439,12 +487,25 @@ function ensureOpenDetailsSet() {
 	return uiState.sessionTimelineOpenDetails;
 }
 
-function bindDetailsToggle(details, detailKey) {
+function closedDetailKey(detailKey) {
+	return `${detailKey}::user-closed`;
+}
+
+function bindDetailsToggle(details, detailKey, defaultOpen = false) {
 	const openSet = ensureOpenDetailsSet();
-	if (openSet.has(detailKey)) details.open = true;
+	if (defaultOpen) {
+		if (!openSet.has(closedDetailKey(detailKey))) details.open = true;
+	} else if (openSet.has(detailKey)) {
+		details.open = true;
+	}
 	details.addEventListener("toggle", () => {
-		if (details.open) openSet.add(detailKey);
-		else openSet.delete(detailKey);
+		if (details.open) {
+			openSet.add(detailKey);
+			openSet.delete(closedDetailKey(detailKey));
+		} else {
+			openSet.delete(detailKey);
+			openSet.add(closedDetailKey(detailKey));
+		}
 	});
 }
 
@@ -599,7 +660,7 @@ function renderProtocolCard(item) {
 	const details = document.createElement("details");
 	details.className = "process-timeline-details";
 	details.dataset.detailKey = item.detailKey;
-	bindDetailsToggle(details, item.detailKey);
+	bindDetailsToggle(details, item.detailKey, true);
 	const summary = document.createElement("summary");
 	summary.className = "process-timeline-summary";
 	summary.textContent = `消息收发 · ${item.protocolCount} 条协议事件`;
@@ -644,7 +705,7 @@ export async function mergeSessionEvents(dagRunId, nodeId) {
 	}
 }
 
-export function renderSessionTimeline(content, nodeId) {
+export function renderSessionTimeline(content, nodeId, options = {}) {
 	content.dataset.dagRunId = uiState.currentDagRunId ?? "";
 	content.dataset.nodeId = nodeId ?? "";
 	content.classList.add("process-timeline-scroll");
@@ -653,6 +714,14 @@ export function renderSessionTimeline(content, nodeId) {
 		return;
 	}
 
+	const visible = resolveTimelineVisibleEvents(
+		uiState.sessionEvents,
+		options.executionKey,
+	);
+	if (visible.note) {
+		content.appendChild(el("p", "process-timeline-note", visible.note));
+	}
+
 	const showProtocol = Boolean(uiState.sessionTimelineShowProtocol);
 	const toolbar = el("div", "process-timeline-toolbar");
 	const protocolToggle = document.createElement("button");
@@ -668,17 +737,17 @@ export function renderSessionTimeline(content, nodeId) {
 		const scrollTop = parent.scrollTop;
 		const scrollLeft = parent.scrollLeft;
 		while (parent.firstChild) parent.removeChild(parent.firstChild);
-		renderSessionTimeline(parent, nodeId);
+		renderSessionTimeline(parent, nodeId, options);
 		parent.scrollTop = scrollTop;
 		parent.scrollLeft = scrollLeft;
 	});
 	toolbar.appendChild(protocolToggle);
 	content.appendChild(toolbar);
 
-	const timelineItems = buildRichTimelineItems(uiState.sessionEvents, {
+	const timelineItems = buildRichTimelineItems(visible.events, {
 		showProtocol,
 	});
-	const hasEventTimes = uiState.sessionEvents.some((event) =>
+	const hasEventTimes = visible.events.some((event) =>
 		Boolean(sessionEventTimestamp(event)),
 	);
 	if (!hasEventTimes) {

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

@@ -5,7 +5,7 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
-import { assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
+import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.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;
@@ -486,6 +486,55 @@ export async function extractBackendTestOpenApiRules(input) {
     }
     return rules.sort((left, right) => left.ruleKey.localeCompare(right.ruleKey));
 }
+export async function extractBackendTestOpenApiPartitionAxes(input) {
+    const axes = [];
+    const seen = new Set();
+    for (const referencePath of input.sourceBinding.referencePaths) {
+        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
+        let document;
+        try {
+            const parsed = YAML.parse(await readFile(physicalPath, "utf8"));
+            if (!isRecord(parsed) || !isRecord(parsed.paths))
+                continue;
+            document = parsed;
+        }
+        catch {
+            continue;
+        }
+        for (const [apiPath, pathItem] of Object.entries(document.paths)) {
+            if (!isRecord(pathItem))
+                continue;
+            const operation = pathItem.get;
+            if (!isRecord(operation))
+                continue;
+            const parameterValues = [
+                ...(Array.isArray(pathItem.parameters) ? pathItem.parameters : []),
+                ...(Array.isArray(operation.parameters) ? operation.parameters : []),
+            ];
+            for (const rawParameter of parameterValues) {
+                const parameter = resolveOpenApiSchema(document, rawParameter);
+                if (!parameter || typeof parameter.name !== "string")
+                    continue;
+                const location = parameter.in === "path" ? "path" : parameter.in === "query" ? "query" : undefined;
+                if (!location)
+                    continue;
+                const property = resolveOpenApiSchema(document, parameter.schema);
+                const enumValues = property && Array.isArray(property.enum) ? property.enum.map(String) : null;
+                const identity = `GET ${apiPath}|${location}|${parameter.name}`;
+                if (seen.has(identity))
+                    continue;
+                seen.add(identity);
+                axes.push({
+                    operation: `GET ${apiPath}`,
+                    name: parameter.name,
+                    in: location,
+                    enumValues,
+                });
+            }
+        }
+    }
+    return axes;
+}
 function orderedUnique(values) {
     const result = [];
     const seen = new Set();
@@ -985,8 +1034,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
     // Plan C: deterministic query/filter axis partitions (fail-closed on missing slots).
     const parsedPartitions = parseScenarioPartitions(readme);
     findings.push(...parsedPartitions.issues);
+    const openApiPartitionAxes = await extractBackendTestOpenApiPartitionAxes(input);
+    const partitionedBySource = applyOpenApiPartitionDomainPolicy(parsedPartitions.partitions, openApiPartitionAxes);
+    findings.push(...partitionedBySource.issues);
     const declaredPointUniverse = new Set(cases.flatMap((item) => item.testPoints));
-    const partitionAssessment = assessScenarioPartitionCoverage(parsedPartitions.partitions, declaredPointUniverse);
+    const partitionAssessment = assessScenarioPartitionCoverage(partitionedBySource.partitions, declaredPointUniverse);
     findings.push(...partitionAssessment.findings);
     const [enumValueCount, coveredEnumValueCount] = dimensionCounts(rules, /enum/);
     const [boundaryPointCount, coveredBoundaryPointCount] = dimensionCounts(rules, /boundary|length|numeric/);
@@ -1003,7 +1055,7 @@ export async function analyzeBackendTestCaseCoverage(input) {
         sourceBinding: input.sourceBinding,
         inputFiles: await inputFileFacts(input.workspaceRoot, [
             ...((await exists(readmePath)) ? [readmePath] : []),
-            ...(await markdownModuleFiles(input.workspaceRoot)),
+            ...(await markdownModuleFiles(input.workspaceRoot, layout)),
             ...(await Promise.all(input.sourceBinding.referencePaths.map(async (referencePath) => {
                 const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
                 return (await exists(physicalPath)) ? physicalPath : "";
@@ -1448,8 +1500,26 @@ print(json.dumps(out,ensure_ascii=True))
     // Windows Python may expose stdin as GBK; decoding generated Chinese/emoji
     // source through that locale can create surrogateescape code points and make
     // ast.parse fail with "surrogates not allowed".
-    const result = spawnSync("python", ["-c", program], { input: Buffer.from(source, "utf8"), encoding: "utf8", maxBuffer: 4 * 1024 * 1024, windowsHide: true });
-    if (result.status !== 0 || !result.stdout.trim())
+    // POSIX images usually expose only `python3` (modern macOS has no `python`);
+    // Windows often has a real `python` plus a Microsoft Store `python3` stub.
+    // A missing interpreter must not silently degrade to empty payload shapes.
+    const interpreterCandidates = process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+    let result;
+    for (const interpreter of interpreterCandidates) {
+        const attempt = spawnSync(interpreter, ["-c", program], {
+            input: Buffer.from(source, "utf8"),
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true,
+        });
+        // Interpreter missing/unspawnable → try the next candidate. A spawned
+        // interpreter that exits nonzero analyzed real input; do not retry then.
+        if (attempt.error)
+            continue;
+        result = attempt;
+        break;
+    }
+    if (!result || result.status !== 0 || !result.stdout.trim())
         return new Map();
     try {
         const parsed = JSON.parse(result.stdout);
@@ -1794,7 +1864,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
         status: findings.length === 0 ? "PASS" : "FAIL",
         inputFiles: await inputFileFacts(input.workspaceRoot, [
             path.join(input.workspaceRoot, ...layout.readmePath.split("/")),
-            ...(await markdownModuleFiles(input.workspaceRoot)),
+            ...(await markdownModuleFiles(input.workspaceRoot, layout)),
             ...scriptFiles,
         ].filter((file) => file && path.isAbsolute(file))),
         summary: {

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

@@ -35,6 +35,8 @@ export const scenarioPartitionRowSchema = z.object({
 const PARTITION_HEADING = /^##\s+Scenario Partitions\s*$/;
 const PARTITION_TABLE_HEADER = /^\|\s*Partition ID\s*\|\s*Operation\s*\|\s*Axis\s*\|\s*Domain\s*\|\s*Required Slots\s*\|\s*Expected by Slot\s*\|\s*Bind Rule\s*\|\s*$/;
 const TABLE_ROW = /^\|(.+)\|$/;
+const FINITE_DOMAIN_MEMBER = /^[A-Za-z0-9]+(?:[._\- ][A-Za-z0-9]+)*$/;
+const RESERVED_SLOT_TOKENS = new Set(["OMITTED", "NOT-IN-SET"]);
 function splitCells(raw) {
     return raw
         .split("|")
@@ -100,6 +102,11 @@ export function parseScenarioPartitions(readmeMarkdown) {
             continue;
         }
         seen.add(partitionId);
+        const domainIssue = describeInvalidPartitionDomain(domain);
+        if (domainIssue) {
+            issues.push(`INVALID_PARTITION_DOMAIN: partition ${partitionId} ${domainIssue}`);
+            continue;
+        }
         partitions.push({
             partitionId,
             operation,
@@ -119,6 +126,40 @@ function slotToken(value) {
         .replace(/[^A-Z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+function describeInvalidPartitionDomain(domain) {
+    const tokens = [];
+    const seenTokens = new Set();
+    for (const value of domain) {
+        if (!FINITE_DOMAIN_MEMBER.test(value)) {
+            return `value is not a finite identifier member: ${value}`;
+        }
+        const token = slotToken(value);
+        if (!token) {
+            return `value cannot produce a stable non-empty slot token: ${value}`;
+        }
+        if (RESERVED_SLOT_TOKENS.has(token)) {
+            return `value maps to reserved slot token ${token}: ${value}`;
+        }
+        if (seenTokens.has(token)) {
+            return `values collapse to duplicate slot token ${token}`;
+        }
+        seenTokens.add(token);
+        tokens.push(token);
+    }
+    return tokens.length === 0 ? "domain produced no slot tokens" : undefined;
+}
+function normalizePartitionAxisName(value) {
+    return value.trim().replace(/^(?:query|path)\s*:\s*/i, "").toLowerCase();
+}
+function normalizePartitionOperation(value) {
+    return value.trim().replace(/\s+/g, " ").toUpperCase();
+}
+function sameFiniteSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const expected = new Set(left);
+    return right.every((value) => expected.has(value));
+}
 const STABLE_PARTITION_ID = /^SP-[A-Z0-9][A-Z0-9._-]*$/i;
 /**
  * Slot IDs are `TP-<Partition ID>-<VALUE|OMITTED|NOT-IN-SET>`.
@@ -138,13 +179,16 @@ function partitionToken(row) {
 export function expandScenarioPartitions(partitions) {
     const slots = [];
     for (const row of partitions) {
+        if (describeInvalidPartitionDomain(row.domain))
+            continue;
         const prefix = partitionToken(row);
         for (const value of row.domain) {
+            const token = slotToken(value);
             slots.push({
                 partitionId: row.partitionId,
                 operation: row.operation,
                 axis: row.axis,
-                slotId: `${prefix}-${slotToken(value)}`,
+                slotId: `${prefix}-${token}`,
                 kind: "each-value",
                 value,
                 intent: "nominal-filter",
@@ -176,6 +220,34 @@ export function expandScenarioPartitions(partitions) {
     }
     return slots;
 }
+/**
+ * Bind parsed partitions to GET query/path OpenAPI axes.
+ * Unconfirmed axes keep identifier-valid Domain rows (requirement finite sets).
+ */
+export function applyOpenApiPartitionDomainPolicy(partitions, axes) {
+    const issues = [];
+    const valid = [];
+    for (const row of partitions) {
+        const operation = normalizePartitionOperation(row.operation);
+        const axisName = normalizePartitionAxisName(row.axis);
+        const matched = axes.find((axis) => normalizePartitionOperation(axis.operation) === operation &&
+            normalizePartitionAxisName(axis.name) === axisName);
+        if (!matched) {
+            valid.push(row);
+            continue;
+        }
+        if (matched.enumValues === null) {
+            issues.push(`NO_FINITE_DOMAIN: partition ${row.partitionId} axis ${row.axis} exists on ${row.operation} without a documented enum`);
+            continue;
+        }
+        if (!sameFiniteSet(matched.enumValues, row.domain)) {
+            issues.push(`PARTITION_SOURCE_MISMATCH: partition ${row.partitionId} domain does not match OpenAPI enum for ${row.operation} ${row.axis}`);
+            continue;
+        }
+        valid.push(row);
+    }
+    return { partitions: valid, issues };
+}
 /** Facts projection consumed by N6 and plan D gap-fill. */
 export const scenarioPartitionFactsSchema = z.object({
     partitions: z.array(z.object({

package/dist/workflows/dag/contract-output-registry.js

@@ -1,4 +1,19 @@
 import { structuredContractOutputSchemaIds, } from "./types.js";
+/**
+ * Registry of node-level structured contract validators, keyed by the
+ * `structuredContractOutput.schemaId` declared on a DAG task.
+ *
+ * The executor looks the validator up here instead of hardcoding per-contract
+ * imports, so new contracts (backend-test manifests, coverage contracts, ...)
+ * can opt into producing-node self-validation without touching the executor.
+ */
+export const structuredContractValidationClassifications = [
+    "format",
+    "schema",
+    "truncated",
+    "semantic-repair",
+    "governance-blocked",
+];
 const validators = new Map();
 export function registerStructuredContractValidator(schemaId, validator) {
     if (validators.has(schemaId)) {

package/dist/workflows/dag/failure-category.js

@@ -29,8 +29,13 @@ const RAW_TO_NORMALIZED = {
     "decision-envelope-invalid": "decision-envelope",
     "nonzero-exit": "shell-command",
     "spawn-error": "shell-command",
+    "test-timeout": "timeout",
     "static-error": "static-error",
     "invalid-output": "validation",
+    "structured-output-truncated": "validation",
+    "output-too-large": "validation",
+    "structured-repair-exhausted": "validation",
+    "governance-blocked": "validation",
     "path-violation": "validation",
     "empty-output": "validation",
     "verify-failure": "validation",
@@ -40,6 +45,13 @@ const RAW_TO_NORMALIZED = {
     quota: "executor",
     "rate-limit": "executor",
     unavailable: "executor",
+    // Deterministic capability/policy refusal: missing verified launcher JS
+    // entry, capability allowlist rejection, or missing bounded write tool
+    // profile. These are environment/config defects the operator repairs
+    // before rerunning; classify as executor so recovery recommends
+    // rerun-after-fix WITHOUT forcing a human-decision gate on
+    // standaloneTaskRerun (run-failed same-task rerun).
+    "tool-policy": "executor",
     unknown: "unknown",
 };
 function isFinishedStatus(status) {