@tea-agent/loop-agent 0.16.24 → 0.16.26

package/dist/worker/observe/routes.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { open as openFile, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
@@ -8,8 +9,8 @@ import { clampEventHistoryLimit, listBatchEventHistory, listPoolEventHistory, }
 import { buildGlobalSnapshot, clampTaskRunHistoryLimit, listTaskRunHistory, resolveLegacyTask, } from "../observability/read-model.js";
 import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
-import { isAllowedArtifactTextPath, resolveArtifactPath, toRepoRelativeArtifactPath, } from "./paths.js";
-import { extractSpecEvidence, } from "./spec-evidence.js";
+import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview, toRepoRelativeArtifactPath, } from "./paths.js";
+import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
 export function createObserveSnapshotCache() {
     return { expiresAt: 0 };
@@ -76,6 +77,11 @@ const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
         handler: handleDagNodeSpecEvidence,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence\/file$/,
+        handler: handleDagNodeSpecEvidenceFile,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
@@ -706,6 +712,109 @@ function sendJson(res, status, body) {
     });
     res.end(payload);
 }
+async function loadDagRunSourceBinding(repoRoot, dagRunId) {
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    for (const lifecycle of ["active", "completed", "paused"]) {
+        const runJsonPath = path.join(dagRunsRoot, lifecycle, dagRunId, "run.json");
+        try {
+            const runRaw = await readFile(runJsonPath, "utf-8");
+            const runSpec = JSON.parse(runRaw);
+            const parsed = dagSourceBindingSchema.safeParse(runSpec.sourceBinding);
+            if (parsed.success)
+                return parsed.data;
+            return undefined;
+        }
+        catch {
+            // run.json may not exist; continue to next lifecycle
+        }
+    }
+    return undefined;
+}
+/**
+ * Read-only spec-evidence file preview (AC-001..AC-005). Re-validates evidence
+ * membership server-side: binding paths must be in sourceBinding.sources, read
+ * paths must have a successful paired read in session events. Enforces AC-003
+ * path safety and AC-004 truncation + redaction.
+ */
+async function handleDagNodeSpecEvidenceFile(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        sendJson(res, 400, { error: "Invalid dag run or node identifier" });
+        return;
+    }
+    const source = match.query.get("source");
+    const rawPath = match.query.get("path");
+    if (source !== "binding" && source !== "read") {
+        sendJson(res, 400, { error: "Invalid source" });
+        return;
+    }
+    if (!rawPath) {
+        sendJson(res, 400, { error: "path is required" });
+        return;
+    }
+    const maxBytes = ARTIFACT_PREVIEW_MAX_BYTES;
+    if (source === "binding") {
+        const sourceBinding = await loadDagRunSourceBinding(ctx.repoRoot, dagRunId);
+        const member = sourceBinding?.sources?.find((s) => s.path === rawPath);
+        if (!sourceBinding || !member) {
+            sendJson(res, 404, { error: "Path is not a bound source" });
+            return;
+        }
+        let resolved;
+        try {
+            resolved = await resolveRepoFilePreview(ctx.repoRoot, rawPath);
+        }
+        catch {
+            sendJson(res, 400, { error: "Invalid or unsafe path" });
+            return;
+        }
+        let raw;
+        try {
+            raw = await readFile(resolved.absPath, "utf-8");
+        }
+        catch {
+            sendJson(res, 404, { error: "File not found" });
+            return;
+        }
+        const redacted = redactSecrets(raw);
+        const content = truncateUtf8Preview(redacted, maxBytes);
+        const truncated = content !== redacted;
+        const currentSha256 = createHash("sha256")
+            .update(raw, "utf-8")
+            .digest("hex");
+        sendJson(res, 200, {
+            source: "binding",
+            path: rawPath,
+            sha256: member.sha256,
+            currentSha256,
+            hashMatch: currentSha256 === member.sha256,
+            content,
+            truncated,
+            contentBytes: Buffer.byteLength(content, "utf-8"),
+            maxBytes,
+        });
+        return;
+    }
+    // source === "read"
+    const record = await extractSpecReadContent(ctx.repoRoot, dagRunId, nodeId, rawPath);
+    if (!record) {
+        sendJson(res, 404, { error: "Path was not successfully read" });
+        return;
+    }
+    const redacted = redactSecrets(record.content);
+    const content = truncateUtf8Preview(redacted, maxBytes);
+    const truncated = content !== redacted;
+    sendJson(res, 200, {
+        source: "read",
+        path: rawPath,
+        content,
+        truncated,
+        contentBytes: Buffer.byteLength(content, "utf-8"),
+        maxBytes,
+        readAt: record.timestamp ?? null,
+    });
+}
 async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     const dagRunId = match.params.id;
     const nodeId = match.params.sub;
