@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.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

@@ -1500,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);

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/contract-validator-registrations.js

@@ -3,8 +3,7 @@
  * its schemaId in the contract output registry. Imported once by the node
  * executor; keeps per-contract imports out of the executor.
  */
-import { validateFrontendContractNodeOutput, validateFrontendPlanPatchNodeOutput, validateFrontendRevisionPatchNodeOutput, } from "./frontend-implementation-contract.js";
+import { validateFrontendContractNodeOutput, validateFrontendPlanPatchNodeOutput, } from "./frontend-implementation-contract.js";
 import { registerStructuredContractValidator } from "./contract-output-registry.js";
 registerStructuredContractValidator("frontend-implementation-contract-v1", validateFrontendContractNodeOutput);
 registerStructuredContractValidator("frontend-implementation-contract-plan-patch-v1", validateFrontendPlanPatchNodeOutput);
-registerStructuredContractValidator("frontend-implementation-contract-revision-patch-v1", validateFrontendRevisionPatchNodeOutput);

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) {

package/dist/workflows/dag/frontend-closeout.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+export { buildFrontendShapeTransitionCapsule, computeFrontendShapeSourceDigest, evaluateFrontendShapeEscalation, FRONTEND_SHAPE_NODE_COUNTS, frontendShapeTransitionCapsuleSchema, frontendShapeTransitionReshapeCapsuleSchema, frontendShapeTransitionSplitCapsuleSchema, parseFrontendShapeTransitionCapsule, resolveFrontendTaskShape, } from "./frontend-shape.js";
+/**
+ * Deterministic frontend closeout facts + renderer (M7).
+ *
+ * The functions here are pure (no I/O, no model, no side effects). The closeout
+ * renderer reads only committed facts, never model summaries or node prose, so
+ * a weak conclusion (failed / not-run / baseline-debt / mock-backed / pending)
+ * can never be rewritten into a stronger one (passed / real-integrated).
+ *
+ * Canonical shape routing and transition capsules live in `frontend-shape.ts`
+ * and are re-exported here for callers that also consume closeout contracts.
+ */
+export const FRONTEND_CLOSEOUT_FACTS_SCHEMA_ID = "frontend-closeout-facts-v1";
+/* ------------------------------------------------------------------ *
+ * Enums + facts schema                                                 *
+ * ------------------------------------------------------------------ */
+export const frontendCoverageStatusSchema = z.enum([
+    "passed",
+    "failed",
+    "not-run",
+    "blocked",
+    "unavailable",
+]);
+export const frontendLintStatusSchema = z.enum([
+    "passed",
+    "baseline-debt",
+    "failed",
+    "unavailable",
+]);
+export const frontendIntegrationFactsSchema = z.enum([
+    "real-api",
+    "mock-backed",
+    "local-no-remote",
+    "unavailable",
+]);
+export const frontendCloseoutFactsSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_CLOSEOUT_FACTS_SCHEMA_ID),
+    coverageMatrix: z.array(z
+        .object({
+        verificationTargetId: z.string().min(1),
+        status: frontendCoverageStatusSchema,
+    })
+        .strict()),
+    lintStatus: frontendLintStatusSchema,
+    integrationFacts: frontendIntegrationFactsSchema,
+    reviewApproval: z
+        .object({
+        typedVerdict: z
+            .enum(["approve_review", "request_review_changes"])
+            .nullable(),
+        legacyVerdict: z.enum(["pass", "request-revision"]).nullable(),
+        match: z.boolean(),
+    })
+        .strict(),
+    cumulativeDiff: z
+        .object({
+        cumulativeDigest: z.string().min(1),
+        empty: z.boolean(),
+    })
+        .strict(),
+    notRun: z
+        .object({
+        browser: z.literal("not-run"),
+        visual: z.literal("not-run"),
+    })
+        .strict(),
+    pendingRealIntegration: z.boolean(),
+    residualRisks: z.array(z.string().min(1)).optional(),
+    evidenceGaps: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+/* ------------------------------------------------------------------ *
+ * FrontendTestHandoff (A+B AC-010)                                   *
+ * ------------------------------------------------------------------ */
+export const FRONTEND_TEST_HANDOFF_SCHEMA_ID = "frontend-test-handoff-v1";
+/**
+ * A+B (AC-010): deterministic frontend-test handoff. Bound to the task id,
+ * source digest, and candidate hash; browser/visual/runtime-a11y are always
+ * `not-run` and the handoff is always `deferred-to-frontend-test`, so a weak
+ * closeout can never block implementation and can never be rewritten as
+ * passed.
+ */
+export const frontendTestHandoffSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_TEST_HANDOFF_SCHEMA_ID),
+    taskId: z.string().min(1),
+    sourceDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    candidateHash: z.string().regex(/^[a-f0-9]{64}$/),
+    executionStatus: z.literal("not-run"),
+    handoffStatus: z.literal("deferred-to-frontend-test"),
+    nonBlocking: z.literal(true),
+})
+    .strict();
+export function buildFrontendTestHandoff(input) {
+    return frontendTestHandoffSchema.parse({
+        schemaVersion: 1,
+        schemaId: FRONTEND_TEST_HANDOFF_SCHEMA_ID,
+        taskId: input.taskId,
+        sourceDigest: input.sourceDigest,
+        candidateHash: input.candidateHash,
+        executionStatus: "not-run",
+        handoffStatus: "deferred-to-frontend-test",
+        nonBlocking: true,
+    });
+}
+/**
+ * Deterministic, fail-closed mapping from structured evidence to integration
+ * facts. Never reads model text. `real-api` is the only value that may report
+ * real integration, and it requires both real passed evidence and satisfied
+ * required verification evidence. Anything else downgrades to pending.
+ */
+export function deriveFrontendIntegrationFacts(input) {
+    const requiredEvidenceSatisfied = input.verificationTargets.length > 0 &&
+        input.verificationTargets.every((target) => target.status === "ok");
+    if (input.realApiEvidence.present &&
+        input.realApiEvidence.passed &&
+        requiredEvidenceSatisfied) {
+        return "real-api";
+    }
+    // Required evidence not satisfied → never report real-integrated or
+    // mock/locally-validated; evidence is unavailable.
+    if (!requiredEvidenceSatisfied) {
+        return "unavailable";
+    }
+    if (input.mockStrategy !== "not-needed" && input.mockEvidenceBound) {
+        return "mock-backed";
+    }
+    if (input.mockStrategy === "not-needed" && !input.realApiEvidence.present) {
+        return "local-no-remote";
+    }
+    return "unavailable";
+}
+/* ------------------------------------------------------------------ *
+ * Deterministic closeout renderer                                     *
+ * ------------------------------------------------------------------ */
+function bulletList(items) {
+    if (!items || items.length === 0)
+        return "";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function coverageLines(facts) {
+    const lines = facts.coverageMatrix.map((entry) => `- ${entry.verificationTargetId}: ${entry.status}`);
+    return lines.length > 0 ? lines.join("\n") : "_(none)_";
+}
+function frontendStatus(facts) {
+    switch (facts.integrationFacts) {
+        case "real-api":
+            return "Frontend status: real-integrated";
+        case "mock-backed":
+            return "Frontend status: mock-validated";
+        case "local-no-remote":
+            return "Frontend status: locally-validated";
+        case "unavailable":
+            return "Frontend status: unverified";
+    }
+}
+function integrationStatus(facts) {
+    return facts.integrationFacts === "real-api"
+        ? "Real integration: validated"
+        : `Real integration: pending (${facts.integrationFacts})`;
+}
+function reviewApprovalLines(facts) {
+    const { typedVerdict, legacyVerdict, match } = facts.reviewApproval;
+    return [
+        `typed: ${typedVerdict ?? "none"}`,
+        `legacy: ${legacyVerdict ?? "none"}`,
+        `match: ${match}`,
+    ].join("\n");
+}
+/**
+ * Render a deterministic closeout Markdown document from committed facts only.
+ * The same facts always render byte-identical output; weak statuses are
+ * emitted verbatim and never promoted to `passed` / real-integrated.
+ */
+export function renderFrontendCloseout(facts) {
+    const lintLine = facts.lintStatus === "baseline-debt"
+        ? `${facts.lintStatus} (explicit debt; not passed)`
+        : facts.lintStatus;
+    return [
+        "# Frontend Closeout",
+        "",
+        "## Coverage Matrix",
+        coverageLines(facts),
+        "",
+        "## Lint Status",
+        lintLine,
+        "",
+        "## Integration Facts",
+        facts.integrationFacts,
+        "",
+        "## Frontend Status",
+        frontendStatus(facts),
+        "",
+        "## Real Integration Status",
+        integrationStatus(facts),
+        "",
+        "## Real Integration Pending",
+        facts.pendingRealIntegration ? "yes" : "no",
+        "",
+        "## Review Approval",
+        reviewApprovalLines(facts),
+        "",
+        "## Cumulative Diff",
+        `digest: ${facts.cumulativeDiff.cumulativeDigest}`,
+        `empty: ${facts.cumulativeDiff.empty}`,
+        "",
+        "## Browser / Visual",
+        `Browser: ${facts.notRun.browser}`,
+        `Visual: ${facts.notRun.visual}`,
+        "",
+        "## Residual Risks",
+        bulletList(facts.residualRisks) || "_(none)_",
+        "",
+        "## Evidence Gaps",
+        bulletList(facts.evidenceGaps) || "_(none)_",
+    ].join("\n") + "\n";
+}