@tea-agent/loop-agent 0.30.0 → 0.31.1

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

@@ -10,13 +10,18 @@ import {
 	UI_TEXT,
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
+import { attemptFailureLabel } from "../dag-history-labels.js";
 import { fetchJson, fetchSpecEvidenceFile, fetchDagNodeInput } from "../api.js";
-import { badge } from "../format.js";
+import { badge, formatMs } from "../format.js";
 import { renderMarkdown } from "../markdown-render.js";
 import {
 	uiState,
 	makeSessionEventIdentity,
 	makeDagNodeInputIdentity,
+	makeDagNodeExecutionOutputIdentity,
+	getDagNodeExecutionOutputCache,
+	setDagNodeExecutionOutputCache,
+	clearDagNodeExecutionOutputCache,
 	openSpecEvidenceDetail,
 	closeSpecEvidenceDetail,
 	updateDagTimelineViewportState,
@@ -47,28 +52,59 @@ function renderDagInspectorForCurrent() {
 	);
 }
 
-export function selectDagNode(dagRunId, nodeId) {
-	const nodeChanged = uiState.selectedDagNodeId !== nodeId;
+function resetInspectorNodeSelection(dagRunId, nodeId) {
 	uiState.selectedDagNodeId = nodeId;
 	uiState.dagInspectorOpen = true;
+	// Reset the per-attempt selection so an old node's attempt cannot leak
+	// into the newly selected node (always defaults back to the latest).
+	uiState.dagInspectorAttempt = null;
+	uiState.sessionEventOffset = 0;
+	uiState.sessionEvents = [];
+	// Drop any open spec-evidence preview so a stale A detail cannot survive
+	// into node B's spec-evidence panel (AC-007 regression guard).
+	uiState.specEvidenceDetail = null;
+	uiState.specEvidenceListEvidence = null;
+	uiState.dagNodeInputData = null;
+	uiState.dagNodeInputError = null;
+	uiState.dagNodeInputLoading = false;
+	// Drop execution-output cache/identity so node A's bodies never leak into B.
+	clearDagNodeExecutionOutputCache();
+	// Bump the session-event identity token so any in-flight response for the
+	// previous node is rejected before it can mutate the current node cache.
+	uiState.sessionEventIdentity = makeSessionEventIdentity(dagRunId, nodeId);
+	uiState.dagNodeInputIdentity = makeDagNodeInputIdentity(dagRunId, nodeId);
+}
+
+export function selectDagNode(dagRunId, nodeId) {
+	const nodeChanged = uiState.selectedDagNodeId !== nodeId;
 	if (nodeChanged) {
-		uiState.sessionEventOffset = 0;
-		uiState.sessionEvents = [];
-		// Drop any open spec-evidence preview so a stale A detail cannot survive
-		// into node B's spec-evidence panel (AC-007 regression guard).
-		uiState.specEvidenceDetail = null;
-		uiState.specEvidenceListEvidence = null;
-		uiState.dagNodeInputData = null;
-		uiState.dagNodeInputError = null;
-		uiState.dagNodeInputLoading = false;
-		// Bump the session-event identity token so any in-flight response for the
-		// previous node is rejected before it can mutate the current node cache.
-		uiState.sessionEventIdentity = makeSessionEventIdentity(dagRunId, nodeId);
-		uiState.dagNodeInputIdentity = makeDagNodeInputIdentity(dagRunId, nodeId);
+		resetInspectorNodeSelection(dagRunId, nodeId);
+	} else {
+		uiState.dagInspectorOpen = true;
 	}
 	void import("./dag.js").then((m) => m.renderDagDetail(dagRunId, false));
 }
 
+/**
+ * 从执行轨迹 occurrence 打开同一 Inspector 并选中对应 execution（AC-005）。
+ * `executionKey` 为既有 pass-<n> key（@pass-<n> 映射）或 null（@base/@final
+ * 默认最新）。uiState.dagInspectorAttempt 跨 poll 保持。
+ */
+export function selectDagExecution(dagRunId, nodeId, executionKey) {
+	const nodeChanged = uiState.selectedDagNodeId !== nodeId;
+	if (nodeChanged) {
+		resetInspectorNodeSelection(dagRunId, nodeId);
+	} else {
+		uiState.dagInspectorOpen = true;
+	}
+	uiState.dagInspectorAttempt = {
+		dagRunId,
+		nodeId,
+		key: executionKey ? String(executionKey) : null,
+	};
+	void import("./dag.js").then((m) => m.renderDagDetail(dagRunId, false));
+}
+
 export function closeDagInspector() {
 	uiState.dagInspectorOpen = false;
 	const panel = document.getElementById("dag-inspector");
@@ -1063,6 +1099,373 @@ function ensureInspectorContentScrollCapture(content, dagRunId, nodeId, tab) {
 	});
 }
 
+function attemptPreviewStatus(status) {
+	if (!status) return null;
+	const normalized = String(status).toLowerCase();
+	if (
+		["success", "finished", "completed", "succeeded", "done"].includes(
+			normalized,
+		)
+	) {
+		return { cls: "succeeded", label: "成功" };
+	}
+	if (
+		[
+			"failure",
+			"failed",
+			"error",
+			"partial_failed",
+			"partial-failed",
+			"interrupted",
+		].includes(normalized)
+	) {
+		return { cls: "failed", label: "失败" };
+	}
+	return null;
+}
+
+/**
+ * Attempt selector options for a node: per-attempt when attempts>1,
+ * per-pass when convergence passes>1, none otherwise (legacy/single).
+ * 主文案为中文：首次尝试 / 第 N 次尝试 / 初始执行 / 修复轮次 N-1
+ * （AC-001/AC-002）；option value 保持 raw attempt-<n>/pass-<n>（AC-003）。
+ */
+function attemptSelectorOptions(node) {
+	const summary = node.executionSummary;
+	if (summary?.attempts && summary.attempts.length > 1) {
+		return summary.attempts.map((attempt) => ({
+			key: `attempt-${attempt.attempt}`,
+			label:
+				attempt.attempt === 1 ? "首次尝试" : `第 ${attempt.attempt} 次尝试`,
+			preview: attempt,
+		}));
+	}
+	const passes = node.passes ?? [];
+	if (passes.length > 1) {
+		const passPreviews = summary?.passes ?? [];
+		return passes.map((pass) => {
+			const preview = passPreviews.find((entry) => entry.pass === pass) ?? {
+				pass,
+			};
+			// 仅显示文案做人类轮次映射：raw pass=1 → 初始执行，raw pass>=2 →
+			// 修复轮次 N-1（AC-001/AC-002）；option value 保持 raw pass-<n>（AC-003）。
+			return {
+				key: `pass-${pass}`,
+				label: pass <= 1 ? "初始执行" : `修复轮次 ${pass - 1}`,
+				preview,
+			};
+		});
+	}
+	return [];
+}
+
+/** Selected attempt key for the current node; null = latest. */
+function resolveSelectedAttemptKey(dagRunId, node) {
+	const selection = uiState.dagInspectorAttempt;
+	if (
+		selection &&
+		selection.dagRunId === dagRunId &&
+		selection.nodeId === node.nodeId
+	) {
+		return selection.key;
+	}
+	return null;
+}
+
+/**
+ * Sticky selector + preview strip shown at the top of output/timeline tabs
+ * when the node carries multi-attempt (or multi-pass) history. Preview shows
+ * status badge / failureCategory / durationMs for the selected attempt; for a
+ * non-latest attempt the full body stays in the immutable attempt artifact.
+ */
+function buildAttemptBar(dagRunId, node) {
+	const options = attemptSelectorOptions(node);
+	if (options.length === 0) return null;
+	const latestKey = options[options.length - 1].key;
+	const requestedKey = resolveSelectedAttemptKey(dagRunId, node);
+	const selectedKey = options.some((option) => option.key === requestedKey)
+		? requestedKey
+		: latestKey;
+
+	const bar = el("div", "dag-inspector-attempt-bar");
+	bar.appendChild(el("label", "dag-inspector-attempt-label", "执行分次"));
+	const select = document.createElement("select");
+	select.className = "dag-inspector-attempt-select";
+	select.setAttribute("aria-label", "选择执行分次");
+	for (const option of options) {
+		const optionEl = document.createElement("option");
+		optionEl.value = option.key;
+		optionEl.textContent = option.label;
+		select.appendChild(optionEl);
+	}
+	select.value = selectedKey;
+	select.addEventListener("change", () => {
+		uiState.dagInspectorAttempt = {
+			dagRunId,
+			nodeId: node.nodeId,
+			key: select.value,
+		};
+		renderDagInspectorForCurrent();
+	});
+	bar.appendChild(select);
+
+	const selected =
+		options.find((option) => option.key === selectedKey) ??
+		options[options.length - 1];
+	const data = selected.preview ?? {};
+	const preview = el("div", "dag-inspector-attempt-preview");
+	const status = attemptPreviewStatus(data.status);
+	if (status) {
+		preview.appendChild(el("span", `badge badge-${status.cls}`, status.label));
+	}
+	if (status?.cls === "failed" && data.failureCategory) {
+		// 仅失败尝试显示原因；部分 runtime 会在成功尝试保留
+		// failureCategory="success"，不能将其误映射为「其他失败原因」。
+		// 未知失败分类仍 fail-closed，raw token 仅保留在 title 诊断中。
+		const reason = el(
+			"span",
+			"dag-inspector-attempt-category",
+			`原因 ${attemptFailureLabel(data.failureCategory)}`,
+		);
+		reason.setAttribute("title", `failureCategory ${data.failureCategory}`);
+		preview.appendChild(reason);
+	}
+	if (data.durationMs !== undefined) {
+		preview.appendChild(
+			el(
+				"span",
+				"dag-inspector-attempt-duration",
+				`耗时 ${formatMs(data.durationMs)}`,
+			),
+		);
+	}
+	// Historical bodies load via execution-output endpoint; do not surface
+	// raw artifact paths as the primary path for full text (AC-003/004).
+	bar.appendChild(preview);
+	return { bar, selectedKey, latestKey, options };
+}
+
+/**
+ * Resolve whether the current selection is the semantic latest execution.
+ * Users selecting the last option still write a concrete attempt-N/pass-N key;
+ * treat that as latest so preview/body is never blank on "切回最新".
+ */
+function isLatestExecutionSelection(dagRunId, node) {
+	const options = attemptSelectorOptions(node);
+	if (options.length === 0) return true;
+	const latestKey = options[options.length - 1].key;
+	const requested = resolveSelectedAttemptKey(dagRunId, node);
+	return requested === null || requested === latestKey;
+}
+
+function effectiveExecutionKey(dagRunId, node) {
+	const options = attemptSelectorOptions(node);
+	if (options.length === 0) return null;
+	const latestKey = options[options.length - 1].key;
+	const requested = resolveSelectedAttemptKey(dagRunId, node);
+	if (requested === null) return latestKey;
+	return options.some((option) => option.key === requested)
+		? requested
+		: latestKey;
+}
+
+/**
+ * Inline read-only fetch for execution-output (api.js is outside writeSet).
+ * Mirrors fetchJsonResult: preserves status, never throws on transport errors.
+ */
+async function fetchExecutionOutput(dagRunId, nodeId, key) {
+	const url = `/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(nodeId)}/execution-output?key=${encodeURIComponent(key)}`;
+	try {
+		const res = await fetch(url);
+		let body = null;
+		try {
+			body = await res.json();
+		} catch {
+			body = null;
+		}
+		return { ok: res.ok, status: res.status, body };
+	} catch {
+		return { ok: false, status: 0, body: null };
+	}
+}
+
+function composeExecutionBodyText(payload) {
+	if (!payload || typeof payload !== "object") return "";
+	const assistant =
+		typeof payload.assistantText === "string" && payload.assistantText
+			? payload.assistantText
+			: "";
+	const stdout =
+		typeof payload.stdout === "string" && payload.stdout ? payload.stdout : "";
+	// Dedupe when both streams are non-empty and equal after trim (AC-001);
+	// keep order assistantText → stdout when they differ (AC-002).
+	if (assistant && stdout) {
+		if (assistant.trim() === stdout.trim()) return assistant;
+		return `${assistant}\n\n${stdout}`;
+	}
+	return assistant || stdout;
+}
+
+function composeExecutionErrorText(payload) {
+	if (!payload || typeof payload !== "object") return "";
+	return typeof payload.stderr === "string" ? payload.stderr : "";
+}
+
+function appendOutputBody(content, outputText, errorText, options = null) {
+	if (!outputText && !errorText) {
+		content.appendChild(el("p", "empty", UI_TEXT.noOutput));
+		return;
+	}
+	if (outputText) content.appendChild(renderMarkdown(outputText));
+	// Truncation note only for full/cached execution-output bodies (AC-003);
+	// preview path never invents truncated/maxBytes.
+	if (options?.truncated === true) {
+		const maxBytes = options.maxBytes ?? 0;
+		content.appendChild(
+			el(
+				"p",
+				"muted execution-output-truncated",
+				`内容过长，已截断（maxBytes=${maxBytes}）`,
+			),
+		);
+	}
+	if (errorText) {
+		const error = el("section", "markdown-error");
+		error.appendChild(el("p", "markdown-error-title", "错误输出"));
+		error.appendChild(renderMarkdown(errorText));
+		content.appendChild(error);
+	}
+}
+
+function renderCachedOrPreviewBody(content, dagRunId, node, key, isLatest) {
+	const cached = key
+		? getDagNodeExecutionOutputCache(dagRunId, node.nodeId, key)
+		: null;
+	if (cached?.ok && cached.body) {
+		appendOutputBody(
+			content,
+			composeExecutionBodyText(cached.body),
+			composeExecutionErrorText(cached.body),
+			{
+				truncated: cached.body.truncated === true,
+				maxBytes: cached.body.maxBytes,
+			},
+		);
+		return "cached";
+	}
+	if (isLatest) {
+		appendOutputBody(
+			content,
+			node.outputPreview ?? "",
+			node.errorPreview ?? "",
+		);
+		return "preview";
+	}
+	if (cached && cached.ok === false) {
+		const message =
+			cached.error || "该次执行输出暂不可用（artifact 缺失或无法读取）。";
+		const error = el("p", "empty", message);
+		error.setAttribute("role", "status");
+		content.appendChild(error);
+		return "missing";
+	}
+	return null;
+}
+
+async function loadAndRenderExecutionOutput(
+	content,
+	dagRunId,
+	node,
+	key,
+	isLatest,
+) {
+	const nodeId = node.nodeId;
+	const identity = makeDagNodeExecutionOutputIdentity(dagRunId, nodeId, key);
+	uiState.dagNodeExecutionOutputIdentity = identity;
+	uiState.dagNodeExecutionOutputKey = key;
+	uiState.dagNodeExecutionOutputLoading = true;
+	uiState.dagNodeExecutionOutputError = null;
+
+	const stillCurrent = () =>
+		uiState.dagNodeExecutionOutputIdentity === identity &&
+		uiState.selectedDagNodeId === nodeId &&
+		// currentDagRunId may be unset in isolated unit stubs; prefer dataset match.
+		(uiState.currentDagRunId == null || uiState.currentDagRunId === dagRunId) &&
+		uiState.dagInspectorTab === "output" &&
+		content.isConnected &&
+		content.dataset.dagNodeId === String(nodeId) &&
+		content.dataset.dagRunId === String(dagRunId) &&
+		effectiveExecutionKey(dagRunId, inspectorSelection.node ?? node) === key;
+
+	const result = await fetchExecutionOutput(dagRunId, nodeId, key);
+	if (!stillCurrent()) return;
+
+	uiState.dagNodeExecutionOutputLoading = false;
+	if (!result.ok || !result.body) {
+		const message =
+			result.body?.error ||
+			(result.status === 0
+				? "加载执行输出失败（网络错误）。"
+				: result.status === 404
+					? "该次执行输出暂不可用（artifact 缺失或无法读取）。"
+					: `加载执行输出失败（HTTP ${result.status}）。`);
+		// Cache the miss for this key only — never wipe other valid bodies.
+		setDagNodeExecutionOutputCache(dagRunId, nodeId, key, {
+			ok: false,
+			error: message,
+			status: result.status,
+		});
+		uiState.dagNodeExecutionOutputError = message;
+		// Rebuild body area: keep attempt bar, replace status/body.
+		repaintOutputTabBody(content, dagRunId, node);
+		return;
+	}
+
+	setDagNodeExecutionOutputCache(dagRunId, nodeId, key, {
+		ok: true,
+		body: result.body,
+	});
+	uiState.dagNodeExecutionOutputError = null;
+	repaintOutputTabBody(content, dagRunId, node);
+}
+
+/**
+ * Rebuild the output tab body under the attempt bar using cache + preview
+ * without losing selection identity (poll / async completion).
+ */
+function repaintOutputTabBody(content, dagRunId, node) {
+	if (
+		!content?.isConnected ||
+		content.dataset.dagNodeId !== String(node.nodeId ?? "") ||
+		content.dataset.dagRunId !== String(dagRunId ?? "") ||
+		activeInspectorTab() !== "output"
+	) {
+		return;
+	}
+	// Remove everything after the attempt bar (or all if no bar).
+	const bar = content.querySelector(".dag-inspector-attempt-bar");
+	const keep = bar ? [bar] : [];
+	while (content.firstChild) content.removeChild(content.firstChild);
+	for (const nodeEl of keep) content.appendChild(nodeEl);
+
+	const key = effectiveExecutionKey(dagRunId, node);
+	const latest = isLatestExecutionSelection(dagRunId, node);
+	const rendered = renderCachedOrPreviewBody(
+		content,
+		dagRunId,
+		node,
+		key,
+		latest,
+	);
+	if (rendered === null) {
+		const loading = el("p", "muted", "正在加载执行输出…");
+		loading.setAttribute("role", "status");
+		loading.setAttribute("aria-live", "polite");
+		content.appendChild(loading);
+	}
+	restoreInspectorContentScroll(content, dagRunId, node.nodeId, "output");
+}
+
 function fillDagInspectorContent(content, dagRunId, node) {
 	const previousRenderedNode = content.dataset.dagNodeId ?? "";
 	const previousRenderedRun = content.dataset.dagRunId ?? "";
@@ -1110,21 +1513,39 @@ function fillDagInspectorContent(content, dagRunId, node) {
 	if (activeTab === "spec-evidence") {
 		void renderSpecEvidence(content, dagRunId, node.nodeId);
 	} else if (activeTab === "timeline") {
+		const attemptBuilt = buildAttemptBar(dagRunId, node);
+		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
 		renderSessionTimeline(content, node.nodeId);
 	} else if (activeTab === "input") {
 		void renderDagNodeInput(content, dagRunId, node);
-	} else if (!node.outputPreview && !node.errorPreview) {
-		content.appendChild(el("p", "empty", UI_TEXT.noOutput));
-		restoreInspectorContentScroll(content, dagRunId, node.nodeId, "output");
 	} else {
-		if (node.outputPreview)
-			content.appendChild(renderMarkdown(node.outputPreview));
-		if (node.errorPreview) {
-			const error = el("section", "markdown-error");
-			error.appendChild(el("p", "markdown-error-title", "错误输出"));
-			error.appendChild(renderMarkdown(node.errorPreview));
-			content.appendChild(error);
+		// output tab: attempt bar + latest preview immediate / historical async body.
+		const attemptBuilt = buildAttemptBar(dagRunId, node);
+		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
+		const key = effectiveExecutionKey(dagRunId, node);
+		const latest = isLatestExecutionSelection(dagRunId, node);
+		const rendered = renderCachedOrPreviewBody(
+			content,
+			dagRunId,
+			node,
+			key,
+			latest,
+		);
+		// Historical (or multi-exec) selection without cache → loading then fetch.
+		if (key && rendered === null) {
+			const loading = el("p", "muted", "正在加载执行输出…");
+			loading.setAttribute("role", "status");
+			loading.setAttribute("aria-live", "polite");
+			content.appendChild(loading);
+			void loadAndRenderExecutionOutput(content, dagRunId, node, key, latest);
+		} else if (key && rendered === "preview" && latest) {
+			// Optional parallel enhance: load full artifact body for latest.
+			const cached = getDagNodeExecutionOutputCache(dagRunId, node.nodeId, key);
+			if (!cached) {
+				void loadAndRenderExecutionOutput(content, dagRunId, node, key, latest);
+			}
 		}
+		// Single-execution nodes (!key) already painted preview via renderCachedOrPreviewBody.
 		restoreInspectorContentScroll(content, dagRunId, node.nodeId, "output");
 	}
 }
@@ -1223,16 +1644,46 @@ function syncDagInspectorHeader(panel, dagRunId, node) {
 
 function dagInspectorSignature(dagRunId, node) {
 	const tab = activeInspectorTab();
+	const execKey = effectiveExecutionKey(dagRunId, node);
+	const cachedBody = execKey
+		? getDagNodeExecutionOutputCache(dagRunId, node.nodeId, execKey)
+		: null;
+	const cachedRevision = cachedBody?.ok
+		? [
+				cachedBody.body?.assistantText ?? "",
+				cachedBody.body?.stdout ?? "",
+				cachedBody.body?.stderr ?? "",
+				cachedBody.body?.truncated === true ? "trunc" : "full",
+				cachedBody.body?.maxBytes ?? "",
+			]
+		: cachedBody
+			? ["err", cachedBody.error ?? ""]
+			: ["none"];
 	const contentRevision =
 		tab === "output"
-			? [node.outputPreview ?? "", node.errorPreview ?? ""]
+			? [
+					node.outputPreview ?? "",
+					node.errorPreview ?? "",
+					...cachedRevision,
+					uiState.dagNodeExecutionOutputLoading ? "loading" : "idle",
+				]
 			: tab === "timeline"
 				? [uiState.sessionEventOffset]
 				: [node.status ?? ""];
+	// Attempt dimension: selection identity + history shape. Poll refreshes keep
+	// the DOM while selection/history are unchanged; switching attempt or a
+	// changed attempt count rebuilds the selector.
+	const summary = node.executionSummary;
+	const attemptRevision = [
+		summary?.totalAttemptCount ?? 0,
+		(node.passes ?? []).join(","),
+		execKey ?? "latest",
+	];
 	return JSON.stringify([
 		dagRunId,
 		node.nodeId,
 		tab,
+		attemptRevision,
 		contentRevision,
 	]);
 }