@@ -715,24 +824,23 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     }
     // Extract skill injection info from the DAG run spec (run.json)
     const skillInjection = { skills: [], references: [] };
-    let sourceBinding;
-    const dagRunsRoot = path.resolve(ctx.repoRoot, ".harness", "dag-runs");
-    for (const lifecycle of ["active", "completed", "paused"]) {
-        const runJsonPath = path.join(dagRunsRoot, lifecycle, dagRunId, "run.json");
-        try {
-            const runRaw = await readFile(runJsonPath, "utf-8");
-            const runSpec = JSON.parse(runRaw);
-            const parsedSourceBinding = dagSourceBindingSchema.safeParse(runSpec.sourceBinding);
-            if (parsedSourceBinding.success)
-                sourceBinding = parsedSourceBinding.data;
-            const task = runSpec.tasks?.find((t) => t.id === nodeId);
-            if (task?.skills && Array.isArray(task.skills)) {
-                skillInjection.skills = task.skills;
+    const sourceBinding = await loadDagRunSourceBinding(ctx.repoRoot, dagRunId);
+    {
+        const dagRunsRoot = path.resolve(ctx.repoRoot, ".harness", "dag-runs");
+        for (const lifecycle of ["active", "completed", "paused"]) {
+            const runJsonPath = path.join(dagRunsRoot, lifecycle, dagRunId, "run.json");
+            try {
+                const runRaw = await readFile(runJsonPath, "utf-8");
+                const runSpec = JSON.parse(runRaw);
+                const task = runSpec.tasks?.find((t) => t.id === nodeId);
+                if (task?.skills && Array.isArray(task.skills)) {
+                    skillInjection.skills = task.skills;
+                }
+                break;
+            }
+            catch {
+                // run.json may not exist; continue to next lifecycle
             }
-            break;
-        }
-        catch {
-            // run.json may not exist; continue to next lifecycle
         }
     }
     const evidence = await extractSpecEvidence(ctx.repoRoot, dagRunId, nodeId);

package/dist/worker/observe/spec-evidence.js

@@ -132,6 +132,90 @@ async function readSessionEvents(filePath) {
         return [];
     }
 }
+/**
+ * Coerce a `tool_execution_end` result body (toolResult.content or result.content)
+ * into a string. Accepts plain strings, `{type:"text", text}[]` arrays, and
+ * message.content shapes. Returns null when no usable body is present.
+ */
+function resultContentToString(content) {
+    if (content == null)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (typeof part === "string") {
+                parts.push(part);
+            }
+            else if (part && typeof part === "object" && typeof part.text === "string") {
+                parts.push(part.text);
+            }
+        }
+        return parts.length > 0 ? parts.join("\n") : null;
+    }
+    return null;
+}
+/**
+ * Scan session events for successful paired `read` tool calls and return the
+ * most recent result body + timestamp whose repo-relative path matches
+ * `relPath` exactly. Used for AC-002: show the content the model actually
+ * received at read time, never the current workspace file.
+ */
+export async function extractSpecReadContent(repoRoot, dagRunId, nodeId, relPath) {
+    if (!relPath || !isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    // The preview endpoint must expose exactly the same membership as the
+    // `specReads` list, not every file the node happened to read.
+    if (!isSpecFilePath(relPath))
+        return null;
+    const eventsPath = resolveSessionEventsPath(repoRoot, dagRunId, nodeId);
+    if (!eventsPath)
+        return null;
+    const events = await readSessionEvents(eventsPath);
+    const startMap = new Map();
+    let latest = null;
+    for (const event of events) {
+        const type = event.type;
+        const toolName = resolveToolName(event);
+        const toolCallId = event.toolCallId;
+        if (type === "tool_execution_start" && toolCallId) {
+            startMap.set(toolCallId, { toolName, input: eventToolArgs(event) });
+            continue;
+        }
+        if (type !== "tool_execution_end" || toolName !== "read" || !toolCallId)
+            continue;
+        const start = startMap.get(toolCallId);
+        if (!start || start.toolName !== "read")
+            continue;
+        const isErrored = event.isError === true ||
+            event.toolResult?.error != null ||
+            event.toolResult?.ok === false ||
+            event.result?.error != null ||
+            event.result?.ok === false;
+        if (isErrored) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const startInput = start.input ?? {};
+        const filePath = typeof startInput.path === "string" ? startInput.path : undefined;
+        if (!filePath) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const rel = toRepoRelative(repoRoot, filePath);
+        startMap.delete(toolCallId);
+        if (!rel || rel !== relPath)
+            continue;
+        const body = resultContentToString(event.toolResult?.content) ??
+            resultContentToString(event.result?.content);
+        if (body == null)
+            continue;
+        latest = { content: body, timestamp: eventTimestamp(event) };
+    }
+    return latest;
+}
 export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
     if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
         return null;

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

@@ -29,6 +29,29 @@ export async function fetchJsonResult(url) {
 	}
 }
 
