@tea-agent/loop-agent 0.38.2 → 0.38.3

package/dist/worker/observe/node-input.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -33,6 +33,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
+        piExtensionRunFacts: null,
         warnings,
     };
 }
@@ -137,7 +138,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -268,6 +269,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             kind,
             skills,
             modelHint: resolveModelHint(spec, task),
+            piExtensions: redactStringList(task.piExtensions),
             shell,
             static: staticBlock,
         },
@@ -284,9 +286,72 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
         },
         promptFingerprint: fingerprint,
+        piExtensionRunFacts,
         warnings,
     };
 }
+/**
+ * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
+ * 2026-08-22 R2). Returns null when the node declares no piExtensions
+ * (no expected artifact). Never throws: unreadable/corrupt artifacts degrade
+ * to parseError stubs so the node-input endpoint stays 200.
+ */
+async function loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declared, warnings) {
+    if (declared.length === 0)
+        return null;
+    const artifact = path.posix.join(nodeId, "pi-extensions.json");
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "pi-extensions.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous pi-extensions.json lifecycle copies.");
+        }
+        return {
+            artifact,
+            exists: false,
+            requested: [...declared],
+            resolved: [],
+            missing: [],
+        };
+    }
+    const empty = {
+        artifact,
+        exists: false,
+        requested: [...declared],
+        resolved: [],
+        missing: [],
+    };
+    try {
+        const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+        const resolvedList = Array.isArray(raw.resolved) ? raw.resolved : [];
+        const missingList = Array.isArray(raw.missing) ? raw.missing : [];
+        const projected = resolvedList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            packageName: redactSecrets(String(entry.packageName ?? "")),
+            version: redactSecrets(String(entry.version ?? "")),
+        }));
+        const missingProjected = missingList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            reason: redactSecrets(String(entry.reason ?? "")),
+        }));
+        return {
+            artifact,
+            exists: true,
+            requested: redactStringList(raw.requested ?? declared),
+            resolved: projected,
+            missing: missingProjected,
+        };
+    }
+    catch {
+        return { ...empty, parseError: "read-failed" };
+    }
+}
 async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
     const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
     if (!resolved.ok) {
@@ -415,8 +480,12 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
     }
     const warnings = [];
     const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    const declaredPiExtensions = Array.isArray(task.piExtensions)
+        ? task.piExtensions.filter((item) => typeof item === "string")
+        : [];
+    const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {

package/dist/worker/observe/static/dag-history-labels.js

@@ -14,6 +14,10 @@ const ATTEMPT_FAILURE_LABELS = {
 	timeout: "执行超时",
 	"nonzero-exit": "命令执行失败",
 	"invalid-output": "输出格式无效",
+	"structured-output-truncated": "结构化输出被截断",
+	"output-too-large": "输出超出体积上限",
+	"structured-repair-exhausted": "结构化修复耗尽",
+	"governance-blocked": "治理规则阻断",
 	"empty-output": "输出为空",
 	auth: "认证失败",
 	quota: "额度或限流",

package/dist/worker/observe/static/state.js

@@ -76,8 +76,8 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。 */
-	sessionTimelineShowProtocol: false,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认展开，用户可点选隐藏。 */
+	sessionTimelineShowProtocol: true,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
 	lastSnapshot: null,

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

@@ -725,6 +725,11 @@ function renderDagNodeInputDetail(content, data) {
 		}
 		section.appendChild(dl);
 		appendCodeList(section, "skills", data.executorInput.skills);
+		appendCodeList(
+			section,
+			"piExtensions（声明）",
+			data.executorInput.piExtensions,
+		);
 		if (data.executorInput.shell) {
 			const shell = data.executorInput.shell;
 			const shellDl = el("dl", "node-input-summary");
@@ -799,6 +804,52 @@ function renderDagNodeInputDetail(content, data) {
 		wrap.appendChild(section);
 	}
 
+	if (data.piExtensionRunFacts) {
+		const facts = data.piExtensionRunFacts;
+		const section = el("section", "node-input-section");
+		section.appendChild(el("h4", null, "Pi 扩展运行事实"));
+		if (!facts.exists) {
+			section.appendChild(
+				el(
+					"p",
+					"muted",
+					facts.parseError
+					? `产物 ${facts.artifact} 读取失败（${facts.parseError}）。`
+					: `产物 ${facts.artifact} 尚未生成（节点未执行或缺失）。`,
+				),
+			);
+		} else {
+			const dl = el("dl", "node-input-summary");
+			appendMetaRow(
+				dl,
+				"resolved",
+				facts.resolved
+					.map((entry) => `${entry.id} → ${entry.packageName}@${entry.version}`)
+					.join(", ") || "(none)",
+				null,
+			);
+			section.appendChild(dl);
+			appendCodeList(
+				section,
+				"requested",
+				facts.requested,
+			);
+			for (const missingEntry of facts.missing ?? []) {
+				section.appendChild(
+					el(
+						"p",
+						"node-input-warning",
+						`降级：${missingEntry.id} 未加载（${missingEntry.reason || "unknown"}）`,
+					),
+				);
+			}
+			if ((facts.missing ?? []).length === 0) {
+				section.appendChild(el("p", "muted", "全部声明扩展均已解析加载。"));
+			}
+		}
+		wrap.appendChild(section);
+	}
+
 	if (data.promptFingerprint?.exists) {
 		const section = el("section", "node-input-section");
 		section.appendChild(el("h4", null, "Assembled prompt 指纹"));

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

@@ -439,12 +439,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 +612,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} 条协议事件`;

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 : "";
@@ -1794,7 +1846,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

@@ -31,6 +31,10 @@ const RAW_TO_NORMALIZED = {
     "spawn-error": "shell-command",
     "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",