+/**
+ * Fetch a spec-evidence file preview (binding source or successful read).
+ * Resolves to the parsed JSON body, or throws an Error carrying the HTTP
+ * status and server message so the UI can render an accessible error state.
+ */
+export async function fetchSpecEvidenceFile(runId, nodeId, source, relPath) {
+	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence/file?source=${encodeURIComponent(source)}&path=${encodeURIComponent(relPath)}`;
+	const res = await fetch(url);
+	let body = null;
+	try {
+		body = await res.json();
+	} catch {
+		body = null;
+	}
+	if (!res.ok) {
+		const message = body?.error || `加载失败：HTTP ${res.status}`;
+		const error = new Error(message);
+		error.status = res.status;
+		throw error;
+	}
+	return body;
+}
+
 export function artifactUrl(artifactPath) {
 	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
 }

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

@@ -46,6 +46,13 @@ export const uiState = {
 	dagTimelineViewportState: null,
 	dagNodeOutputViewportState: null,
 	runOutputViewportState: null,
+	/**
+	 * Spec-evidence file preview drill-down. null = list view; otherwise
+	 * { source, path, loading, error, data, triggerId } for the active preview.
+	 */
+	specEvidenceDetail: null,
+	/** Last-rendered spec-evidence list, used to restore the list synchronously. */
+	specEvidenceListEvidence: null,
 	pollingGeneration: 0,
 };
 
@@ -271,3 +278,22 @@ export function bumpPollingGeneration() {
 	uiState.pollingGeneration += 1;
 	return uiState.pollingGeneration;
 }
+
+/** Open an in-inspector spec-evidence file preview (AC-001/002). */
+export function openSpecEvidenceDetail(source, path, triggerEl) {
+	uiState.specEvidenceDetail = {
+		source,
+		path,
+		loading: true,
+		error: null,
+		data: null,
+		triggerId: triggerEl?.id ?? null,
+	};
+}
+
+/** Close the preview; caller restores focus to the trigger element. */
+export function closeSpecEvidenceDetail() {
+	const detail = uiState.specEvidenceDetail;
+	uiState.specEvidenceDetail = null;
+	return detail;
+}

package/dist/worker/observe/static/styles.css

@@ -1863,6 +1863,16 @@ body.is-resizing-dag-graph {
 .spec-evidence-time { margin-left: auto; color: var(--muted); font-size: 10px; font-variant-numeric: tabular-nums; white-space: nowrap; }
 .spec-evidence-warning { display: flex; align-items: flex-start; gap: 8px; margin-top: var(--space-4); padding: 10px 12px; border: 1px solid color-mix(in srgb, var(--amber) 50%, var(--hairline)); border-radius: var(--radius-sm); background: #fff8e7; color: var(--body); font-size: 12px; line-height: 1.6; }
 .spec-evidence-warning > i { flex-shrink: 0; margin-top: 2px; color: var(--amber); }
+.spec-evidence-file-btn { display: flex; align-items: flex-start; gap: 6px; width: 100%; padding: 4px 0; background: none; border: none; text-align: left; cursor: pointer; color: inherit; font: inherit; line-height: 1.5; overflow-wrap: anywhere; border-radius: var(--radius-sm); }
+.spec-evidence-file-btn:hover, .spec-evidence-file-btn:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, transparent); outline: none; }
+.spec-evidence-file-btn:focus-visible { box-shadow: 0 0 0 2px var(--accent, #2563eb); }
+.spec-evidence-detail { display: grid; gap: var(--space-3); }
+.spec-evidence-back { display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); color: var(--ink); font-size: 12px; cursor: pointer; }
+.spec-evidence-back:hover, .spec-evidence-back:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, var(--surface, #fff)); }
+.spec-evidence-detail-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; font-size: 12px; color: var(--body); }
+.spec-evidence-detail-content { min-height: 0; max-width: 100%; margin: 0; padding: var(--space-3); border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); white-space: pre-wrap; overflow-wrap: anywhere; font-size: 12px; line-height: 1.6; }
+.spec-evidence-detail-error { margin: 0; color: var(--red, #c00); font-size: 12px; }
+.spec-evidence-detail-truncated { margin: 0; color: var(--muted); font-size: 11px; }
 
 .run-layer-process {
 	display: grid;

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

@@ -10,12 +10,14 @@ import {
 	UI_TEXT,
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
-import { fetchJson } from "../api.js";
+import { fetchJson, fetchSpecEvidenceFile } from "../api.js";
 import { badge } from "../format.js";
 import { renderMarkdown } from "../markdown-render.js";
 import {
 	uiState,
 	makeSessionEventIdentity,
+	openSpecEvidenceDetail,
+	closeSpecEvidenceDetail,
 	updateDagTimelineViewportState,
 	updateDagOutputViewportState,
 	computeFollowLatest,
@@ -44,6 +46,10 @@ export function selectDagNode(dagRunId, 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;
 		// 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);
@@ -188,15 +194,20 @@ export function captureDagTimelineViewportState(panel) {
 	}
 }
 
-async function renderSpecEvidence(content, dagRunId, nodeId) {
-	const evidence = await fetchJson(
+async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
+	const evidence = cachedEvidence ?? await fetchJson(
 		`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence`,
 	);
 	if (!content.isConnected || content.dataset.dagNodeId !== String(nodeId)) return;
+	if (uiState.specEvidenceDetail) {
+		renderSpecEvidenceDetail(content, dagRunId, nodeId);
+		return;
+	}
 	if (!evidence) {
 		content.appendChild(el("p", "empty", "无法加载规范证据。"));
 		return;
 	}
+	uiState.specEvidenceListEvidence = evidence;
 
 	const statusLabels = {
 		"spec-read": "已读取规范",
@@ -241,9 +252,24 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 	});
 	appendListSection("已绑定任务源", evidence.sourceBinding?.sources, (source) => {
 		const item = el("li", null);
+		const button = document.createElement("button");
+		button.type = "button";
+		button.className = "spec-evidence-file-btn";
+		button.setAttribute("data-source", "binding");
+		button.setAttribute("data-path", source.path);
+		button.id = `spec-evidence-btn-binding-${source.path}`;
 		const icon = el("i", "ri-links-line");
 		icon.setAttribute("aria-hidden", "true");
-		item.append(icon, document.createTextNode(` ${source.kind}: `), el("code", null, source.path), document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`));
+		button.append(
+			icon,
+			document.createTextNode(` ${source.kind}: `),
+			el("code", null, source.path),
+			document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`),
+		);
+		button.addEventListener("click", () =>
+			onSpecEvidenceFileClick(content, dagRunId, nodeId, "binding", source.path, button),
+		);
+		item.appendChild(button);
 		return item;
 	});
 	appendListSection("显式需求编号", evidence.sourceBinding?.requirementIds, (id) => el("li", null, id));
@@ -252,11 +278,20 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 		evidence.specReads,
 		(read) => {
 			const item = el("li", null);
+			const button = document.createElement("button");
+			button.type = "button";
+			button.className = "spec-evidence-file-btn";
+			button.setAttribute("data-source", "read");
+			button.setAttribute("data-path", read.path);
+			if (read.timestamp) {
+				button.setAttribute("data-read-at", read.timestamp);
+			}
+			button.id = `spec-evidence-btn-read-${read.path}`;
 			const icon = el("i", "ri-file-text-line");
 			icon.setAttribute("aria-hidden", "true");
-			item.append(icon, el("code", null, read.path));
+			button.append(icon, el("code", null, read.path));
 			if (read.timestamp) {
-				item.appendChild(
+				button.appendChild(
 					el(
 						"span",
 						"spec-evidence-time",
@@ -264,6 +299,10 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 					),
 				);
 			}
+			button.addEventListener("click", () =>
+				onSpecEvidenceFileClick(content, dagRunId, nodeId, "read", read.path, button),
+			);
+			item.appendChild(button);
 			return item;
 		},
 	);
@@ -308,7 +347,135 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 	}
 }
 
+/**
+ * Click handler for spec-evidence file buttons (AC-001/002). Opens the detail
+ * view in the same spec-evidence panel (no modal), records the trigger button
+ * so the back action can restore keyboard focus (AC-005).
+ */
+function onSpecEvidenceFileClick(content, dagRunId, nodeId, source, relPath, button) {
+	openSpecEvidenceDetail(source, relPath, button);
+	clearNode(content);
+	const detail = uiState.specEvidenceDetail;
+	renderSpecEvidenceDetail(content, dagRunId, nodeId);
+	void (async () => {
+		try {
+			const data = await fetchSpecEvidenceFile(dagRunId, nodeId, source, relPath);
+			if (
+				!content.isConnected ||
+				content.dataset.dagNodeId !== String(nodeId) ||
+				!uiState.specEvidenceDetail ||
+				uiState.specEvidenceDetail.source !== source ||
+				uiState.specEvidenceDetail.path !== relPath
+			) {
+				return;
+			}
+			detail.loading = false;
+			detail.data = data;
+		} catch (error) {
+			if (
+				!content.isConnected ||
+				content.dataset.dagNodeId !== String(nodeId) ||
+				!uiState.specEvidenceDetail ||
+				uiState.specEvidenceDetail.source !== source ||
+				uiState.specEvidenceDetail.path !== relPath
+			) {
+				return;
+			}
+			detail.loading = false;
+			detail.error = error instanceof Error ? error.message : String(error);
+		}
+		renderSpecEvidenceDetail(content, dagRunId, nodeId);
+	})();
+}
+
+/**
+ * Render the in-inspector file preview (AC-005). Single scroll container for
+ * the body, always-visible back button, and accessible loading/error states.
+ */
+function renderSpecEvidenceDetail(content, dagRunId, nodeId) {
+	const detail = uiState.specEvidenceDetail;
+	clearNode(content);
+	if (!detail) {
+		renderSpecEvidence(content, dagRunId, nodeId, uiState.specEvidenceListEvidence);
+		return;
+	}
+
+	const wrapper = el("div", "spec-evidence-detail");
+	const back = document.createElement("button");
+	back.type = "button";
+	back.className = "spec-evidence-back";
+	back.setAttribute("aria-label", "返回规范证据");
+	const backIcon = el("i", "ri-arrow-left-line");
+	backIcon.setAttribute("aria-hidden", "true");
+	back.append(backIcon, document.createTextNode(" 返回规范证据"));
+	back.addEventListener("click", () => {
+		const closed = closeSpecEvidenceDetail();
+		clearNode(content);
+		// Restore the list synchronously from the cached evidence so the user
+		// sees no flicker and the trigger button is immediately focusable.
+		renderSpecEvidence(content, dagRunId, nodeId, uiState.specEvidenceListEvidence);
+		if (closed?.triggerId) {
+			const trigger = document.getElementById(closed.triggerId);
+			trigger?.focus();
+		}
+	});
+	wrapper.appendChild(back);
+
+	const meta = el("div", "spec-evidence-detail-meta");
+	meta.appendChild(el("code", null, detail.path));
+	if (detail.source === "binding" && detail.data) {
+		meta.appendChild(
+			el(
+				"span",
+				"spec-evidence-detail-hash",
+				`绑定 sha256 ${String(detail.data.sha256 ?? "").slice(0, 12)}… · 当前 ${detail.data.hashMatch ? "一致" : "不一致"}`,
+			),
+		);
+	} else if (detail.source === "read" && detail.data?.readAt) {
+		meta.appendChild(
+			el(
+				"span",
+				"spec-evidence-detail-time",
+				`读取于 ${formatSessionEventTime({ timestamp: detail.data.readAt })}`,
+			),
+		);
+	}
+	wrapper.appendChild(meta);
+
+	if (detail.loading) {
+		const loading = el("p", "muted", "正在加载文件内容…");
+		loading.setAttribute("role", "status");
+		loading.setAttribute("aria-live", "polite");
+		wrapper.appendChild(loading);
+	} else if (detail.error) {
+		const error = el("p", "spec-evidence-detail-error", `加载失败：${detail.error}`);
+		error.setAttribute("role", "alert");
+		wrapper.appendChild(error);
+	} else if (detail.data) {
+		const body = el("pre", "spec-evidence-detail-content");
+		body.textContent = detail.data.content ?? "";
+		wrapper.appendChild(body);
+		if (detail.data.truncated) {
+			const note = el(
+				"p",
+				"spec-evidence-detail-truncated",
+				`已截断，仅显示前 ${detail.data.maxBytes ?? 0} 字节。`,
+			);
+			wrapper.appendChild(note);
+		}
+	}
+	content.appendChild(wrapper);
+}
+
 	function fillDagInspectorContent(content, dagRunId, node) {
+		const previousRenderedNode = content.dataset.dagNodeId ?? "";
+		const nodeChanged = previousRenderedNode !== String(node.nodeId ?? "");
+		if (nodeChanged) {
+			// Drop any open spec-evidence preview + cached list so a stale A detail
+			// cannot survive into node B (AC-007 regression guard).
+			uiState.specEvidenceDetail = null;
+			uiState.specEvidenceListEvidence = null;
+		}
 		const activeTab = ["timeline", "spec-evidence"].includes(
 			uiState.dagInspectorTab,
 		)