@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

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

@@ -1,3 +1,4 @@
+import { createInspectorSubmission, sendInspectorSubmission, hasUnresolvedSubmission } from "../inspector-submission.js";
 /** DAG node inspector panel (Observe UI R5). */
 import {
 	DAG_INSPECTOR_DEFAULT_WIDTH,
@@ -9,15 +10,24 @@ import {
 	DAG_INSPECTOR_KEYBOARD_STEP,
 	UI_TEXT,
 } from "../constants.js";
-import { clearNode, el } from "../dom.js";
+import { clearNode, el, iconButton, setIconButton } from "../dom.js";
 import { attemptFailureLabel } from "../dag-history-labels.js";
+import { isNodeFailed } from "../dag-helpers.js";
+import { isDagRunActive } from "../dag-model.js";
 import {
 	contextTransferReasonLabel,
 	describeTransferError,
 	formatContextTransferReasonList,
 } from "../dag-context-reason-labels.js";
+import {
+	describeInspectorMeta,
+	inspectorFieldLabel,
+	inspectorListValueLabel,
+	inspectorValueLabel,
+} from "../dag-inspector-humanize.js";
 import {
 	fetchJson,
+	fetchJsonResult,
 	fetchSpecEvidenceFile,
 	fetchDagNodeInput,
 	fetchDagNodeContext,
@@ -31,7 +41,6 @@ import {
 } from "../api.js";
 import {
 	badge,
-	formatLedgerSummary,
 	formatMs,
 	prettyJsonBlock,
 } from "../format.js";
@@ -39,9 +48,11 @@ import { renderMarkdown, renderInspectorDocument } from "../markdown-render.js";
 import { describeDagNodePurpose } from "../dag-node-purpose.js";
 import { buildPromptRestartCandidateOptions } from "../prompt-restart-candidates.js";
 import { copyText } from "../copy.js";
-import { navigate } from "../router.js";
+import { navigate, inspectPathToCanonicalHref } from "../router.js";
 import {
 	fetchWithWorkspaceScope,
+	scopedApiUrl,
+	workspaceScope,
 	uiState,
 	makeSessionEventIdentity,
 	makeDagNodeInputIdentity,
@@ -59,12 +70,15 @@ import {
 	inspectorViewportRegionKey,
 	saveDagInspectorViewportState,
 	getDagInspectorViewportState,
+	inspectorReadingState,
+	inspectorNodeSelections,
+	inspectorDrafts,
+	inspectorOperations,
 } from "../state.js";
 import {
 	formatSessionEventTime,
 	renderSessionTimeline,
-	buildPageStyledDoc,
-	fetchPageStylesheetText,
+	createTimelineAutoScrollControl,
 } from "./session-timeline.js";
 import { createCustomSelect } from "../custom-select.js";
 
@@ -72,7 +86,7 @@ import { createCustomSelect } from "../custom-select.js";
 // reused inspector shell never keeps stale node closures: every render writes
 // the latest {dagRunId, node} here and tab clicks re-render from the same
 // reference, always resolving the currently selected node identity.
-const inspectorSelection = { dagRunId: null, node: null };
+const inspectorSelection = { dagRunId: null, node: null, run: null };
 
 /**
  * 失败状态行统一入口：错误信息中嵌入的已知 reason code 先给中文语义
@@ -111,34 +125,117 @@ export const ARTIFACT_FILE_PREVIEW_SURFACES = Object.freeze({
 	revisionSelection: "artifact-revision-current-preview",
 });
 
+const INSPECTOR_PAGE_GUIDANCE = Object.freeze({
+	overview: {
+		eyebrow: "先看结论",
+		title: "这个节点做了什么",
+		body: "先看当前状态、执行方式和结果来源；需要追细节时，再进入后面的页面。",
+	},
+	input: {
+		eyebrow: "运行前",
+		title: "系统原本准备怎么做",
+		body: "这里是开始执行前保存的任务说明、依赖关系和读写范围，不代表这些内容后来一定被实际使用。",
+	},
+	context: {
+		eyebrow: "执行时",
+		title: "AI 实际拿到了哪些资料",
+		body: "这一页只展示系统在下发任务时真正记录到的内容；没有记录时会明确说明，不会用运行前设置代替。",
+	},
+	timeline: {
+		eyebrow: "执行过程",
+		title: "这一步实际发生了什么",
+		body: "按顺序查看 AI 的回复、工具调用或命令结果；失败时优先看标红步骤和错误输出。",
+	},
+	"spec-evidence": {
+		eyebrow: "需求依据",
+		title: "它有没有真的读过需求",
+		body: "只有成功读取文件或查询知识库的记录才算证据；模型自己提到文件名不算。",
+	},
+	output: {
+		eyebrow: "执行结果",
+		title: "它产出了什么，谁会用",
+		body: "先确认文件是否真实生成、能否替换以及后续谁会使用，再查看具体输出内容。",
+	},
+	lineage: {
+		eyebrow: "来源与影响",
+		title: "这一步从哪里来，会影响哪里",
+		body: "用于判断结果是本次生成还是沿用旧运行，以及替换或重跑会从哪个位置继续。",
+	},
+});
+
+/** 会话级收起记忆：同一 Tab 收起后，本会话内的重绘保持折叠（可再展开）。 */
+const COLLAPSED_INSPECTOR_LEADS = new Set();
+
+function buildInspectorPageLead(tab) {
+	const copy = INSPECTOR_PAGE_GUIDANCE[tab];
+	if (!copy) return null;
+	const lead = el("section", "inspector-page-lead");
+	lead.dataset.page = tab;
+	const collapsed = COLLAPSED_INSPECTOR_LEADS.has(tab);
+	if (collapsed) lead.classList.add("is-collapsed");
+	const toggle = iconButton(
+		collapsed ? "展开说明" : "收起说明",
+		collapsed ? "ri-arrow-down-s-line" : "ri-arrow-up-s-line",
+		"inspector-lead-toggle",
+	);
+	toggle.setAttribute("aria-expanded", String(!collapsed));
+	toggle.addEventListener("click", () => {
+		const nextCollapsed = !lead.classList.contains("is-collapsed");
+		if (nextCollapsed) COLLAPSED_INSPECTOR_LEADS.add(tab);
+		else COLLAPSED_INSPECTOR_LEADS.delete(tab);
+		lead.classList.toggle("is-collapsed", nextCollapsed);
+		setIconButton(
+			toggle,
+			nextCollapsed ? "展开说明" : "收起说明",
+			nextCollapsed ? "ri-arrow-down-s-line" : "ri-arrow-up-s-line",
+		);
+		toggle.setAttribute("aria-expanded", String(!nextCollapsed));
+	});
+	const eyebrow = el("span", "inspector-page-eyebrow", copy.eyebrow);
+	const eyebrowRow = el("div", "inspector-page-eyebrow-row");
+	eyebrowRow.append(eyebrow, toggle);
+	lead.append(eyebrowRow, el("h4", null, copy.title), el("p", null, copy.body));
+	return lead;
+}
+
+function ensureInspectorPageLead(content, tab) {
+	const existing = content.querySelector(
+		`.inspector-page-lead[data-page="${tab}"]`,
+	);
+	if (existing) return existing;
+	const lead = buildInspectorPageLead(tab);
+	if (lead) content.insertBefore(lead, content.firstChild);
+	return lead;
+}
+
 export const CONTEXT_EXPORT_TARGETS = Object.freeze([
 	{
 		value: "generic",
-		label: "通用 Agent 交接包",
-		description: "适合交给其他 Agent 或 LLM 继续处理",
+		label: "通用 AI 交接包",
+		description: "适合交给其他 AI 工具继续处理",
 		icon: "ri-robot-2-line",
-		contents: "receipt · manifest · handoff.md",
+		contents: "执行时记录 · 文件清单 · 交接说明",
 	},
 	{
 		value: "pi-session",
-		label: "Pi 可重开会话",
-		description: "兼容时附带可由 Pi 打开的 session JSONL",
+		label: "可在 Pi 中恢复的会话",
+		description: "如果记录兼容，会附带可直接恢复的会话文件",
 		icon: "ri-terminal-box-line",
-		contents: "receipt · manifest · session.jsonl（兼容时）",
+		contents: "执行时记录 · 文件清单 · 可恢复的 Pi 会话（兼容时）",
 	},
 	{
 		value: "readable",
 		label: "可读执行记录",
 		description: "便于人工审阅，不承诺完整重现执行",
 		icon: "ri-file-list-3-line",
-		contents: "receipt · manifest · transcript.md",
+		contents: "执行时记录 · 文件清单 · 可读对话记录",
 	},
 	{
 		value: "pi-handoff",
-		label: "Pi Handoff 交接包",
-		description: "面向 Pi Handoff 工作流的兼容格式",
+		label: "Pi 专用交接包",
+		description: "用于把资料交给 Pi 的继续处理流程",
 		icon: "ri-share-forward-box-line",
-		contents: "receipt · manifest · handoff.md",
+		contents: "执行时记录 · 文件清单 · Pi 交接说明",
 	},
 ]);
 
@@ -398,7 +495,7 @@ function createPromptRestartPromptCard({
 		const next = candidate ?? readCandidate?.();
 		titleEl.textContent =
 			next?.key === "frozen"
-				? "冻结原始提示词"
+				? "运行开始时的提示词"
 				: (next?.label ?? title);
 		pre.textContent = next?.prompt ?? "";
 		metaEl.textContent = formatPromptRestartMeta(next?.prompt ?? "");
@@ -415,11 +512,15 @@ function renderDagInspectorForCurrent() {
 		inspectorSelection.dagRunId,
 		inspectorSelection.node,
 		false,
+		inspectorSelection.run,
 	);
 }
 
 function resetInspectorNodeSelection(dagRunId, nodeId) {
 	uiState.selectedDagNodeId = nodeId;
+	// Resolve the default after loading this node, rather than inheriting
+	// another node's tab. Explicit links and later tab clicks still win.
+	uiState.dagInspectorTab = null;
 	uiState.dagInspectorOpen = true;
 	// Each node opens in live-follow mode by default. The explicit floating
 	// control can pause it without losing the reader's current position.
@@ -427,7 +528,7 @@ function resetInspectorNodeSelection(dagRunId, nodeId) {
 	uiState.dagTimelineViewportState = null;
 	// 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.dagInspectorAttempt = inspectorNodeSelections.get(`${dagRunId}:${nodeId}`) ?? null;
 	uiState.sessionEventOffset = 0;
 	uiState.sessionEvents = [];
 	// Drop any open spec-evidence preview so a stale A detail cannot survive
@@ -628,6 +729,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 		restoreInspectorContentScroll(content, dagRunId, nodeId, "spec-evidence");
 		return;
 	}
+	ensureInspectorPageLead(content, "spec-evidence");
 	if (!evidence) {
 		content.appendChild(el("p", "empty", "无法加载规范证据。"));
 		restoreInspectorContentScroll(content, dagRunId, nodeId, "spec-evidence");
@@ -638,8 +740,8 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 	const statusLabels = {
 		"spec-read": "已读取规范",
 		"source-bound": "已绑定任务源",
-		"spec-injected": "仅注入 skill",
-		"search-only": "仅执行检索",
+		"spec-injected": "已提供阅读能力，但没有读取记录",
+		"search-only": "只搜索过，没有读取内容",
 		"kb-queried": "已观察知识库查询",
 		"no-evidence": "未观察到读取",
 	};
@@ -680,7 +782,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 	};
 
 	appendListSection(
-		"注入的 Skill",
+		"提供给节点的技能",
 		evidence.skillInjection?.skills,
 		(skill) => {
 			const item = el("li", null);
@@ -705,9 +807,9 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 			icon.setAttribute("aria-hidden", "true");
 			button.append(
 				icon,
-				document.createTextNode(` ${source.kind}: `),
+				document.createTextNode(` ${inspectorListValueLabel(source.kind)}: `),
 				el("code", null, source.path),
-				document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`),
+				document.createTextNode(` · 内容校验码 ${source.sha256.slice(0, 12)}…`),
 			);
 			button.addEventListener("click", () =>
 				onSpecEvidenceFileClick(
@@ -767,7 +869,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 			item.appendChild(button);
 			return item;
 		},
-		"unavailable：未观察到规范读取。",
+		"没有记录到节点读取规范文件。",
 	);
 	appendListSection(
 		`规范检索（${evidence.specSearches?.length ?? 0}）`,
@@ -782,7 +884,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 			);
 			return item;
 		},
-		"unavailable：未观察到规范检索。",
+		"没有记录到节点检索规范。",
 	);
 	appendListSection(
 		`知识库查询（${evidence.knowledgeBaseQueries?.length ?? 0}）`,
@@ -794,7 +896,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 			item.append(icon, document.createTextNode(` ${query.connector}`));
 			return item;
 		},
-		"unavailable：未观察到知识库查询；connector 可能未配置或未调用。",
+		"没有记录到知识库查询；可能未配置知识库连接，或节点没有使用它。",
 	);
 
 	if (
@@ -809,10 +911,10 @@ async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
 			icon,
 			document.createTextNode(
 				evidence.status === "source-bound"
-					? "DAG 已绑定权威任务源及内容哈希，但尚未观察到成功的 read 工具调用；绑定证明上下文来源，read 事件才证明节点读取了完整文件。"
+					? "系统已确认任务来源和文件版本，但没有记录到节点成功读取完整文件。仅绑定文件不能证明节点真的读过内容。"
 					: evidence.status === "no-evidence"
-						? "未观察到规范读取。只有 session event 中成功配对的 read 工具调用才算已读取，模型总结或文件名命中不能作为证明。"
-						: "规范 skill 已注入，但未观察到规范读取或知识库查询；grep/find/ls 只能证明检索，不能替代 read。",
+						? "没有记录到节点读取规范。模型总结里提到文件名，不等于节点真正读取了文件。"
+						: "已把规范阅读能力提供给节点，但没有记录到它读取规范或查询知识库；只搜索到文件名不等于读过文件内容。",
 			),
 		);
 		content.appendChild(warning);
@@ -923,7 +1025,7 @@ function renderSpecEvidenceDetail(content, dagRunId, nodeId) {
 			el(
 				"span",
 				"spec-evidence-detail-hash",
-				`绑定 sha256 ${String(detail.data.sha256 ?? "").slice(0, 12)}… · 当前 ${detail.data.hashMatch ? "一致" : "不一致"}`,
+				`登记的内容校验码 ${String(detail.data.sha256 ?? "").slice(0, 12)}… · 当前文件${detail.data.hashMatch ? "一致" : "不一致"}`,
 			),
 		);
 	} else if (detail.source === "read" && detail.data?.readAt) {
@@ -969,15 +1071,31 @@ function renderSpecEvidenceDetail(content, dagRunId, nodeId) {
 
 function sourceLabel(source) {
 	if (source === "defaults") return "继承默认值";
-	if (source === "schema-default") return "schema 默认";
-	if (source === "merged") return "合并";
+	if (source === "schema-default") return "系统默认值";
+	if (source === "merged") return "合并后的值";
 	return null;
 }
 
 function appendMetaRow(dl, label, value, source) {
 	if (value == null || value === "") return;
-	const dt = el("dt", null, label);
-	const dd = el("dd", null, String(value));
+	const isElement = value && typeof value === "object" && value.nodeType != null;
+	const copy = describeInspectorMeta(label, isElement ? "" : value);
+	const dt = el("dt", null, copy.label);
+	const dd = el("dd", null, copy.value);
+	if (isElement) dd.appendChild(value);
+	const labelHelp = [
+		copy.help ? `含义：${copy.help}` : null,
+		copy.rawLabel ? `技术字段：${copy.rawLabel}` : null,
+	].filter(Boolean);
+	if (labelHelp.length > 0) {
+		const tooltipText = labelHelp.join("\n");
+		const help = el("span", "node-input-summary-help", "?");
+		help.tabIndex = 0;
+		help.setAttribute("data-tooltip", tooltipText);
+		help.setAttribute("aria-label", tooltipText);
+		dt.appendChild(help);
+	}
+	if (copy.rawValue) dd.setAttribute("title", `原始值：${copy.rawValue}`);
 	const inherited = sourceLabel(source);
 	if (inherited) {
 		dd.appendChild(document.createTextNode(" "));
@@ -990,12 +1108,20 @@ function appendMetaRow(dl, label, value, source) {
 function appendCodeList(parent, title, values) {
 	if (!values || values.length === 0) return;
 	const section = el("section", "node-input-section");
-	section.appendChild(el("h4", null, title));
+	const heading = el("h4", null, inspectorFieldLabel(title));
+	if (inspectorFieldLabel(title) !== title) {
+		heading.setAttribute("title", `技术字段：${title}`);
+	}
+	section.appendChild(heading);
 	const list = el("ul", "node-input-code-list");
 	for (const value of values) {
 		const item = document.createElement("li");
 		const code = document.createElement("code");
-		code.textContent = String(value);
+		const rawValue = String(value);
+		code.textContent = inspectorListValueLabel(rawValue);
+		if (code.textContent !== rawValue) {
+			code.setAttribute("title", `原始值：${rawValue}`);
+		}
 		item.appendChild(code);
 		list.appendChild(item);
 	}
@@ -1063,9 +1189,9 @@ function renderDagNodeInputDetail(content, data) {
 		section.appendChild(el("h4", null, "任务正文"));
 		if (data.prompt.source?.path) {
 			const meta = el("p", "muted");
-			meta.textContent = `source: ${data.prompt.source.path}${
+			meta.textContent = `任务说明来源：${data.prompt.source.path}${
 				data.prompt.source.sha256Prefix
-					? ` (sha256 ${data.prompt.source.sha256Prefix}…)`
+					? `（内容校验码 ${data.prompt.source.sha256Prefix}…）`
 					: ""
 			}`;
 			section.appendChild(meta);
@@ -1085,7 +1211,7 @@ function renderDagNodeInputDetail(content, data) {
 
 	if (data.executorInput) {
 		const section = el("section", "node-input-section");
-		section.appendChild(el("h4", null, "执行器输入摘要"));
+		section.appendChild(el("h4", null, "将如何执行"));
 		const dl = el("dl", "node-input-summary");
 		appendMetaRow(dl, "kind", data.executorInput.kind, null);
 		if (data.executorInput.modelHint) {
@@ -1158,7 +1284,7 @@ function renderDagNodeInputDetail(content, data) {
 
 	if (data.boundaries) {
 		const section = el("section", "node-input-section");
-		section.appendChild(el("h4", null, "边界与输出契约"));
+		section.appendChild(el("h4", null, "读写范围与输出要求"));
 		const dl = el("dl", "node-input-summary");
 		appendMetaRow(dl, "outputMode", data.boundaries.outputMode, null);
 		appendMetaRow(
@@ -1169,7 +1295,7 @@ function renderDagNodeInputDetail(content, data) {
 		);
 		section.appendChild(dl);
 		if (data.boundaries.outputContract) {
-			section.appendChild(el("h5", null, "outputContract"));
+			section.appendChild(el("h5", null, "输出内容要求"));
 			section.appendChild(renderMarkdown(data.boundaries.outputContract));
 		}
 		appendCodeList(section, "allowedPaths", data.boundaries.allowedPaths);
@@ -1181,7 +1307,7 @@ function renderDagNodeInputDetail(content, data) {
 	if (data.piExtensionRunFacts) {
 		const facts = data.piExtensionRunFacts;
 		const section = el("section", "node-input-section");
-		section.appendChild(el("h4", null, "Pi 扩展运行事实"));
+		section.appendChild(el("h4", null, "AI 扩展加载结果"));
 		if (!facts.exists) {
 			section.appendChild(
 				el(
@@ -1222,7 +1348,7 @@ function renderDagNodeInputDetail(content, data) {
 
 	if (data.promptFingerprint?.exists) {
 		const section = el("section", "node-input-section");
-		section.appendChild(el("h4", null, "Assembled prompt 指纹"));
+		section.appendChild(el("h4", null, "最终提示内容校验信息"));
 		const dl = el("dl", "node-input-summary");
 		appendMetaRow(
 			dl,
@@ -1274,6 +1400,7 @@ async function renderDagNodeInput(content, dagRunId, node) {
 		preserveIntent: true,
 	});
 	clearNode(content);
+	ensureInspectorPageLead(content, "input");
 	const loading = el("p", "muted", UI_TEXT.inputLoading);
 	loading.setAttribute("role", "status");
 	loading.setAttribute("aria-live", "polite");
@@ -1293,6 +1420,7 @@ async function renderDagNodeInput(content, dagRunId, node) {
 	}
 
 	clearNode(content);
+	ensureInspectorPageLead(content, "input");
 	const finishInputRender = () => {
 		restoreInspectorContentScroll(content, dagRunId, nodeId, "input");
 		uiState.dagNodeInputLoading = false;
@@ -1355,31 +1483,45 @@ export function frontendGateLedgerLines(input) {
 	if (prewriteResult?.ok && prewriteResult.body) {
 		const parsed = prewriteResult.body;
 		if (parsed?.classification) {
-			lines.push(`classification: ${String(parsed.classification)}`);
+			const classifications = {
+				accepted: "通过，可以进入写入阶段",
+				blocked: "未通过，已阻止写入",
+				warning: "有提醒，需要留意",
+			};
+			lines.push(
+				`写入前检查：${classifications[parsed.classification] ?? String(parsed.classification)}`,
+			);
 			if (parsed.failureCode) {
-				lines.push(`failureCode: ${String(parsed.failureCode)}`);
+				lines.push(`问题编号：${String(parsed.failureCode)}`);
 			}
 			if (parsed.failureReason) {
-				lines.push(`failureReason: ${String(parsed.failureReason)}`);
+				lines.push(`原因：${String(parsed.failureReason)}`);
 			}
 		} else {
-			lines.push("frontend-prewrite-result.json 内容无法解析为结构化结果。");
+			lines.push("写入前检查结果无法解析，请查看运行记录。");
 		}
 	} else if (prewriteResult && prewriteResult.status === 404) {
-		lines.push("frontend-prewrite-result.json 尚未生成（门禁未执行或缺失）。");
+		lines.push("写入前检查尚未执行，或没有留下检查结果。");
 	} else if (prewriteResult) {
 		lines.push(
-			"frontend-prewrite-result.json 读取失败（只读接口拒绝/服务异常，安全降级）。",
+			"暂时无法读取写入前检查结果；为安全起见，不把它当成已通过。",
 		);
 	} else {
-		lines.push("frontend-prewrite-result.json 尚未生成（门禁未执行或缺失）。");
+		lines.push("写入前检查尚未执行，或没有留下检查结果。");
 	}
 	if (ledgerBody && ledgerBody.present === true) {
-		lines.push(formatLedgerSummary(ledgerBody));
+		const value = (candidate) =>
+			typeof candidate === "number" ? candidate : "未知";
+		lines.push(
+			`需求覆盖记录：原始片段 ${value(ledgerBody.fragmentCount)} 个；整理后的需求 ${value(ledgerBody.canonicalRequirementCount)} 条；待处理 ${value(ledgerBody.unresolvedCount)} 条；冲突 ${value(ledgerBody.conflictCount)} 条。`,
+		);
+		if (ledgerBody.stale === true) {
+			lines.push("提醒：任务来源后来发生过变化，这份需求覆盖记录可能已经过时。");
+		}
 	} else if (ledgerBody) {
-		lines.push("ledger: 无（任务无引用或 ledger 缺失，不伪造计数）");
+		lines.push("没有需求覆盖记录；可能是任务没有引用资料，或记录尚未生成。不会猜测数量。");
 	} else if (taskId) {
-		lines.push("ledger: 暂不可查（只读接口失败，安全降级）");
+		lines.push("需求覆盖记录暂时无法查看；不会把读取失败当成没有问题。");
 	}
 	return lines;
 }
@@ -1426,7 +1568,7 @@ export async function fetchFrontendGateLedgerData(dagRunId) {
 async function renderFrontendGateLedger(content, dagRunId) {
 	const section = el("section", "node-input-section");
 	section.appendChild(
-		el("h4", null, "Frontend prewrite 门禁 / source fidelity ledger"),
+		el("h4", null, "前端写入前检查与需求覆盖记录"),
 	);
 	const status = el("p", "muted", "加载中…");
 	status.setAttribute("role", "status");
@@ -1458,6 +1600,9 @@ async function renderFrontendGateLedger(content, dagRunId) {
  * executes it as a Console operation, and on success we jump to the new run.
  */
 function buildContextExportSection(dagRunId, node) {
+	const formScope = workspaceScope();
+	let exportAttempt = null;
+	let exportSourceLoading = true;
 	const zone = el("section", "dag-action-export-zone");
 	zone.dataset.actionSection = "context-export";
 	const divider = el("div", "dag-action-export-divider");
@@ -1472,11 +1617,11 @@ function buildContextExportSection(dagRunId, node) {
 	const heading = el("div", "context-export-heading");
 	const headingCopy = el("div", null);
 	headingCopy.appendChild(el("span", "context-export-eyebrow", "上下文交接包"));
-	const title = el("h4", null, "把这个节点交给另一个 Agent");
+	const title = el("h4", null, "把这个节点的资料交给另一个 AI");
 	title.id = "context-export-title";
 	headingCopy.appendChild(title);
 	headingCopy.appendChild(
-		el("p", null, "选择接收方式和保护级别，系统会生成一个可核验的 ZIP 交接包。"),
+		el("p", null, "选择接收方式和是否脱敏，系统会生成一个带来源校验信息的 ZIP 交接包。"),
 	);
 	const invariant = el("div", "context-export-invariant");
 	const lockIcon = el("i", "ri-lock-2-line");
@@ -1560,10 +1705,10 @@ function buildContextExportSection(dagRunId, node) {
 	ticket.setAttribute("aria-live", "polite");
 	const ticketTop = el("div", "context-export-ticket-top");
 	ticketTop.append(
-		el("span", "context-export-ticket-type", "CONTEXT / ZIP"),
+		el("span", "context-export-ticket-type", "交接资料 / ZIP"),
 		el("span", "context-export-ticket-safety", "已脱敏"),
 	);
-	const ticketTitle = el("strong", "context-export-ticket-title", "通用 Agent 交接包");
+	const ticketTitle = el("strong", "context-export-ticket-title", "通用 AI 交接包");
 	const ticketRows = el("dl", "context-export-ticket-rows");
 	const appendTicketRow = (label, value, className) => {
 		const term = el("dt", null, label);
@@ -1571,12 +1716,12 @@ function buildContextExportSection(dagRunId, node) {
 		ticketRows.append(term, detail);
 		return detail;
 	};
-	const recipientValue = appendTicketRow("用途", "适合交给其他 Agent 或 LLM 继续处理");
+	const recipientValue = appendTicketRow("用途", "适合交给其他 AI 工具继续处理");
 	const contentsValue = appendTicketRow("包含", CONTEXT_EXPORT_TARGETS[0].contents, "is-mono");
 	const protectionValue = appendTicketRow("保护", "自动隐藏匹配到的疑似凭据");
 	const attemptValue = appendTicketRow(
 		"来源",
-		`${node.nodeId} · attempt ${selectedAttemptNumber(dagRunId, node) ?? 1}`,
+		`${node.nodeId} · ${exportAttempt ? `第 ${exportAttempt} 次尝试` : exportSourceLoading ? "正在确认最新尝试…" : "暂无可用上下文"}`,
 		"is-mono",
 	);
 	ticket.append(
@@ -1584,7 +1729,7 @@ function buildContextExportSection(dagRunId, node) {
 		el("span", "context-export-ticket-label", "即将生成"),
 		ticketTitle,
 		ticketRows,
-		el("p", "context-export-ticket-foot", "附带 manifest 哈希，可核对来源与完整性"),
+		el("p", "context-export-ticket-foot", "附带文件清单和内容校验码，可以核对资料来源与完整性"),
 	);
 	workspace.appendChild(ticket);
 	section.appendChild(workspace);
@@ -1604,7 +1749,7 @@ function buildContextExportSection(dagRunId, node) {
 		recipientValue.textContent = target.description;
 		contentsValue.textContent = target.contents;
 		protectionValue.textContent = profile.description;
-		attemptValue.textContent = `${node.nodeId} · attempt ${selectedAttemptNumber(dagRunId, node) ?? 1}`;
+		attemptValue.textContent = `${node.nodeId} · ${exportAttempt ? `第 ${exportAttempt} 次尝试` : exportSourceLoading ? "正在确认最新尝试…" : "暂无可用上下文"}`;
 		const safety = ticket.querySelector(".context-export-ticket-safety");
 		if (safety) {
 			safety.textContent = profileValue === "raw" ? "原始内容" : "已脱敏";
@@ -1624,6 +1769,7 @@ function buildContextExportSection(dagRunId, node) {
 	submit.type = "button";
 	submit.className = "prompt-restart-submit context-export-submit";
 	submit.dataset.testid = "context-export-submit";
+	submit.disabled = true;
 	const submitIcon = el("i", "ri-download-cloud-2-line");
 	submitIcon.setAttribute("aria-hidden", "true");
 	submit.append(submitIcon, document.createTextNode(" 生成交接包并下载"));
@@ -1637,8 +1783,35 @@ function buildContextExportSection(dagRunId, node) {
 		status.textContent = message;
 		status.classList.toggle("prompt-restart-error", error);
 	};
+	const refreshSource = iconButton("刷新导出来源", "ri-refresh-line", "context-export-refresh-source");
+	refreshSource.type = "button";
+	ticketTop.appendChild(refreshSource);
+	const loadExportSource = async () => {
+		exportAttempt = null;
+		exportSourceLoading = true;
+		submit.disabled = true;
+		refreshSource.disabled = true;
+		updatePreview();
+		setStatus("正在检查最新尝试的上下文…");
+		const result = await fetchDagNodeContext(dagRunId, node.nodeId);
+		if (!section.isConnected || workspaceScope() !== formScope) return;
+		exportSourceLoading = false;
+		refreshSource.disabled = false;
+		const data = result.ok ? result.body : null;
+		if (Number.isInteger(data?.attempt) && data.attempt > 0 && data.effectiveContext?.status === "captured") {
+			exportAttempt = data.attempt;
+			submit.disabled = false;
+			setStatus("交接包将使用上方标明的来源；有新尝试时可刷新来源。");
+		} else {
+			setStatus("最新尝试没有可用的上下文记录。记录生成后，可刷新来源重试。", true);
+		}
+		updatePreview();
+	};
+	refreshSource.addEventListener("click", () => { void loadExportSource(); });
+	void loadExportSource();
 	submit.addEventListener("click", () => {
 		void (async () => {
+			if (exportAttempt == null || workspaceScope() !== formScope) return;
 			const targetValue = selectedValue("context-export-target");
 			const profileValue = selectedValue("context-export-profile");
 			if (profileValue === "raw" && !rawAck.checked) {
@@ -1646,8 +1819,10 @@ function buildContextExportSection(dagRunId, node) {
 				return;
 			}
 			submit.disabled = true;
+			refreshSource.disabled = true;
 			try {
-				setStatus("正在生成可验证 Context Bundle…");
+				setStatus("正在生成带来源校验信息的交接包…");
+				if (workspaceScope() !== formScope) return;
 				const clientRequestId = `inspect-context-export-${Date.now()}-${Math.random()
 					.toString(36)
 					.slice(2, 10)}`;
@@ -1656,25 +1831,28 @@ function buildContextExportSection(dagRunId, node) {
 					{
 						runId: dagRunId,
 						nodeId: node.nodeId,
-						attempt: selectedAttemptNumber(dagRunId, node) ?? 1,
+						attempt: exportAttempt,
 						target: targetValue,
 						profile: profileValue,
 						rawAcknowledged: profileValue === "raw" && rawAck.checked,
 					},
 					clientRequestId,
 				);
+				if (workspaceScope() !== formScope) return;
 				const operationId = response.body?.operationId;
 				if (!response.ok || !operationId) {
 					throw new Error(response.body?.error?.message ?? "导出操作未被接受");
 				}
 				const operation = await pollOperationToTerminal(operationId, (message) =>
-					setStatus(message.replace("续跑", "导出")),
+					setStatus(message.replace("续跑", "导出")), formScope,
 				);
+				if (workspaceScope() !== formScope) return;
 				if (operation?.state !== "succeeded" || !operation.result?.downloadUrl) {
 					throw new Error(operation?.errorMessage ?? "导出未成功完成");
 				}
-				setStatus("Bundle 已生成，正在安全下载…");
+				setStatus("交接包已生成，正在安全下载…");
 				const downloaded = await downloadContextExport(operation.result.downloadUrl);
+				if (workspaceScope() !== formScope) return;
 				const objectUrl = URL.createObjectURL(downloaded.blob);
 				const link = document.createElement("a");
 				link.href = objectUrl;
@@ -1684,12 +1862,13 @@ function buildContextExportSection(dagRunId, node) {
 				link.remove();
 				URL.revokeObjectURL(objectUrl);
 				setStatus(
-					`下载完成 · ${operation.result.bundleId} · ${new Intl.NumberFormat("zh-CN").format(operation.result.bytes)} bytes\nSHA-256 ${operation.result.bundleSha256}`,
+					`下载完成 · ${operation.result.bundleId} · ${new Intl.NumberFormat("zh-CN").format(operation.result.bytes)} 字节\n内容校验码 ${operation.result.bundleSha256}`,
 				);
 			} catch (error) {
 					setStatus(transferErrorStatusText(error, "导出未成功完成"), true);
 			} finally {
 				submit.disabled = false;
+				refreshSource.disabled = false;
 			}
 		})();
 	});
@@ -1739,16 +1918,11 @@ function buildDagActionAvailability({ title, description, reasonCode, tone = "ne
 	return panel;
 }
 
-function buildFullContentCta() {
-	// Honest limitation note (review 2026-08-26): the context bundle exports
-	// node *inputs*; it does not necessarily contain the full bytes of a
-	// produced artifact or a revision candidate, so pointing the truncated
-	// preview at the export flow would overpromise. State the bound plainly.
-	return el(
-		"p",
-		"artifact-content-preview-full-cta",
-		"预览有截断；当前版本暂不提供完整文件下载。",
-	);
+function buildFullContentCta(dagRunId, nodeId, artifactId) {
+	const link = el("a", "artifact-content-preview-full-cta btn btn-secondary", "下载完整脱敏文本");
+	link.href = scopedApiUrl(`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(nodeId)}/artifacts/download?artifactId=${encodeURIComponent(artifactId)}`);
+	link.setAttribute("download", `${artifactId}.redacted.txt`);
+	return link;
 }
 
 function createArtifactContentPreview(
@@ -1816,14 +1990,14 @@ function createArtifactContentPreview(
 			el(
 				"span",
 				null,
-				`${data.mediaType ?? "unknown"} · ${new Intl.NumberFormat("zh-CN").format(data.sourceBytes ?? 0)} bytes`,
+				`${data.mediaType ?? "未知类型"} · ${new Intl.NumberFormat("zh-CN").format(data.sourceBytes ?? 0)} 字节`,
 			),
 		];
 		if (typeof data.sha256 === "string" && data.sha256.length >= 12) {
 			const sha = el(
 				"span",
 				null,
-				` · sha256 ${data.sha256.slice(0, 12)}…`,
+				` · 内容校验码 ${data.sha256.slice(0, 12)}…`,
 			);
 			sha.title = data.sha256;
 			metaChildren.push(sha);
@@ -1835,7 +2009,7 @@ function createArtifactContentPreview(
 				el(
 					"p",
 					"artifact-content-preview-unavailable",
-					"该文件的媒体类型不支持安全内嵌显示；路径、大小和 SHA-256 已核验。",
+					"该文件类型不适合直接在页面中显示；系统已经核对文件位置、大小和内容校验码。",
 				),
 			);
 			return;
@@ -1856,15 +2030,14 @@ function createArtifactContentPreview(
 		if (data.redacted) notes.push("疑似凭据已脱敏");
 		if (data.truncated) {
 			notes.push(
-				`仅显示前 ${new Intl.NumberFormat("zh-CN").format(data.maxBytes ?? 0)} bytes`,
+				`仅显示前 ${new Intl.NumberFormat("zh-CN").format(data.maxBytes ?? 0)} 字节`,
 			);
 		}
 		if (notes.length > 0) {
 			host.appendChild(el("p", "artifact-content-preview-note", notes.join(" · ")));
 		}
-		if (data.truncated) {
-			host.appendChild(buildFullContentCta());
-		}
+		host.appendChild(buildFullContentCta(dagRunId, nodeId, artifact.artifactId));
+		const copy = el("button", "btn btn-secondary", "复制预览文本"); copy.type = "button"; copy.addEventListener("click", async () => { copy.textContent = await copyText(data.content) ? "已复制" : "复制失败"; }); host.appendChild(copy);
 	};
 	details.addEventListener("toggle", () => {
 		if (details.open) void load();
@@ -1872,29 +2045,69 @@ function createArtifactContentPreview(
 	return { element: details, reset };
 }
 
-function buildArtifactRevisionSection(dagRunId, node) {
+export function artifactRevisionRunEligibility(run) {
+	// File-level eligibility only says that a file has a known replacement
+	// contract. Creating a derived run has stricter, run-level safeguards.
+	// Keep this check here so the UI does not invite an action the server will
+	// necessarily reject later.
+	if (!run) return { eligible: true };
+	const lifecycle = String(run.lifecycle ?? "").toLowerCase();
+	const status = String(run.status ?? "").toLowerCase();
+	if (lifecycle !== "completed") {
+		return {
+			eligible: false,
+			title: "这次运行还没有完整结束",
+			description:
+				"请等待运行收尾为“已完成”。进行中、暂停中，或尚未收尾的报错，都不能从替换产出继续。",
+		};
+	}
+	if (!new Set(["failed", "partial_failed"]).has(status)) {
+		return {
+			eligible: false,
+			title: "这次运行不支持替换产出后继续",
+			description:
+				"只有已完整结束且结果为“失败”或“部分失败”的运行，才能换文件后继续。当前运行已经成功完成；文件本身可替换，不代表可以创建后续运行。",
+		};
+	}
+	return { eligible: true };
+}
+
+function buildArtifactRevisionSection(dagRunId, node, run) {
+	const formScope = workspaceScope();
 	const { section, body } = createDagActionCard({
-		eyebrow: "产出修订",
-		title: "替换产出后继续运行",
-		description: "上传一个候选新版本，先校验差异和影响范围，再决定是否创建新的运行。",
+		eyebrow: "替换已有文件",
+		title: "换掉这个节点的产出后继续",
+		description: "上传新文件后，系统会先检查格式并告诉你哪些后续节点需要重做；确认前不会改动原运行。",
 		icon: "ri-file-transfer-line",
 		className: "artifact-revision-box",
 	});
 	section.dataset.actionSection = "artifact-revision";
+	const runEligibility = artifactRevisionRunEligibility(run);
+	if (!runEligibility.eligible) {
+		body.appendChild(
+			buildDagActionAvailability({
+				tone: "blocked",
+				title: runEligibility.title,
+				description: runEligibility.description,
+			}),
+		);
+		return section;
+	}
 	body.appendChild(
 		buildDagActionAvailability({
-			title: "正在检查是否可以安全修订",
-			description: "读取已冻结的产出关系和修订规则。",
+			title: "正在检查这个文件能不能安全替换",
+			description: "系统正在读取运行开始前保存的文件关系和替换规则。",
 		}),
 	);
 	void (async () => {
 		const response = await fetchDagNodeArtifacts(dagRunId, node.nodeId);
+		if (workspaceScope() !== formScope || !body.isConnected) return;
 		clearNode(body);
 		if (!response.ok || response.body?.binding?.available !== true) {
 			body.appendChild(
 				buildDagActionAvailability({
 					tone: "blocked",
-					title: "这个运行暂时不能安全修订产出",
+					title: "这个运行暂时不能安全替换产出",
 					description:
 						"缺少结构化的产出关系，系统无法可靠判断哪些后续节点会受影响，也不会根据文件名或提示词猜测。",
 					reasonCode:
@@ -1921,8 +2134,8 @@ function buildArtifactRevisionSection(dagRunId, node) {
 		body.appendChild(
 			buildDagActionAvailability({
 				tone: "ready",
-				title: `可修订 ${eligible.length} 个产出`,
-				description: "父运行不会被修改；确认后会创建一条新的派生运行。",
+				title: `可以替换 ${eligible.length} 个已生成文件`,
+				description: "原运行不会被修改；确认后系统会另外创建一次新运行。",
 			}),
 		);
 		const form = el("div", "dag-action-form artifact-revision-form");
@@ -1951,7 +2164,7 @@ function buildArtifactRevisionSection(dagRunId, node) {
 			form.appendChild(currentArtifactPreview.element);
 			artifactSelect.addEventListener("change", currentArtifactPreview.reset);
 			const fileLabel = el("label", "prompt-restart-field");
-		fileLabel.appendChild(el("span", "dag-action-field-label", "选择新文件（最多 10 MiB）"));
+		fileLabel.appendChild(el("span", "dag-action-field-label", "选择新文件（最多 10 MB）"));
 		const file = document.createElement("input");
 		file.type = "file";
 		file.className = "dag-action-file-input";
@@ -1963,7 +2176,7 @@ function buildArtifactRevisionSection(dagRunId, node) {
 		const reason = document.createElement("textarea");
 		reason.className = "prompt-restart-textarea";
 		reason.rows = 3;
-		reason.placeholder = "说明为什么要替换此产物";
+		reason.placeholder = "例如：计划遗漏了一个验收条件，需要更正后继续";
 		reason.dataset.testid = "artifact-revision-reason";
 		reasonLabel.appendChild(reason);
 		form.appendChild(reasonLabel);
@@ -1984,20 +2197,42 @@ function buildArtifactRevisionSection(dagRunId, node) {
 		const planHost = el("div", "artifact-revision-plan");
 		form.appendChild(planHost);
 		body.appendChild(form);
+		const draftKey = `${dagRunId}:${node.nodeId}:artifact`;
+		const artifactDraft = inspectorDrafts.get(draftKey) ?? {};
+		inspectorDrafts.set(draftKey, artifactDraft);
+		if (eligible.some((item) => item.artifactId === artifactDraft.artifactId)) artifactSelect.value = artifactDraft.artifactId;
+		reason.value = artifactDraft.reason ?? "";
+		const fileHint = el("p", "muted", artifactDraft.file ? `已保留：${artifactDraft.file.name}` : "");
+		fileLabel.appendChild(fileHint);
+		let draftRevision = 0;
+		const updateDraft = () => {
+			artifactDraft.artifactId = artifactSelect.value;
+			artifactDraft.reason = reason.value;
+			artifactDraft.file = file.files?.[0] ?? artifactDraft.file;
+			fileHint.textContent = artifactDraft.file ? `已保留：${artifactDraft.file.name}` : "";
+			draftRevision += 1; clearNode(planHost);
+		};
+		artifactSelect.addEventListener("change", updateDraft);
+		file.addEventListener("change", updateDraft);
+		reason.addEventListener("input", updateDraft);
 		const setStatus = (message, error = false) => {
 			status.textContent = message;
 			status.classList.toggle("prompt-restart-error", error);
 		};
+		const syncArtifactRetry = mountSubmissionRetry(form, artifactDraft, dagRunId, node.nodeId, formScope, setStatus);
 		preview.addEventListener("click", () => {
 			void (async () => {
+				if (hasUnresolvedSubmission(artifactDraft.submission) || artifactDraft.submission?.operationId) { setStatus("已有提交记录，请使用“重试原提交”或查看操作进度。"); return; }
 				const selected = eligible.find((artifact) => artifact.artifactId === artifactSelect.value);
-				const selectedFile = file.files?.[0];
+				const selectedFile = file.files?.[0] ?? artifactDraft.file;
+				const requestedRevision = draftRevision;
+				const requestedReason = reason.value.trim();
 				if (!selected || !selectedFile) {
 					setStatus("请选择一个替换文件。", true);
 					return;
 				}
 				if (selectedFile.size > 10 * 1024 * 1024) {
-					setStatus("文件超过 10 MiB 限制。", true);
+					setStatus("文件超过 10 MB 限制。", true);
 					return;
 				}
 				if (!reason.value.trim()) {
@@ -2014,8 +2249,9 @@ function buildArtifactRevisionSection(dagRunId, node) {
 						reader.readAsDataURL(selectedFile);
 					});
 					const candidateBase64 = String(dataUrl).split(",", 2)[1] ?? "";
-					setStatus("正在校验候选字节、schema 与 diff…");
+					setStatus("正在检查新文件格式并对比差异…");
 					const stageId = `artifact-stage-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+					if (workspaceScope() !== formScope) return;
 					const staged = await postOperatorAction(
 						"artifactRevisionStage",
 						{
@@ -2027,38 +2263,49 @@ function buildArtifactRevisionSection(dagRunId, node) {
 						},
 						stageId,
 					);
+					if (workspaceScope() !== formScope) return;
 					if (!staged.ok || !staged.body?.operationId) throw new Error(staged.body?.error?.message ?? "修订 staging 失败");
 					const stageOp = await pollOperationToTerminal(staged.body.operationId, (message) =>
-						setStatus(message.replace("续跑", "修订校验")),
+						setStatus(message.replace("续跑", "修订校验")), formScope,
 					);
 					const revision = stageOp?.result?.revision;
 					if (stageOp?.state !== "succeeded" || !revision?.revisionId) {
 						throw new Error(stageOp?.errorMessage ?? "修订校验失败");
 					}
-					setStatus("校验通过，正在计算 direct consumers 与传递影响闭包…");
+					setStatus("文件检查通过，正在计算哪些后续节点需要重新执行…");
 					const planId = `artifact-plan-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+					if (workspaceScope() !== formScope) return;
 					const planned = await postOperatorAction(
 						"artifactRevisionPlan",
 						{ runId: dagRunId, artifactId: selected.artifactId, revisionId: revision.revisionId },
 						planId,
 					);
+					if (workspaceScope() !== formScope) return;
 					if (!planned.ok || !planned.body?.operationId) throw new Error(planned.body?.error?.message ?? "影响预览失败");
 					const planOp = await pollOperationToTerminal(planned.body.operationId, (message) =>
-						setStatus(message.replace("续跑", "影响分析")),
+						setStatus(message.replace("续跑", "影响分析")), formScope,
 					);
+					if (workspaceScope() !== formScope) return;
 					const plan = planOp?.result?.plan;
 					if (!plan) throw new Error(planOp?.errorMessage ?? "影响预览失败");
-					planHost.appendChild(el("h5", null, "修订与影响预览"));
+					if (draftRevision !== requestedRevision || !body.isConnected) { setStatus("草稿已变化，请重新预览。"); return; }
+					planHost.appendChild(el("h5", null, "替换结果与影响范围"));
 					planHost.appendChild(
 						transparencyMetaList([
-							["修订 ID", revision.revisionId],
-							["候选文件 SHA-256", revision.candidate?.sha256],
-							["差异类型", revision.diff?.kind],
-							["风险级别", plan.risk],
-							["直接使用者", plan.impact?.directConsumerNodeIds?.join(", ") || "无"],
-							["需要重跑", plan.impact?.affectedNodeIds?.join(", ") || "无"],
-							["可以沿用", plan.impact?.importedNodeIds?.join(", ") || "无"],
-							["计划哈希", plan.planHash],
+							["本次替换编号", revision.revisionId],
+							["新文件校验码", revision.candidate?.sha256],
+							[
+								"文件内容类型",
+								inspectorValueLabel("差异类型", revision.diff?.kind),
+							],
+							[
+								"预计风险",
+								inspectorValueLabel("风险级别", plan.risk),
+							],
+							["最先受影响的节点", plan.impact?.directConsumerNodeIds?.join(", ") || "无"],
+							["会重新执行的节点", plan.impact?.affectedNodeIds?.join(", ") || "无"],
+							["会沿用结果的节点", plan.impact?.importedNodeIds?.join(", ") || "无"],
+							["本次计划校验码", plan.planHash],
 						]),
 					);
 					if (revision.diff?.summary) {
@@ -2069,7 +2316,7 @@ function buildArtifactRevisionSection(dagRunId, node) {
 					}
 					if (plan.eligible !== true) {
 						setStatus(
-							`派生运行被阻断：${formatContextTransferReasonList(plan.blockedReasons) ?? "当前不满足继续运行的条件"}`,
+							`暂时不能创建新运行：${formatContextTransferReasonList(plan.blockedReasons) ?? "当前不满足继续运行的条件"}`,
 							true,
 						);
 						return;
@@ -2082,23 +2329,22 @@ function buildArtifactRevisionSection(dagRunId, node) {
 					planHost.appendChild(execute);
 					execute.addEventListener("click", () => {
 						void (async () => {
+							if (draftRevision !== requestedRevision || hasUnresolvedSubmission(artifactDraft.submission) || artifactDraft.submission?.operationId) { setStatus("此预览已变化或已经提交，请查看操作进度。", true); return; }
 							execute.disabled = true;
 							try {
-								setStatus("正在执行受影响闭包；父 run 保持不可变…");
-								const executeId = `artifact-execute-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-								const accepted = await postOperatorAction(
-									"artifactRevisionExecute",
-									{
-										runId: dagRunId,
-										artifactId: selected.artifactId,
-										revisionId: revision.revisionId,
-										planHash: plan.planHash,
-										reason: reason.value.trim(),
-									},
-									executeId,
-								);
-								if (!accepted.ok || !accepted.body?.operationId) throw new Error(accepted.body?.error?.message ?? "派生运行未被接受");
-								const operation = await pollOperationToTerminal(accepted.body.operationId, setStatus);
+								setStatus("正在创建新运行并重新执行受影响节点；原运行保持不变…");
+								if (workspaceScope() !== formScope) return;
+								artifactDraft.submission = createInspectorSubmission("artifactRevisionExecute", {
+									runId: dagRunId, artifactId: selected.artifactId,
+									revisionId: revision.revisionId, planHash: plan.planHash, reason: requestedReason,
+								});
+								const accepted = await sendInspectorSubmission(artifactDraft.submission, postOperatorAction);
+								if (!accepted.ok || !accepted.body?.operationId) throw new Error(accepted.body?.error?.message ?? "新运行未被接受");
+								if (workspaceScope() !== formScope) return;
+								artifactDraft.submission.operationId = accepted.body.operationId;
+								trackInspectorOperation(dagRunId, node.nodeId, accepted.body.operationId);
+								const operation = await pollOperationToTerminal(accepted.body.operationId, setStatus, formScope);
+								if (workspaceScope() !== formScope) return;
 								const childRunId = operation?.result?.newRunId;
 								if (childRunId) {
 									const open = document.createElement("button");
@@ -2115,17 +2361,19 @@ function buildArtifactRevisionSection(dagRunId, node) {
 									planHost.appendChild(open);
 								}
 								if (operation?.state !== "succeeded" || !operation.result?.newRunId) {
-									throw new Error(operation?.errorMessage ?? operation?.result?.message ?? "派生运行失败");
+									throw new Error(operation?.errorMessage ?? operation?.result?.message ?? "新运行失败");
 								}
-								setStatus(`派生运行完成：${operation.result.newRunId}`);
+								setStatus(`新运行完成：${operation.result.newRunId}`);
 							} catch (error) {
-								setStatus(transferErrorStatusText(error, "派生运行失败"), true);
+								setStatus(transferErrorStatusText(error, "新运行失败"), true);
 							} finally {
-								execute.disabled = false;
+								if (artifactDraft.submission) artifactDraft.submission.inFlight = false;
+								execute.disabled = Boolean(artifactDraft.submission?.operationId) || hasUnresolvedSubmission(artifactDraft.submission);
+								syncArtifactRetry();
 							}
 						})();
 					});
-					setStatus("影响预览已冻结；确认后将重新规划并校验 plan hash。" );
+					setStatus("影响范围已经锁定；确认时系统会再次检查文件、运行和计划是否有变化。" );
 				} catch (error) {
 					setStatus(transferErrorStatusText(error, "影响预览失败"), true);
 				} finally {
@@ -2149,20 +2397,27 @@ function buildDagActionIntro(node) {
 			"重跑会创建新的运行；当前运行及其已经保存的事实始终保持不变。",
 		),
 	);
-	const state = el("span", "dag-action-node-state", node.status ?? "unknown");
+	const rawState = node.status ?? "unknown";
+	const state = el(
+		"span",
+		"dag-action-node-state",
+		inspectorValueLabel("status", rawState),
+	);
+	if (state.textContent !== rawState) state.setAttribute("title", `原始值：${rawState}`);
 	intro.append(copy, state);
 	return intro;
 }
 
-async function renderPromptRestart(content, dagRunId, node) {
+async function renderPromptRestart(content, dagRunId, node, run) {
+	const formScope = workspaceScope();
 	const nodeId = node.nodeId;
 	clearNode(content);
 	const intro = buildDagActionIntro(node);
-	const revisionSection = buildArtifactRevisionSection(dagRunId, node);
+	const revisionSection = buildArtifactRevisionSection(dagRunId, node, run);
 	const { section: promptSection, body: promptBody } = createDagActionCard({
 		eyebrow: "提示词重跑",
 		title: "修改失败提示后重新执行",
-		description: "仅失败节点可编辑提示词并从当前节点继续；其他节点只提供冻结提示查看。",
+		description: "只有执行失败的节点可以修改提示词并从这里继续；其他节点只能查看运行开始前保存的提示词。",
 		icon: "ri-restart-line",
 		className: "prompt-rerun-action-box",
 	});
@@ -2170,7 +2425,7 @@ async function renderPromptRestart(content, dagRunId, node) {
 	promptBody.appendChild(
 		buildDagActionAvailability({
 			title: "正在读取节点提示",
-			description: "检查冻结版本和历史失败候选。",
+			description: "检查运行开始前保存的版本，以及每次失败时实际使用的版本。",
 		}),
 	);
 	const exportSection = buildContextExportSection(dagRunId, node);
@@ -2180,10 +2435,24 @@ async function renderPromptRestart(content, dagRunId, node) {
 		["context-export", exportSection],
 	]);
 	content.appendChild(intro);
+	const intent = el("div", "dag-action-intents");
+	const intentKey = `${dagRunId}:${nodeId}:intent`;
+	let selectedIntent = inspectorDrafts.get(intentKey) ?? "prompt-restart";
+	const chooseIntent = (id) => {
+		selectedIntent = id; inspectorDrafts.set(intentKey, id);
+		for (const [key, section] of sections) section.hidden = key !== id;
+		for (const button of intent.querySelectorAll("button")) button.setAttribute("aria-pressed", String(button.dataset.intent === id));
+	};
+	for (const [id, label] of [["prompt-restart", "修改提示重跑"], ["artifact-revision", "替换产出继续"], ["context-export", "导出资料"]]) {
+		const button = el("button", "btn btn-secondary", label); button.type = "button"; button.dataset.intent = id; button.setAttribute("aria-pressed", String(selectedIntent === id)); button.addEventListener("click", () => chooseIntent(id)); intent.appendChild(button);
+	}
+	content.appendChild(intent);
 	for (const sectionId of DAG_ACTION_SECTION_ORDER) {
 		const section = sections.get(sectionId);
 		if (section) content.appendChild(section);
 	}
+	chooseIntent(selectedIntent);
+	mountInspectorOperations(content, dagRunId, nodeId);
 	const input = await fetchDagNodeInput(dagRunId, nodeId);
 	if (
 		!content.isConnected ||
@@ -2199,7 +2468,7 @@ async function renderPromptRestart(content, dagRunId, node) {
 		promptBody.appendChild(
 			buildDagActionAvailability({
 				tone: "blocked",
-				title: "无法读取这个节点的冻结提示",
+				title: "无法读取这个节点原先保存的提示词",
 				description: "当前不能安全预览或修改提示词。可以继续使用最下方的上下文导出。",
 			}),
 		);
@@ -2210,7 +2479,7 @@ async function renderPromptRestart(content, dagRunId, node) {
 	if (!frozenBasePrompt) {
 		promptBody.appendChild(
 			buildDagActionAvailability({
-				title: "这个节点没有冻结提示",
+				title: "这个节点没有保存原始提示词",
 				description: "因此不能从这里修改提示词重跑。",
 			}),
 		);
@@ -2220,7 +2489,10 @@ async function renderPromptRestart(content, dagRunId, node) {
 		frozenBasePrompt,
 		input.body.promptCandidates,
 	);
-	let selectedCandidate = promptCandidateOptions[0];
+	const draftKey = `${dagRunId}:${nodeId}:prompt`;
+	const draft = inspectorDrafts.get(draftKey) ?? { candidateKey: "frozen", candidates: {} };
+	inspectorDrafts.set(draftKey, draft);
+	let selectedCandidate = promptCandidateOptions.find((item) => item.key === draft.candidateKey) ?? promptCandidateOptions[0];
 	const historicalCandidatesMissing = Array.isArray(input.body.warnings)
 		? input.body.warnings.some((warning) =>
 				String(warning).startsWith(
@@ -2236,12 +2508,12 @@ async function renderPromptRestart(content, dagRunId, node) {
 			createPromptRestartBanner({
 				tone: "readonly",
 				kicker: "只读",
-				title: `当前节点 ${node.status ?? "unknown"}`,
-				body: "仅失败（ERROR）节点支持编辑提示词并重启。以下可只读查看冻结提示词与历史失败候选。",
+				title: `当前节点：${inspectorValueLabel("status", node.status ?? "unknown")}`,
+				body: "只有执行失败的节点支持编辑提示词并重启。下面可以查看原始提示词，以及历次失败时实际使用的提示词。",
 			}),
 		);
 		const promptCard = createPromptRestartPromptCard({
-			title: "冻结原始提示词",
+			title: "运行开始前保存的提示词",
 			badge: "只读",
 			readCandidate: () => selectedCandidate,
 			preTestId: "prompt-restart-readonly",
@@ -2253,9 +2525,9 @@ async function renderPromptRestart(content, dagRunId, node) {
 			hint:
 				promptCandidateOptions.length === 1
 					? historicalCandidatesMissing
-						? "该历史运行未保存失败 attempt 的实际提示词；新运行会在此列出。"
-						: "该节点没有已保存的失败 attempt。"
-					: "可切换查看冻结底稿与历史失败候选。",
+						? "这个较早的运行没有保存失败时实际使用的提示词；新运行会在这里列出。"
+						: "该节点没有保存过失败时使用的提示词。"
+					: "可以切换查看原始版本和历次失败时使用的版本。",
 			onChange: (nextKey) => {
 				selectedCandidate =
 					promptCandidateOptions.find((option) => option.key === nextKey) ??
@@ -2273,7 +2545,7 @@ async function renderPromptRestart(content, dagRunId, node) {
 		promptBody.appendChild(
 			buildDagActionAvailability({
 				tone: "blocked",
-				title: "冻结提示不完整，无法安全编辑",
+				title: "保存的提示词不完整，无法安全编辑",
 				description:
 					"为避免用截断文本覆盖完整提示，请改用 CLI：dag rerun --prompt-override。",
 			}),
@@ -2287,11 +2559,11 @@ async function renderPromptRestart(content, dagRunId, node) {
 			tone: "edit",
 			kicker: "可编辑",
 			title: "从失败节点编辑提示词并重启",
-			body: "父 run spec 保持冻结，将创建带修改提示词的续跑 run。",
+			body: "原运行的设置和记录保持不变；系统会另建一次使用新提示词的运行。",
 		}),
 	);
 	const promptCard = createPromptRestartPromptCard({
-		title: `冻结提示词（只读底稿 · ${nodeId}）`,
+		title: `原始提示词（只读 · ${nodeId}）`,
 		badge: "底稿",
 		readCandidate: () => selectedCandidate,
 		preTestId: "prompt-restart-base",
@@ -2304,31 +2576,29 @@ async function renderPromptRestart(content, dagRunId, node) {
 		label: "提示词版本",
 		hint:
 			promptCandidateOptions.length > 1
-				? "选择失败候选会载入全文替换；冻结原始提示词仍可使用追加模式。"
+				? "选择某次失败使用的版本后，会载入完整文本供你修改；原始提示词仍可选择只追加补充说明。"
 				: historicalCandidatesMissing
-					? "该历史运行未保存失败 attempt 的实际提示词；新运行会在此列出。"
-					: "该节点没有已保存的失败 attempt；当前仅有冻结原始提示词。",
+					? "这个较早的运行没有保存失败时实际使用的提示词；新运行会在这里列出。"
+					: "该节点没有保存过失败时使用的提示词；当前只有原始提示词。",
 		onChange: (nextKey) => {
-			selectedCandidate =
-				promptCandidateOptions.find((option) => option.key === nextKey) ??
-				promptCandidateOptions[0];
+			saveDraft();
+			selectedCandidate = promptCandidateOptions.find((option) => option.key === nextKey) ?? promptCandidateOptions[0];
+			draft.candidateKey = selectedCandidate.key;
 			promptCard.sync(selectedCandidate);
-			replaceArea.value = selectedCandidate.prompt;
-			if (selectedCandidate.key !== "frozen") {
-				modeSelect.value = "replace";
-			}
+			restoreDraft();
+			invalidatePlan();
 			picker.hintEl.hidden = false;
 			picker.hintEl.textContent = selectedCandidate.truncated
 				? "该候选已截断，仅供查看，不能直接提交重启。"
 				: selectedCandidate.key === "frozen"
-					? "冻结原始提示词可使用追加或全文替换。"
-					: "已载入该失败候选；可在全文替换编辑器中修订后重启。";
+					? "原始提示词可以选择追加说明，也可以全文替换。"
+					: "已载入这次失败时使用的提示词；修改完整文本后即可重启。";
 			applyModeVisibility();
 		},
 	});
 	const modeSwitch = createPromptRestartModeSwitch({
 		value: "append",
-		onChange: () => applyModeVisibility(),
+		onChange: () => { applyModeVisibility(); saveDraft(); invalidatePlan(); },
 	});
 	const modeSelect = modeSwitch.group;
 	const toolbar = el("div", "prompt-restart-toolbar");
@@ -2344,7 +2614,7 @@ async function renderPromptRestart(content, dagRunId, node) {
 		el(
 			"p",
 			"prompt-restart-hint",
-			"将包裹为 <operator_addendum> 块附加到原提示词末尾",
+			"这段补充会加在原提示词末尾，不会改写原文（内部记录为 operator_addendum）。",
 		),
 	);
 	const addendumArea = document.createElement("textarea");
@@ -2371,6 +2641,8 @@ async function renderPromptRestart(content, dagRunId, node) {
 	box.appendChild(baseLabel);
 
 	const applyModeVisibility = () => {
+		if (selectedCandidate.key !== "frozen") modeSelect.value = "replace";
+		for (const button of modeSelect.querySelectorAll("button")) if (button.dataset.mode === "append" || button.getAttribute("data-value") === "append") button.disabled = selectedCandidate.key !== "frozen";
 		const append = modeSelect.value === "append";
 		baseLabel.classList.toggle("is-hidden", !append);
 		addendumLabel.classList.toggle("is-hidden", !append);
@@ -2379,14 +2651,14 @@ async function renderPromptRestart(content, dagRunId, node) {
 	applyModeVisibility();
 
 	const reasonLabel = el("label", "prompt-restart-field");
-	reasonLabel.appendChild(el("span", "prompt-restart-label", "重启原因"));
+	reasonLabel.appendChild(el("span", "prompt-restart-label", "为什么要重启？"));
 	reasonLabel.appendChild(
-		el("p", "prompt-restart-hint", "结构化说明，会写入续跑 provenance"),
+		el("p", "prompt-restart-hint", "这段说明会随新运行一起保存，方便以后追溯。"),
 	);
 	const reasonArea = document.createElement("textarea");
 	reasonArea.className = "prompt-restart-textarea prompt-restart-textarea-compact";
 	reasonArea.rows = 3;
-	reasonArea.value = `operator-prompt-override / run=${dagRunId} / node=${nodeId} / 手工编辑失败节点提示词后重启`;
+	reasonArea.value = `修改失败节点 ${nodeId} 的提示词后重新运行（来源运行：${dagRunId}）`;
 	reasonArea.setAttribute("data-testid", "prompt-restart-reason");
 	reasonLabel.appendChild(reasonArea);
 	box.appendChild(reasonLabel);
@@ -2398,10 +2670,44 @@ async function renderPromptRestart(content, dagRunId, node) {
 	const submit = document.createElement("button");
 	submit.type = "button";
 	submit.className = "prompt-restart-submit";
-	submit.textContent = "资格预检并重启";
+	submit.textContent = "预览重跑影响";
 	submit.setAttribute("data-testid", "prompt-restart-submit");
 	row.appendChild(status);
 	row.appendChild(submit);
+	const start = el("button", "prompt-restart-submit", "确认并开始新运行");
+	start.type = "button";
+	start.disabled = true;
+	start.dataset.testid = "prompt-restart-execute";
+	row.appendChild(start);
+	const planHost = el("div", "prompt-restart-plan");
+	box.appendChild(planHost);
+	let prepared = null;
+	let submitted = false;
+	draft.submission ??= {};
+	const signature = () => JSON.stringify([selectedCandidate.key, modeSelect.value, addendumArea.value, replaceArea.value, reasonArea.value]);
+	const invalidatePlan = () => { prepared = null; start.disabled = true; clearNode(planHost); };
+	const saveDraft = () => {
+		draft.candidates[selectedCandidate.key] = { mode: modeSelect.value, addendum: addendumArea.value, replacement: replaceArea.value, reason: reasonArea.value };
+	};
+	const restoreDraft = () => {
+		const saved = draft.candidates[selectedCandidate.key];
+		modeSelect.value = saved?.mode ?? (selectedCandidate.key === "frozen" ? "append" : "replace");
+		addendumArea.value = saved?.addendum ?? "";
+		replaceArea.value = saved?.replacement ?? selectedCandidate.prompt;
+		reasonArea.value = saved?.reason ?? `修改失败节点 ${nodeId} 的提示词后重新运行（来源运行：${dagRunId}）`;
+		applyModeVisibility();
+	};
+	for (const area of [addendumArea, replaceArea, reasonArea]) area.addEventListener("input", () => { saveDraft(); invalidatePlan(); });
+	restoreDraft();
+	let beforeRestore = null;
+	const restoreOriginal = el("button", "btn btn-secondary", "恢复此版本原文");
+	restoreOriginal.type = "button";
+	restoreOriginal.addEventListener("click", () => {
+		if (beforeRestore === null) { beforeRestore = { key: selectedCandidate.key, text: replaceArea.value }; replaceArea.value = selectedCandidate.prompt; restoreOriginal.textContent = "撤销恢复"; }
+		else { if (beforeRestore.key === selectedCandidate.key) replaceArea.value = beforeRestore.text; beforeRestore = null; restoreOriginal.textContent = "恢复此版本原文"; }
+		saveDraft(); invalidatePlan();
+	});
+	toolbar.appendChild(restoreOriginal);
 	box.appendChild(row);
 
 	promptBody.appendChild(box);
@@ -2411,7 +2717,11 @@ async function renderPromptRestart(content, dagRunId, node) {
 		status.classList.toggle("prompt-restart-error", isError);
 	};
 
-	submit.addEventListener("click", () => {
+	const syncPromptRetry = mountSubmissionRetry(box, draft, dagRunId, nodeId, formScope, setStatus);
+	const handleSubmission = (executeRequested) => {
+		if (submitted || draft.submission.inFlight || (executeRequested && !prepared)) return;
+		if (hasUnresolvedSubmission(draft.submission)) { setStatus("上次提交结果尚未确认，请先重试原提交。", true); return; }
+		if (executeRequested && draft.submission.operationId) { setStatus("这份草稿已经提交，请查看上方操作进度。"); return; }
 		void (async () => {
 			if (selectedCandidate.truncated) {
 				setStatus("所选失败提示词已截断，不能作为完整提示词重启。", true);
@@ -2440,15 +2750,22 @@ async function renderPromptRestart(content, dagRunId, node) {
 				return;
 			}
 			submit.disabled = true;
+			start.disabled = true;
+			const requestedSignature = signature();
 			try {
-				setStatus("正在做重跑资格预检（dagRerunPlan）…");
 				const overrides = [{ nodeId, prompt, mode }];
+				let plan = prepared?.plan;
+				if (!executeRequested) {
+					invalidatePlan();
+				setStatus("正在检查这次重跑是否安全可行…");
+					if (workspaceScope() !== formScope) return;
 				const planRes = await postOperatorAction("dagRerunPlan", {
 					runId: dagRunId,
 					fromNode: nodeId,
 					promptOverrides: overrides,
 				});
-				const plan = planRes.body?.result ?? null;
+					if (workspaceScope() !== formScope) return;
+					plan = planRes.body?.result ?? null;
 				if (!planRes.ok || plan?.eligible !== true || !plan?.planHash) {
 					setStatus(
 						planRes.body?.error?.message ??
@@ -2459,53 +2776,69 @@ async function renderPromptRestart(content, dagRunId, node) {
 					return;
 				}
 
+					if (signature() !== requestedSignature) { setStatus("草稿已变化，请重新预览。"); return; }
+					prepared = { plan, signature: requestedSignature };
+					clearNode(planHost);
+					planHost.appendChild(transparencyMetaList([
+						["将重新执行", (plan.resetNodeIds ?? []).join(", ") || "无"],
+						["将沿用结果", (plan.importedNodeIds ?? []).join(", ") || "无"],
+						["预计风险", inspectorValueLabel("风险级别", plan.risk)],
+						["预计执行", `${plan.estimatedExecution?.nodeCount ?? "未记录"} 个节点 · ${plan.estimatedExecution?.piCallCount ?? "未记录"} 次 AI 调用`],
+					]));
+					const change = el("details", "prompt-change-preview");
+					change.appendChild(el("summary", null, mode === "append" ? "查看将追加的指令" : "查看替换前后提示词"));
+					if (mode === "replace") { change.appendChild(el("h5", null, "修改前")); change.appendChild(el("pre", "prompt-restart-readonly", selectedCandidate.prompt)); }
+					change.appendChild(el("h5", null, "本次提交")); change.appendChild(el("pre", "prompt-restart-readonly", prompt));
+					planHost.appendChild(change);
+					start.disabled = false;
+					setStatus("预览已就绪。确认后创建新运行；编辑草稿会使本次预览失效。");
+					return;
+				}
+				if (prepared?.signature !== requestedSignature) { invalidatePlan(); setStatus("草稿已变化，请重新预览。", true); return; }
+
 				const est = plan.estimatedExecution;
 				const estText = est
-					? `（将执行 ${est.nodeCount ?? "?"} 个节点 / ${est.piCallCount ?? "?"} 次 Pi 调用）`
+					? `（将执行 ${est.nodeCount ?? "?"} 个节点，其中 ${est.piCallCount ?? "?"} 个需要 AI 处理）`
 					: "";
-				setStatus(`预检通过${estText}，正在提交续跑（dagRerun）…`);
-				const clientRequestId = `inspect-prompt-restart-${Date.now()}-${Math.random()
-					.toString(36)
-					.slice(2, 10)}`;
-				const runRes = await postOperatorAction(
-					"dagRerun",
-					{
-						runId: dagRunId,
-						fromNode: nodeId,
-						planHash: plan.planHash,
-						reason,
-						promptOverrides: overrides,
-					},
-					clientRequestId,
-				);
+				setStatus(`检查通过${estText}，正在创建新运行…`);
+				if (workspaceScope() !== formScope) return;
+				draft.submission = createInspectorSubmission("dagRerun", {
+					runId: dagRunId, fromNode: nodeId, planHash: plan.planHash, reason, promptOverrides: overrides,
+				});
+				const runRes = await sendInspectorSubmission(draft.submission, postOperatorAction);
+				if (workspaceScope() !== formScope) return;
 				const operationId = runRes.body?.operationId;
 				if (!runRes.ok || !operationId) {
 					setStatus(runRes.body?.error?.message ?? "提交续跑失败。", true);
 					return;
 				}
 
+				submitted = true;
+				draft.submission.operationId = operationId;
+				trackInspectorOperation(dagRunId, nodeId, operationId);
 				const op = await pollOperationToTerminal(operationId, (text) =>
-					setStatus(text),
+					setStatus(text), formScope,
 				);
+				if (workspaceScope() !== formScope) return;
 				if (op?.state === "succeeded") {
 					const newRunId =
 						op.dagRunId ?? op.result?.newRunId ?? op.runSummary?.runId ?? null;
 					if (newRunId) {
-						setStatus(`重启完成，新 run：${newRunId}`);
+						setStatus(`重启完成，新运行：${newRunId}`);
 						const open = document.createElement("button");
 						open.type = "button";
 						open.className = "prompt-restart-submit is-secondary";
-						open.textContent = "打开新 run";
+						open.textContent = "打开新运行";
 						open.addEventListener("click", () => {
 							navigate(`/dag/${encodeURIComponent(String(newRunId))}`);
 						});
 						row.appendChild(open);
 					} else {
-						setStatus("重启完成（未能解析新 run id，请在 DAG 历史中查看）。");
+						setStatus("重启完成（暂时无法取得新运行编号，请在 DAG 历史中查看）。");
 					}
 				} else if (op) {
 					setStatus(
-						`续跑操作终态：${op.state}${op.errorMessage ? ` — ${op.errorMessage}` : ""}`,
+						`新运行最终状态：${inspectorValueLabel("status", op.state)}${op.errorMessage ? ` — ${op.errorMessage}` : ""}`,
 						true,
 					);
 				} else {
@@ -2514,14 +2847,73 @@ async function renderPromptRestart(content, dagRunId, node) {
 			} catch (err) {
 				setStatus(err instanceof Error ? err.message : String(err), true);
 			} finally {
-				submit.disabled = false;
+				draft.submission.inFlight = false;
+				submit.disabled = submitted;
+				start.disabled = submitted || !prepared || hasUnresolvedSubmission(draft.submission);
+				syncPromptRetry();
 			}
 		})();
+	};
+	submit.addEventListener("click", () => handleSubmission(false));
+	start.addEventListener("click", () => handleSubmission(true));
+}
+
+function mountSubmissionRetry(host, draft, dagRunId, nodeId, scope, setStatus) {
+	const retry = el("button", "btn btn-secondary", "重试原提交");
+	retry.type = "button";
+	retry.setAttribute("data-tooltip", "原样重放已确认的请求，避免重复创建运行");
+	host.appendChild(retry);
+	const sync = () => {
+		retry.hidden = !hasUnresolvedSubmission(draft.submission);
+		retry.disabled = Boolean(draft.submission?.inFlight);
+	};
+	retry.addEventListener("click", async () => {
+		if (workspaceScope() !== scope || !hasUnresolvedSubmission(draft.submission)) return;
+		retry.disabled = true;
+		try {
+			setStatus("正在核对原提交结果…");
+			const response = await sendInspectorSubmission(draft.submission, postOperatorAction);
+			if (workspaceScope() !== scope) return;
+			if (!response.ok || !draft.submission.operationId) {
+				setStatus(response.body?.error?.message ?? "结果仍未确认，可以继续重试原提交。", true);
+				return;
+			}
+			trackInspectorOperation(dagRunId, nodeId, draft.submission.operationId);
+			const operation = await pollOperationToTerminal(draft.submission.operationId, setStatus, scope);
+			if (workspaceScope() === scope) setStatus(operation ? `操作状态：${inspectorValueLabel("status", operation.state)}` : "等待结束，可在操作台查看进度。");
+		} catch (error) {
+			setStatus(error instanceof Error ? error.message : "结果未确认，请重试原提交。", true);
+		} finally { sync(); }
 	});
+	sync();
+	return sync;
+}
+
+function trackInspectorOperation(dagRunId, nodeId, operationId) {
+	inspectorOperations.set(operationId, { dagRunId, nodeId, operationId, operation: { state: "queued" } });
+	refreshInspectorOperations();
+}
+function mountInspectorOperations(content, dagRunId, nodeId) {
+	let host = content.querySelector(".inspector-operations");
+	if (!host) { host = el("div", "inspector-operations"); content.insertBefore(host, content.firstChild); }
+	clearNode(host);
+	for (const tracked of inspectorOperations.values()) {
+		if (tracked.dagRunId !== dagRunId || tracked.nodeId !== nodeId) continue;
+		const card = el("div", "inspector-operation");
+		card.appendChild(el("p", null, `已提交 · ${tracked.operationId} · ${inspectorValueLabel("status", tracked.operation.state)}`));
+		const runId = tracked.operation.dagRunId ?? tracked.operation.result?.newRunId ?? tracked.operation.runSummary?.runId;
+		if (runId) { const link = el("a", "object-link", "打开新运行"); link.href = inspectPathToCanonicalHref(`/dag/${encodeURIComponent(runId)}`); card.appendChild(link); }
+		if (tracked.operation.errorMessage) card.appendChild(el("p", "node-input-error", tracked.operation.errorMessage));
+		host.appendChild(card);
+	}
+}
+function refreshInspectorOperations() {
+	const content = document.querySelector(".dag-inspector-content[data-inspector-tab='prompt-restart']");
+	if (content) mountInspectorOperations(content, content.dataset.dagRunId, content.dataset.dagNodeId);
 }
 
 /** Poll a Console operation until a terminal state; null on poll budget end. */
-async function pollOperationToTerminal(operationId, onProgress) {
+async function pollOperationToTerminal(operationId, onProgress, operationScope = workspaceScope()) {
 	const terminal = new Set([
 		"succeeded",
 		"failed",
@@ -2529,9 +2921,12 @@ async function pollOperationToTerminal(operationId, onProgress) {
 		"needs-reconcile",
 	]);
 	for (let attempt = 0; attempt < 1200; attempt += 1) {
+		if (workspaceScope() !== operationScope) return null;
 		const res = await fetchOperatorOperation(operationId);
+		if (workspaceScope() !== operationScope) return null;
 		const op = res.body?.operation ?? res.body;
 		const state = op?.state ?? "";
+		if (res.ok && inspectorOperations.has(operationId)) { Object.assign(inspectorOperations.get(operationId), { operation: op }); refreshInspectorOperations(); }
 		if (res.ok && terminal.has(state)) {
 			return op;
 		}
@@ -2552,8 +2947,9 @@ function transparencyMetaList(rows) {
 
 function renderNodeOverview(content, dagRunId, node) {
 	const root = el("div", "node-transparency-root");
+	root.appendChild(buildInspectorPageLead("overview"));
 	root.appendChild(
-		el("p", "node-input-semantics", "本页只展示当前运行已持久化的节点事实。"),
+		el("p", "node-input-semantics", "这里展示系统为当前运行保存的真实记录；字段已转换为易懂名称，悬停可查看原始技术字段。"),
 	);
 	const summary = el("section", "node-input-section");
 	summary.appendChild(el("h4", null, "节点事实"));
@@ -2571,12 +2967,12 @@ function renderNodeOverview(content, dagRunId, node) {
 	);
 	root.appendChild(summary);
 	const semantics = el("section", "node-input-section");
-	semantics.appendChild(el("h4", null, "事实阶段"));
+	semantics.appendChild(el("h4", null, "这些信息分别在什么时候产生"));
 	semantics.appendChild(
 		el(
 			"p",
 			"muted",
-			"输入页是 frozen declaration；有效上下文页是 dispatch-time receipt；产物页是执行后 materialization。缺失阶段会明确标记，不用预览冒充事实。",
+			"“执行设置”是运行开始前保存的配置；“实际上下文”是下发任务时真正交给节点的内容；“产出”是执行结束后保存的文件。缺少哪个阶段会明确显示，预览内容不会被当成已经发生的事实。",
 		),
 	);
 	root.appendChild(semantics);
@@ -2591,26 +2987,28 @@ function selectedAttemptNumber(dagRunId, node) {
 }
 
 async function renderEffectiveContext(content, dagRunId, node) {
-	content.appendChild(el("p", "muted", "正在加载有效上下文事实…"));
-	const result = await fetchDagNodeContext(
-		dagRunId,
-		node.nodeId,
-		selectedAttemptNumber(dagRunId, node),
-	);
+	const requestToken = Symbol("context-request");
+	content._contextRequestToken = requestToken;
+	const requestedExecutionKey = effectiveExecutionKey(dagRunId, node);
+	const requestedScope = workspaceScope();
+	ensureInspectorPageLead(content, "context");
+	if (requestedExecutionKey?.startsWith("pass-")) {
+		content.appendChild(el("p", "node-transparency-omission", "该修复轮次没有独立保存的上下文记录。现有记录无法区分各个修复轮次。"));
+		restoreInspectorContentScroll(content, dagRunId, node.nodeId, "context");
+		return;
+	}
+	content.appendChild(el("p", "muted", "正在读取这次尝试的上下文…"));
+	const result = await fetchDagNodeContext(dagRunId, node.nodeId, selectedAttemptNumber(dagRunId, node));
 	if (
-		!content.isConnected ||
+		!content.isConnected || content._contextRequestToken !== requestToken || workspaceScope() !== requestedScope ||
 		content.dataset.dagRunId !== String(dagRunId) ||
 		content.dataset.dagNodeId !== String(node.nodeId) ||
-		activeInspectorTab() !== "context"
-	)
-		return;
+		activeInspectorTab() !== "context" || requestedExecutionKey !== effectiveExecutionKey(dagRunId, node)
+	) return;
 	clearNode(content);
+	ensureInspectorPageLead(content, "context");
 	if (!result.ok || !result.body) {
-		const error = el(
-			"p",
-			"node-input-error",
-			result.body?.error || "无法加载有效上下文事实。",
-		);
+		const error = el("p", "node-input-error", result.body?.error || "无法读取这次尝试的上下文。");
 		error.setAttribute("role", "alert");
 		content.appendChild(error);
 		return;
@@ -2618,103 +3016,186 @@ async function renderEffectiveContext(content, dagRunId, node) {
 	const data = result.body;
 	const receipt = data.effectiveContext;
 	const root = el("div", "node-transparency-root");
-	root.appendChild(
-		transparencyMetaList([
-			["attempt", data.attempt],
-			["declared", data.declared?.status],
-			["dispatched", data.dispatched?.status],
-			["node status", data.dispatched?.nodeStatus],
-		]),
-	);
+	root.appendChild(el("p", "context-record-heading", `第 ${data.attempt} 次尝试 · ${receipt?.status === "captured" ? "已保存上下文" : "上下文不可用"}`));
 	if (receipt?.status !== "captured") {
 		const missing = el("div", "node-transparency-omission");
-		missing.appendChild(
-			el(
-				"h4",
-				null,
-				receipt?.status === "invalid" ? "Receipt 不可用" : "未捕获",
-			),
-		);
-		missing.appendChild(
-			el("code", null, receipt?.reasonCode ?? "CONTEXT_RECEIPT_MISSING"),
-		);
-		const missingLabel = contextTransferReasonLabel(
-			receipt?.reasonCode ?? "CONTEXT_RECEIPT_MISSING",
-		);
-		if (missingLabel) {
-			missing.appendChild(el("p", "muted", missingLabel));
-		}
-		missing.appendChild(
-			el(
-				"p",
-				"muted",
-				"当前只有 frozen input / prompt 指纹；它们不是 Effective Context。历史 run 不做事后回填。",
-			),
-		);
+		const reasonCode = receipt?.reasonCode ?? "CONTEXT_RECEIPT_MISSING";
+		const missingLabel = contextTransferReasonLabel(reasonCode);
+		missing.appendChild(el("h4", null, receipt?.status === "invalid" ? "记录未通过完整性检查" : "没有保存这次尝试的上下文"));
+		const reason = el("p", "muted", missingLabel ?? reasonCode);
+		if (missingLabel) reason.setAttribute("title", `技术代码：${reasonCode}`);
+		missing.appendChild(reason);
+		missing.appendChild(el("p", "muted", "无法确认当时实际收到的材料。你可以在“执行设置”查看运行前的配置；较早的运行不会事后补写上下文记录。"));
 		root.appendChild(missing);
 	} else {
-		const captured = el("section", "node-input-section");
-		captured.appendChild(el("h4", null, "Captured receipt"));
-		captured.appendChild(
-			transparencyMetaList([
-				["context digest", receipt.contextDigest],
-				["captured at", receipt.capturedAt],
-				["components", receipt.componentCount],
-				["truncations", receipt.truncationCount],
-				["executor", receipt.runtime?.executor],
-				["model", receipt.runtime?.model],
-				["skills", receipt.runtime?.skillCount],
-				["extensions", receipt.runtime?.extensionCount],
-				["tools", receipt.runtime?.toolCount],
-			]),
-		);
-		appendCodeList(
-			captured,
-			"组件类型",
-			Object.entries(receipt.componentKinds ?? {}).map(
-				([kind, count]) => `${kind}: ${count}`,
-			),
-		);
-		appendCodeList(
-			captured,
-			"包含状态",
-			Object.entries(receipt.inclusionCounts ?? {}).map(
-				([kind, count]) => `${kind}: ${count}`,
-			),
-		);
+		const components = receipt.components ?? [];
+		const savedCount = components.filter((part) => part.previewAvailable).length;
+		const referenceCount = components.filter((part) => part.inclusion === "reference-only").length;
+		const omittedCount = components.filter((part) => part.inclusion === "omitted").length;
+		root.appendChild(el("p", "context-record-meta", [
+			receipt.runtime?.model, receipt.capturedAt ? `记录于 ${new Date(receipt.capturedAt).toLocaleString("zh-CN", { hour12: false })}` : null,
+			`${savedCount} 项可查看正文`, referenceCount ? `${referenceCount} 项仅有引用` : null,
+			omittedCount ? `${omittedCount} 项未包含` : null,
+		].filter(Boolean).join(" · ")));
+		const captured = el("section", "node-input-section context-materials");
+		captured.appendChild(el("h4", null, "这次尝试的材料"));
+		captured.appendChild(el("p", "muted", "展开材料查看当时保存的正文。仅有引用的材料未保存独立正文。"));
+		for (const component of components) {
+			const details = el("details", "context-component");
+			const summary = el("summary", null);
+			const kind = inspectorValueLabel("kind", component.kind);
+			const name = inspectorValueLabel("kind", component.logicalName || component.kind);
+			summary.appendChild(el("span", "context-component-name", name));
+			summary.appendChild(el("span", "context-component-meta", [name === kind ? null : kind, inspectorValueLabel("inclusion", component.inclusion)].filter(Boolean).join(" · ")));
+			details.appendChild(summary);
+			if (!component.previewAvailable) {
+				details.appendChild(el("p", "muted", component.inclusion === "omitted" ? "这项材料未包含在本次上下文中。" : "仅登记了材料信息，未保存当时的独立正文。"));
+			} else {
+				let loading = false, loaded = false;
+				const body = el("div", "context-component-body");
+				details.appendChild(body);
+				details.addEventListener("toggle", () => {
+					if (!details.open || loaded || loading) return;
+					loading = true; body.textContent = "正在读取保存的正文…";
+					void fetchJson(`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(node.nodeId)}/context/component?attempt=${data.attempt}&componentIndex=${component.index}`).then((part) => {
+						loading = false;
+						if (!body.isConnected || workspaceScope() !== requestedScope) return;
+						clearNode(body);
+						if (typeof part?.content !== "string") { body.appendChild(el("p", "node-input-error", "正文不可用，收起后可重试。")); return; }
+						loaded = true;
+						body.appendChild(renderInspectorDocument(part.content));
+						const copy = iconButton("复制已显示正文", "ri-file-copy-line");
+						copy.type = "button";
+						copy.addEventListener("click", async () => { const copied = await copyText(part.content); setIconButton(copy, copied ? "已复制" : "复制失败", copied ? "ri-check-line" : "ri-error-warning-line"); });
+						body.appendChild(copy);
+						if (part.truncated || part.redacted) body.appendChild(el("p", "muted", [part.truncated ? "正文预览已截断" : "", part.redacted ? "已脱敏" : ""].filter(Boolean).join(" · ")));
+					});
+				});
+			}
+			const source = el("details", "context-source-details");
+			source.appendChild(el("summary", null, "材料来源信息"));
+			source.appendChild(transparencyMetaList([["来源", component.sourceIdentity], ["大小", `${component.bytes} 字节`], ["记录说明", component.omissionReason]]));
+			details.appendChild(source);
+			captured.appendChild(details);
+		}
 		root.appendChild(captured);
+		const diagnostics = el("details", "context-source-details");
+		diagnostics.appendChild(el("summary", null, "来源与校验信息"));
+		diagnostics.appendChild(transparencyMetaList([
+			["context digest", receipt.contextDigest], ["captured at", receipt.capturedAt],
+			["executor", receipt.runtime?.executor], ["components", receipt.componentCount],
+			["truncations", receipt.truncationCount], ["skills", receipt.runtime?.skillCount],
+			["extensions", receipt.runtime?.extensionCount], ["tools", receipt.runtime?.toolCount],
+		]));
+		root.appendChild(diagnostics);
 	}
 	content.appendChild(root);
 	restoreInspectorContentScroll(content, dagRunId, node.nodeId, "context");
 }
 
+async function recordedAttempt(dagRunId, node, key) {
+	const [output, context] = await Promise.all([
+		fetchJsonResult(`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(node.nodeId)}/execution-output?key=${encodeURIComponent(key)}`),
+		/^attempt-/.test(key) ? fetchDagNodeContext(dagRunId, node.nodeId, Number(key.slice(8))) : Promise.resolve(null),
+	]);
+	return { key, output: output.ok ? output.body : null, preview: attemptSelectorOptions(node).find((item) => item.key === key)?.preview, model: context?.ok && context.body?.effectiveContext?.status === "captured" ? context.body.effectiveContext.runtime?.model : null };
+}
+function attemptDiagnostic(dagRunId, node, recorded) {
+	const output = recorded.output;
+	return [`# 节点诊断`, `运行：${dagRunId}`, `节点：${node.nodeId}`, `执行：${recorded.key}`, `状态：${recorded.preview?.status ?? "未记录"}`, `失败分类：${recorded.preview?.failureCategory ?? "未记录"}`, `耗时：${recorded.preview?.durationMs != null ? formatMs(recorded.preview.durationMs) : "未记录"}`, `模型：${recorded.model ?? "未记录"}`, `记录时间：${output?.timestamp ?? "未记录"}`, `范围：当前尝试保存的输出${output?.truncated ? "（接口已截断）" : ""}`, `位置：${new URL(inspectPathToCanonicalHref(`/dag/${encodeURIComponent(dagRunId)}?node=${encodeURIComponent(node.nodeId)}&tab=output&attempt=${recorded.key}`), location.href).href}`, "", "错误输出：", output?.stderr || "未记录"].join("\n");
+}
+async function renderAttemptComparison(content, dagRunId, node) {
+	const options = attemptSelectorOptions(node);
+	if (options.length < 2) return;
+	const toolbar = el("div", "attempt-comparison-toolbar"), body = el("div", "attempt-comparison-columns");
+	const selects = [];
+	const reading = content._readingState;
+	for (const [index, label] of ["左侧执行", "右侧执行"].entries()) {
+		const select = el("select"); select.setAttribute("aria-label", label);
+		for (const option of options) { const item = el("option", null, option.label); item.value = option.key; select.appendChild(item); }
+		const previous = reading?.comparisonKeys?.[index];
+		select.value = options.some((option) => option.key === previous) ? previous : options[Math.max(0, options.length - 2 + index)].key;
+		toolbar.appendChild(select); selects.push(select);
+	}
+	content.appendChild(toolbar); content.appendChild(body);
+	let generation = 0;
+	const render = async () => {
+		if (reading) reading.comparisonKeys = selects.map((select) => select.value);
+		const request = ++generation; body.textContent = "正在读取各次执行记录…";
+		const records = await Promise.all(selects.map((select) => recordedAttempt(dagRunId, node, select.value)));
+		if (request !== generation || !body.isConnected) return;
+		clearNode(body);
+		for (const record of records) {
+			const column = el("section", "attempt-comparison-column");
+			column.appendChild(el("h4", null, options.find((item) => item.key === record.key)?.label));
+			column.appendChild(transparencyMetaList([["状态", record.preview?.status ?? "未记录"], ["失败分类", record.preview?.failureCategory ?? "未记录"], ["耗时", record.preview?.durationMs != null ? formatMs(record.preview.durationMs) : "未记录"], ["模型", record.model ?? "未记录"]]));
+			column.appendChild(el("p", "muted", record.output?.truncated ? "本次输出已截断" : "本次已保存的输出"));
+			column.appendChild(renderInspectorDocument(record.output?.assistantText || record.output?.stdout || "未记录正文"));
+			if (record.output?.stderr) column.appendChild(el("pre", "node-input-error", record.output.stderr));
+			body.appendChild(column);
+		}
+		const left = records[0].output, right = records[1].output;
+		const summary = el("p", "muted", left && right ? (JSON.stringify([left.assistantText, left.stdout, left.stderr]) === JSON.stringify([right.assistantText, right.stdout, right.stderr]) ? "两次已保存的输出相同。" : "两次已保存的输出有差异，可逐列对照；模型、耗时仅使用各次记录。") : "部分执行缺少正文，无法判断完整差异。");
+		body.insertBefore(summary, body.firstChild);
+	};
+	for (const select of selects) select.addEventListener("change", () => { void render(); });
+	await render();
+}
+
+function inspectorNodeLink(dagRunId, nodeId, label = nodeId) {
+	const link = el("a", "object-link", label);
+	link.href = inspectPathToCanonicalHref(`/dag/${encodeURIComponent(dagRunId)}?node=${encodeURIComponent(nodeId)}&tab=overview`);
+	return link;
+}
+function appendNodeLinks(parent, title, dagRunId, nodeIds) {
+	if (!nodeIds.length) return;
+	const section = el("div", "node-relation-links"); section.appendChild(el("h5", null, title));
+	for (const id of nodeIds) section.appendChild(inspectorNodeLink(dagRunId, id));
+	parent.appendChild(section);
+}
+
+/** 长校验码截断显示：中段省略，完整值保留在 title（人工可读优先）。 */
+function shortHashDisplay(value) {
+	const raw = String(value ?? "");
+	if (raw.length <= 24) return raw;
+	return `${raw.slice(0, 10)}…${raw.slice(-6)}`;
+}
+
 function artifactInventorySection(data, dagRunId, nodeId) {
 	const root = el("section", "node-input-section node-artifact-inventory");
-	root.appendChild(el("h4", null, "声明产物与消费关系"));
+	root.appendChild(el("h4", null, "本节点生成和使用的文件"));
+	root.appendChild(el("p", "muted", "文件关系属于整个节点；下方执行输出随尝试切换。"));
 	if (!data?.binding?.available) {
 		const warning = el("div", "node-transparency-omission");
 		const bindingCode =
 			data?.binding?.reasonCode ?? "ARTIFACT_BINDING_UNAVAILABLE";
-		warning.appendChild(el("code", null, bindingCode));
 		const bindingLabel = contextTransferReasonLabel(bindingCode);
-		if (bindingLabel) {
-			warning.appendChild(el("p", "muted", bindingLabel));
-		}
+		const reason = el("p", "muted", bindingLabel ?? bindingCode);
+		if (bindingLabel) reason.setAttribute("title", `技术代码：${bindingCode}`);
+		warning.appendChild(reason);
 		warning.appendChild(
 			el(
 				"p",
 				"muted",
-				"该历史 run 没有 frozen Artifact Binding；不会从 prompt、outputContract、路径或文件名推断 consumer。",
+				"这个较早的运行没有保存明确的文件使用关系；系统不会根据提示词、输出要求或文件名猜测谁会使用它。",
 			),
 		);
 		root.appendChild(warning);
 		return root;
 	}
+	const graphSha = data.binding.artifactGraphSha256;
+	const graphShaCell = graphSha
+		? (() => {
+				const code = el("code", "artifact-hash-code", shortHashDisplay(graphSha));
+				code.setAttribute("title", `完整校验码：${graphSha}`);
+				return code;
+			})()
+		: null;
 	root.appendChild(
 		transparencyMetaList([
 			["origin", data.origin?.kind ?? "unknown"],
 			["parent", data.origin?.parentRunId ?? null],
-			["graph sha256", data.binding.artifactGraphSha256],
+			["graph sha256", graphShaCell],
 		]),
 	);
 	for (const artifact of data.produces ?? []) {
@@ -2740,11 +3221,7 @@ function artifactInventorySection(data, dagRunId, nodeId) {
 				],
 			]),
 		);
-		appendCodeList(
-			card,
-			"Direct consumers",
-			artifact.directConsumerNodeIds ?? [],
-		);
+		appendNodeLinks(card, "会直接使用此文件的节点", dagRunId, artifact.directConsumerNodeIds ?? []);
 		if (artifact.materialization?.status === "materialized") {
 			card.appendChild(
 				createArtifactContentPreview(dagRunId, nodeId, () => artifact, {
@@ -2756,10 +3233,10 @@ function artifactInventorySection(data, dagRunId, nodeId) {
 	}
 	for (const artifact of data.consumes ?? []) {
 		const card = el("div", "node-artifact-card is-consumed");
-		card.appendChild(el("h5", null, `消费 ${artifact.artifactId}`));
+		card.appendChild(el("h5", null, `使用 ${artifact.artifactId}`));
 		card.appendChild(
 			transparencyMetaList([
-				["producer", artifact.producerNodeId],
+				["producer", inspectorNodeLink(dagRunId, artifact.producerNodeId)],
 				["path", artifact.path],
 				["required", artifact.required ? "yes" : "no"],
 			]),
@@ -2775,7 +3252,7 @@ function artifactInventorySection(data, dagRunId, nodeId) {
 		(data.produces ?? []).length === 0 &&
 		(data.consumes ?? []).length === 0
 	) {
-		root.appendChild(el("p", "empty", "该节点没有声明的产物绑定。"));
+		root.appendChild(el("p", "empty", "该节点没有登记会生成或使用的文件。"));
 	}
 	return root;
 }
@@ -2789,6 +3266,23 @@ async function prependArtifactInventory(content, dagRunId, node) {
 		activeInspectorTab() !== "output"
 	)
 		return;
+	// 失败节点优先暴露错误：没有登记任何文件关系时空卡不占首屏，
+	// 「没有登记」这一事实由错误输出之后的一行说明保留。
+	const body = result.ok ? result.body : null;
+	const emptyInventory =
+		body?.binding?.available &&
+		(body.produces ?? []).length === 0 &&
+		(body.consumes ?? []).length === 0;
+	if (isNodeFailed(node?.status) && emptyInventory) {
+		const note = el(
+			"p",
+			"empty node-artifact-inventory-empty",
+			"该节点没有登记会生成或使用的文件。",
+		);
+		const lead = content.querySelector(".inspector-page-lead");
+		content.insertBefore(note, lead?.nextSibling ?? content.firstChild);
+		return;
+	}
 	const section =
 		result.ok && result.body
 			? artifactInventorySection(result.body, dagRunId, node.nodeId)
@@ -2797,10 +3291,12 @@ async function prependArtifactInventory(content, dagRunId, node) {
 					"node-input-error node-artifact-inventory",
 					result.body?.error || "无法加载产物绑定事实。",
 				);
-	content.insertBefore(section, content.firstChild);
+	const lead = content.querySelector(".inspector-page-lead");
+	content.insertBefore(section, lead?.nextSibling ?? content.firstChild);
 }
 
 async function renderRunLineage(content, dagRunId, node) {
+	ensureInspectorPageLead(content, "lineage");
 	content.appendChild(el("p", "muted", "正在加载来源与影响关系…"));
 	const result = await fetchDagRunLineage(dagRunId);
 	if (
@@ -2811,6 +3307,7 @@ async function renderRunLineage(content, dagRunId, node) {
 	)
 		return;
 	clearNode(content);
+	ensureInspectorPageLead(content, "lineage");
 	if (!result.ok || !result.body) {
 		content.appendChild(
 			el("p", "node-input-error", result.body?.error || "无法加载来源与影响关系。"),
@@ -2819,28 +3316,18 @@ async function renderRunLineage(content, dagRunId, node) {
 	}
 	const data = result.body;
 	const root = el("div", "node-transparency-root");
-	const intro = el("section", "node-lineage-intro");
-	intro.append(
-		el("h4", null, "这个节点从哪里来，会影响哪里"),
-		el(
-			"p",
-			"muted",
-			"这里展示派生运行继承、替换或重新执行了哪些节点。产出文件的直接使用者请到“产出”中查看。",
-		),
-	);
-	root.appendChild(intro);
 	root.appendChild(
 		transparencyMetaList([
 			["运行类型", data.kind === "root" ? "首次运行" : "派生运行"],
-			["来源运行", data.parentRunId ?? null],
-			["发起方式", data.trigger ?? null],
+			["来源运行", data.parentRunId ? inspectorNodeLink(data.parentRunId, data.operatorSelectedNodeId || node.nodeId, data.parentRunId) : null],
+			["发起方式", inspectorValueLabel("发起方式", data.trigger)],
 			["人工选择节点", data.operatorSelectedNodeId ?? null],
 			["从此节点重新执行", data.effectiveFromNodeId ?? null],
 			["重跑计划哈希", data.planHash ?? null],
 		]),
 	);
-	appendCodeList(root, "沿用既有结果的节点", data.importedNodeIds ?? []);
-	appendCodeList(root, "替换结果的节点", data.overriddenNodeIds ?? []);
+	appendNodeLinks(root, "沿用既有结果的节点", dagRunId, data.importedNodeIds ?? []);
+	appendNodeLinks(root, "替换结果的节点", dagRunId, data.overriddenNodeIds ?? []);
 	if (data.kind === "root")
 		root.appendChild(
 			el("p", "muted", "这是首次运行，没有来源运行。"),
@@ -2849,19 +3336,41 @@ async function renderRunLineage(content, dagRunId, node) {
 	restoreInspectorContentScroll(content, dagRunId, node.nodeId, "lineage");
 }
 
+function inspectorTabDefinitions(node = inspectorSelection.node) {
+	const options = node ? attemptSelectorOptions(node) : [];
+	const hasPassOnlyHistory = options[0]?.key.startsWith("pass-");
+	const tabDefs = DAG_INSPECTOR_READ_ONLY_TABS.filter(([tab]) => {
+		if (tab === "lineage") return Boolean(inspectorSelection.run?.continuation?.parentRunId);
+		if (tab === "context") return !["shell", "static"].includes(node?.executor) && !hasPassOnlyHistory;
+		if (tab === "timeline") return node?.executor !== "static";
+		return true;
+	}).map((definition) => [...definition]);
+	if (options.length >= 2) {
+		tabDefs.splice(tabDefs.findIndex(([tab]) => tab === "spec-evidence"), 0, ["compare", "尝试对比", "ri-layout-column-line"]);
+	}
+	// A scoped credential controls the mutation surface independently of data.
+	if (globalThis.__INSPECT_MUTATION_TOKEN__) tabDefs.push([...DAG_INSPECTOR_MUTATION_TAB]);
+	return tabDefs;
+}
+
 function activeInspectorTab() {
-	return [
-		"overview",
-		"input",
-		"context",
-		"timeline",
-		"output",
-		"lineage",
-		"spec-evidence",
-		"prompt-restart",
-	].includes(uiState.dagInspectorTab)
-		? uiState.dagInspectorTab
-		: "output";
+	const available = inspectorTabDefinitions().map(([tab]) => tab);
+	const requested = uiState.dagInspectorTab;
+	if (available.includes(requested)) return requested;
+	if (requested == null && ["running", "started"].includes(String(inspectorSelection.node?.status ?? "").toLowerCase())) {
+		return available.includes("timeline") ? "timeline" : "overview";
+	}
+	if (requested === "compare" && available.includes("timeline")) return "timeline";
+	return ["compare", "context", "timeline"].includes(requested) ? "overview" : "output";
+}
+
+function inspectorTabUsesAttempt(tab, node) {
+	return tab === "timeline" || tab === "output" ||
+		(tab === "context" && (node.executionSummary?.attempts?.length ?? 0) > 1);
+}
+
+function inspectorTabExecutionKey(dagRunId, node, tab = activeInspectorTab()) {
+	return inspectorTabUsesAttempt(tab, node) ? effectiveExecutionKey(dagRunId, node) : null;
 }
 
 function saveInspectorContentScroll(
@@ -2872,7 +3381,14 @@ function saveInspectorContentScroll(
 	options = {},
 ) {
 	if (!content) return null;
-	const regionKey = inspectorViewportRegionKey(dagRunId, nodeId, tab);
+	const regionKey = inspectorViewportRegionKey(dagRunId, nodeId, tab, content.dataset.executionKey);
+	if (content._readingState) {
+		const reading = content._readingState;
+		if (!(options.preserveIntent && content.scrollTop === 0 && reading.scrollTop > 0)) {
+			reading.scrollTop = content.scrollTop;
+			reading.scrollLeft = content.scrollLeft;
+		}
+	}
 	const saved = saveDagInspectorViewportState(
 		regionKey,
 		content.scrollLeft,
@@ -2908,7 +3424,8 @@ function saveInspectorContentScroll(
 
 function restoreInspectorContentScroll(content, dagRunId, nodeId, tab) {
 	if (!content) return;
-	const regionKey = inspectorViewportRegionKey(dagRunId, nodeId, tab);
+	const regionKey = inspectorViewportRegionKey(dagRunId, nodeId, tab, content.dataset.executionKey);
+	if (tab === "output" && !content.querySelector(".process-timeline-autoscroll-dock")) content.insertBefore(createTimelineAutoScrollControl(content), content.firstChild);
 	const apply = () => {
 		if (
 			!content.isConnected ||
@@ -2918,19 +3435,14 @@ function restoreInspectorContentScroll(content, dagRunId, nodeId, tab) {
 		) {
 			return;
 		}
-		if (tab === "timeline" && uiState.dagTimelineAutoScrollEnabled !== false) {
+		if ((tab === "timeline" || tab === "output") && content._readingState?.followLatest) {
 			content.scrollLeft = uiState.dagTimelineViewportState?.scrollLeft ?? 0;
 			content.scrollTop = content.scrollHeight;
+			content._lastRestoredTop = content.scrollTop;
+			content._syncTimelineFollow?.();
 			return;
 		}
-		if (tab === "output") {
-			const saved = uiState.dagNodeOutputViewportState;
-			if (saved?.regionKey === regionKey && saved.followLatest) {
-				content.scrollTop = content.scrollHeight;
-				content.scrollLeft = saved.scrollLeft ?? 0;
-				return;
-			}
-		}
+
 		const saved =
 			getDagInspectorViewportState(regionKey) ??
 			(tab === "input" &&
@@ -2945,8 +3457,10 @@ function restoreInspectorContentScroll(content, dagRunId, nodeId, tab) {
 			uiState.dagNodeSpecEvidenceViewportState?.regionKey === regionKey
 				? uiState.dagNodeSpecEvidenceViewportState
 				: null);
-		content.scrollLeft = saved?.scrollLeft ?? 0;
-		content.scrollTop = saved?.scrollTop ?? 0;
+		content.scrollLeft = content._readingState?.scrollLeft ?? saved?.scrollLeft ?? 0;
+		content.scrollTop = content._readingState?.scrollTop ?? saved?.scrollTop ?? 0;
+		content._lastRestoredTop = content.scrollTop;
+		content._syncTimelineFollow?.();
 	};
 	apply();
 	if (typeof requestAnimationFrame === "function") {
@@ -2962,7 +3476,13 @@ function ensureInspectorContentScrollCapture(content, dagRunId, nodeId, tab) {
 		() => {
 			const runId = content.dataset.dagRunId;
 			const nId = content.dataset.dagNodeId;
-			const active = activeInspectorTab();
+			const active = content.dataset.inspectorTab;
+			if (["timeline", "output"].includes(active) && content._readingState && content.scrollTop < (content._lastRestoredTop ?? content._readingState.scrollTop) - 1 && content.scrollHeight - content.clientHeight - content.scrollTop > 48) {
+				content._readingState.followLatest = false;
+				uiState.dagTimelineAutoScrollEnabled = false;
+			}
+			content._lastRestoredTop = content.scrollTop;
+			content._syncTimelineFollow?.();
 			if (!runId || !nId || !active) return;
 			saveInspectorContentScroll(content, runId, nId, active, {
 				// Clearing a tall input pane for its loading shell can emit a native
@@ -3070,6 +3590,21 @@ function buildAttemptBar(dagRunId, node) {
 
 	const bar = el("div", "dag-inspector-attempt-bar");
 	bar.appendChild(el("label", "dag-inspector-attempt-label", "执行分次"));
+	const choose = (nextKey, source = "select") => {
+		uiState.dagInspectorAttempt = { dagRunId, nodeId: node.nodeId, key: String(nextKey) };
+		inspectorNodeSelections.set(`${dagRunId}:${node.nodeId}`, uiState.dagInspectorAttempt);
+		renderDagInspectorForCurrent();
+		const nextBar = document.querySelector(".dag-inspector-header .dag-inspector-attempt-bar");
+		const control = nextBar?.querySelector(`[data-attempt-action="${source}"]`);
+		(control && !control.disabled ? control : nextBar?.querySelector(".custom-select-trigger"))?.focus({ preventScroll: true });
+	};
+	const selectedIndex = options.findIndex((option) => option.key === selectedKey);
+	const previous = iconButton("上一次尝试", "ri-arrow-left-s-line");
+	previous.type = "button";
+	previous.dataset.attemptAction = "previous";
+	previous.disabled = selectedIndex <= 0;
+	previous.addEventListener("click", () => choose(options[selectedIndex - 1].key, "previous"));
+	bar.appendChild(previous);
 	const select = createCustomSelect({
 		ariaLabel: "选择执行分次",
 		className: "dag-inspector-attempt-select",
@@ -3078,25 +3613,25 @@ function buildAttemptBar(dagRunId, node) {
 			value: option.key,
 			label: option.label,
 		})),
-		onChange: (nextKey) => {
-			uiState.dagInspectorAttempt = {
-				dagRunId,
-				nodeId: node.nodeId,
-				key: String(nextKey),
-			};
-			renderDagInspectorForCurrent();
-		},
+		onChange: (nextKey) => choose(nextKey),
 	});
 	// Keep raw key on the root for existing integration assertions that read
 	// `.value` after assign + change (StubNode handler contract).
 	select.value = selectedKey;
 	bar.appendChild(select);
+	const next = iconButton("下一次尝试", "ri-arrow-right-s-line");
+	next.type = "button";
+	next.dataset.attemptAction = "next";
+	next.disabled = selectedIndex >= options.length - 1;
+	next.addEventListener("click", () => choose(options[selectedIndex + 1].key, "next"));
+	bar.appendChild(next);
 
 	const selected =
 		options.find((option) => option.key === selectedKey) ??
 		options[options.length - 1];
 	const data = selected.preview ?? {};
 	const preview = el("div", "dag-inspector-attempt-preview");
+	preview.setAttribute("title", [data.failureCategory ? attemptFailureLabel(data.failureCategory) : "", data.durationMs != null ? `耗时 ${formatMs(data.durationMs)}` : ""].filter(Boolean).join(" · "));
 	const status = attemptPreviewStatus(data.status);
 	if (status) {
 		preview.appendChild(el("span", `badge badge-${status.cls}`, status.label));
@@ -3125,6 +3660,19 @@ function buildAttemptBar(dagRunId, node) {
 	// 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);
+	const diagnostic = iconButton("诊断摘要", "ri-file-info-line"); diagnostic.type = "button";
+	diagnostic.addEventListener("click", async () => {
+		diagnostic.disabled = true;
+		try {
+			const record = await recordedAttempt(dagRunId, node, selectedKey);
+			const panel = document.querySelector(".dag-inspector-content");
+			if (!panel || panel.dataset.dagNodeId !== node.nodeId || panel.dataset.executionKey !== selectedKey) return;
+			panel.querySelector(".diagnostic-preview")?.remove();
+			const detail = el("details", "diagnostic-preview"); detail.open = true; detail.appendChild(el("summary", null, "诊断摘要预览（仅当前尝试）"));
+			const text = attemptDiagnostic(dagRunId, node, record); detail.appendChild(el("pre", "process-timeline-code", text));
+			const copy = el("button", "btn btn-secondary", "复制摘要"); copy.type = "button"; copy.addEventListener("click", async () => { copy.textContent = await copyText(text) ? "已复制" : "复制失败"; }); detail.appendChild(copy); panel.insertBefore(detail, panel.firstChild); panel.scrollTop = 0; if (panel._readingState) panel._readingState.followLatest = false;
+		} finally { diagnostic.disabled = false; }
+	}); bar.appendChild(diagnostic);
 	return { bar, selectedKey, latestKey, options };
 }
 
@@ -3194,11 +3742,22 @@ function composeExecutionErrorText(payload) {
 	return typeof payload.stderr === "string" ? payload.stderr : "";
 }
 
+function buildExecutionErrorSection(errorText) {
+	const error = el("section", "markdown-error");
+	error.appendChild(el("p", "markdown-error-title", "错误输出"));
+	error.appendChild(renderInspectorDocument(errorText));
+	return error;
+}
+
 function appendOutputBody(content, outputText, errorText, options = null) {
 	if (!outputText && !errorText) {
 		content.appendChild(el("p", "empty", UI_TEXT.noOutput));
 		return;
 	}
+	// 失败节点错误优先：先看错误，再对照正文（正文可能很长）。
+	if (options?.priorityError === true && errorText) {
+		content.appendChild(buildExecutionErrorSection(errorText));
+	}
 	if (outputText) content.appendChild(renderInspectorDocument(outputText));
 	// Truncation note only for full/cached execution-output bodies (AC-003);
 	// preview path never invents truncated/maxBytes.
@@ -3212,15 +3771,13 @@ function appendOutputBody(content, outputText, errorText, options = null) {
 			),
 		);
 	}
-	if (errorText) {
-		const error = el("section", "markdown-error");
-		error.appendChild(el("p", "markdown-error-title", "错误输出"));
-		error.appendChild(renderInspectorDocument(errorText));
-		content.appendChild(error);
+	if (errorText && options?.priorityError !== true) {
+		content.appendChild(buildExecutionErrorSection(errorText));
 	}
 }
 
 function renderCachedOrPreviewBody(content, dagRunId, node, key, isLatest) {
+	const priorityError = isNodeFailed(node?.status);
 	const cached = key
 		? getDagNodeExecutionOutputCache(dagRunId, node.nodeId, key)
 		: null;
@@ -3232,6 +3789,7 @@ function renderCachedOrPreviewBody(content, dagRunId, node, key, isLatest) {
 			{
 				truncated: cached.body.truncated === true,
 				maxBytes: cached.body.maxBytes,
+				priorityError,
 			},
 		);
 		return "cached";
@@ -3241,12 +3799,13 @@ function renderCachedOrPreviewBody(content, dagRunId, node, key, isLatest) {
 			content,
 			node.outputPreview ?? "",
 			node.errorPreview ?? "",
+			{ priorityError },
 		);
 		return "preview";
 	}
 	if (cached && cached.ok === false) {
 		const message =
-			cached.error || "该次执行输出暂不可用（artifact 缺失或无法读取）。";
+			cached.error || "该次执行输出暂不可用（记录文件缺失或无法读取）。";
 		const error = el("p", "empty", message);
 		error.setAttribute("role", "status");
 		content.appendChild(error);
@@ -3290,7 +3849,7 @@ async function loadAndRenderExecutionOutput(
 			(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, {
@@ -3328,7 +3887,8 @@ function repaintOutputTabBody(content, dagRunId, node) {
 	// Remove everything after the attempt bar (or all if no bar).
 	const inventory = content.querySelector(".node-artifact-inventory");
 	const bar = content.querySelector(".dag-inspector-attempt-bar");
-	const keep = [inventory, bar].filter(Boolean);
+	const lead = content.querySelector(".inspector-page-lead");
+	const keep = [lead, inventory, bar].filter(Boolean);
 	while (content.firstChild) content.removeChild(content.firstChild);
 	for (const nodeEl of keep) content.appendChild(nodeEl);
 
@@ -3394,7 +3954,7 @@ function renderProcessCommandCard(command) {
 	details.appendChild(summary);
 	const body = el("div", "process-timeline-card-body");
 	const meta = [
-		command.exitCode != null ? `exit ${command.exitCode}` : null,
+		command.exitCode != null ? `退出码 ${command.exitCode}` : null,
 		command.durationMs != null ? `耗时 ${formatMs(command.durationMs)}` : null,
 		command.failureCategory ? command.failureCategory : null,
 	].filter(Boolean);
@@ -3404,11 +3964,11 @@ function renderProcessCommandCard(command) {
 		);
 	}
 	if (command.stdout) {
-		body.appendChild(el("div", "process-timeline-section-label", "stdout"));
+		body.appendChild(el("div", "process-timeline-section-label", "正常输出"));
 		appendProcessPre(body, command.stdout);
 	}
 	if (command.stderr) {
-		body.appendChild(el("div", "process-timeline-section-label", "stderr"));
+		body.appendChild(el("div", "process-timeline-section-label", "错误输出"));
 		appendProcessPre(body, command.stderr);
 	}
 	if (command.truncated) {
@@ -3505,39 +4065,7 @@ function renderNonPiProcess(content, body) {
 		ul.appendChild(li);
 	}
 	content.appendChild(ul);
-	appendProcessExportButton(content, body, body);
-}
-
-function downloadTextFile(filename, text) {
-	const blob = new Blob([text], { type: "text/html;charset=utf-8" });
-	const url = URL.createObjectURL(blob);
-	const a = document.createElement("a");
-	a.href = url;
-	a.download = filename;
-	document.body.appendChild(a);
-	a.click();
-	a.remove();
-	URL.revokeObjectURL(url);
-}
-
-function appendProcessExportButton(content, body, meta) {
-	if (!body || ((body.commands ?? []).length === 0 && (body.steps ?? []).length === 0)) return;
-	const toolbar = el("div", "process-timeline-export-bar");
-	const btn = el("button", "btn btn-secondary", "导出 HTML");
-	btn.type = "button";
-	btn.addEventListener("click", async () => {
-		const cssText = await fetchPageStylesheetText();
-		// 复用页面真实渲染 DOM，保证导出排版与页面一致。
-		const clone = content.cloneNode(true);
-		const bar = clone.querySelector(".process-timeline-export-bar");
-		if (bar) bar.remove();
-		downloadTextFile(
-			`node-process-${meta?.nodeId || "node"}-${Date.now()}.html`,
-			buildPageStyledDoc(clone.innerHTML, meta ?? {}, cssText),
-		);
-	});
-	toolbar.appendChild(btn);
-	content.insertBefore(toolbar, content.firstChild);
+	content.appendChild(createTimelineAutoScrollControl(content));
 }
 
 export async function mergeNodeProcess(dagRunId, node) {
@@ -3588,6 +4116,7 @@ function renderExecutorAwareTimeline(content, dagRunId, node) {
 	if (sameNode && cached.kind === "pi-session") {
 		renderSessionTimeline(content, node.nodeId, {
 			executionKey: effectiveExecutionKey(dagRunId, node),
+			attemptCount: node.executionSummary?.totalAttemptCount,
 		});
 		return;
 	}
@@ -3598,6 +4127,7 @@ function renderExecutorAwareTimeline(content, dagRunId, node) {
 	if ((node.executor ?? "pi") === "pi") {
 		renderSessionTimeline(content, node.nodeId, {
 			executionKey: effectiveExecutionKey(dagRunId, node),
+			attemptCount: node.executionSummary?.totalAttemptCount,
 		});
 		return;
 	}
@@ -3619,7 +4149,7 @@ function renderExecutorAwareTimeline(content, dagRunId, node) {
 	});
 }
 
-function fillDagInspectorContent(content, dagRunId, node) {
+function fillDagInspectorContent(content, dagRunId, node, run) {
 	const previousRenderedNode = content.dataset.dagNodeId ?? "";
 	const previousRenderedRun = content.dataset.dagRunId ?? "";
 	const previousTab = content.dataset.inspectorTab ?? "";
@@ -3655,27 +4185,37 @@ function fillDagInspectorContent(content, dagRunId, node) {
 	content.dataset.dagNodeId = String(node.nodeId ?? "");
 	content.dataset.dagRunId = String(dagRunId ?? "");
 	content.dataset.inspectorTab = activeTab;
+	content.dataset.executionKey = inspectorTabExecutionKey(dagRunId, node, activeTab) ?? "";
+	content._readingState = inspectorReadingState(dagRunId, node.nodeId, activeTab, content.dataset.executionKey, isLatestExecutionSelection(dagRunId, node) && ["running", "pending"].includes(String(node.status ?? "").toLowerCase()));
+	uiState.dagTimelineAutoScrollEnabled = content._readingState.followLatest;
+	uiState.dagTimelineViewportState = { ...content._readingState, dagRunId, nodeId: node.nodeId };
 	// Drop timeline-only classes when switching tabs so output layout stays clean.
 	content.className = "dag-inspector-content";
+	if (activeTab !== "prompt-restart") {
+		content.classList.add("is-readable-page");
+	}
 	ensureInspectorContentScrollCapture(
 		content,
 		dagRunId,
 		node.nodeId,
 		activeTab,
 	);
-	if (activeTab === "overview") {
+	if (activeTab === "compare") {
+		void renderAttemptComparison(content, dagRunId, node);
+	} else if (activeTab === "overview") {
 		renderNodeOverview(content, dagRunId, node);
 	} else if (activeTab === "context") {
 		void renderEffectiveContext(content, dagRunId, node);
 	} else if (activeTab === "lineage") {
 		void renderRunLineage(content, dagRunId, node);
 	} else if (activeTab === "spec-evidence") {
+		ensureInspectorPageLead(content, "spec-evidence");
 		void renderSpecEvidence(content, dagRunId, node.nodeId);
 	} else if (activeTab === "prompt-restart") {
-		void renderPromptRestart(content, dagRunId, node);
+		void renderPromptRestart(content, dagRunId, node, run);
 	} else if (activeTab === "timeline") {
-		const attemptBuilt = buildAttemptBar(dagRunId, node);
-		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
+		ensureInspectorPageLead(content, "timeline");
+
 		renderExecutorAwareTimeline(content, dagRunId, node);
 		// Initial content is rendered before it is attached. Restore again on the
 		// connected animation frame so live-follow sees the final scroll height.
@@ -3684,8 +4224,8 @@ function fillDagInspectorContent(content, dagRunId, node) {
 		void renderDagNodeInput(content, dagRunId, node);
 	} else {
 		// output tab: attempt bar + latest preview immediate / historical async body.
-		const attemptBuilt = buildAttemptBar(dagRunId, node);
-		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
+		ensureInspectorPageLead(content, "output");
+
 		const key = effectiveExecutionKey(dagRunId, node);
 		const latest = isLatestExecutionSelection(dagRunId, node);
 		const rendered = renderCachedOrPreviewBody(
@@ -3719,46 +4259,49 @@ function inspectorNodePurpose(node) {
 	return describeDagNodePurpose(node?.nodeId, node);
 }
 
+/** 纯函数：Tab 条两端是否有被裁切内容（驱动渐隐提示）。 */
+export function inspectorTabOverflowState({ scrollLeft = 0, clientWidth = 0, scrollWidth = 0 } = {}) {
+	const maxScroll = Math.max(0, scrollWidth - clientWidth);
+	return {
+		start: scrollLeft > 1 && maxScroll > 0,
+		end: scrollLeft < maxScroll - 1 && maxScroll > 0,
+	};
+}
+
+function syncInspectorTabOverflowClasses(tabs) {
+	if (!tabs?.classList) return;
+	const state = inspectorTabOverflowState({
+		scrollLeft: tabs.scrollLeft ?? 0,
+		clientWidth: tabs.clientWidth ?? 0,
+		scrollWidth: tabs.scrollWidth ?? 0,
+	});
+	tabs.classList.toggle("is-overflow-start", state.start);
+	tabs.classList.toggle("is-overflow-end", state.end);
+}
+
+/** 选中 Tab 保持可见：只滚动 Tab 条自身，不牵动外层页面。 */
+function revealInspectorTab(tabs, button) {
+	if (!tabs || !button) return;
+	const left = button.offsetLeft;
+	const right = left + (button.offsetWidth ?? 0);
+	if (!Number.isFinite(left) || !Number.isFinite(right)) return;
+	if (left < tabs.scrollLeft + 8) tabs.scrollLeft = Math.max(0, left - 8);
+	else if (right > tabs.scrollLeft + tabs.clientWidth - 8) {
+		tabs.scrollLeft = right - tabs.clientWidth + 8;
+	}
+	syncInspectorTabOverflowClasses(tabs);
+}
+
 function appendInspectorPurpose(title, node) {
 	const purpose = inspectorNodePurpose(node);
 	if (!purpose) return;
 	title.appendChild(el("p", "dag-inspector-purpose", purpose));
 }
 
-function buildDagInspectorHeader(dagRunId, node) {
-	const header = el("div", "dag-inspector-header");
-	header.dataset.dagRunId = String(dagRunId ?? "");
-	header.dataset.dagNodeId = String(node.nodeId ?? "");
-	const title = el("div", "dag-inspector-title");
-	title.appendChild(el("h3", null, "节点检查器"));
-	title.appendChild(el("div", "dag-inspector-node", node.nodeId));
-	appendInspectorPurpose(title, node);
-	header.appendChild(title);
-	const controls = el("div", "dag-inspector-controls");
-	const status = badge(node.status ?? "unknown");
-	status.classList.add("dag-inspector-status");
-	controls.appendChild(status);
-	const close = document.createElement("button");
-	close.type = "button";
-	close.className = "dag-inspector-close";
-	close.setAttribute("aria-label", "关闭节点检查器");
-	const closeIcon = el("i", "ri-close-line");
-	closeIcon.setAttribute("aria-hidden", "true");
-	close.appendChild(closeIcon);
-	close.addEventListener("click", closeDagInspector);
-	controls.appendChild(close);
-	header.appendChild(controls);
-
-	const tabDefs = DAG_INSPECTOR_READ_ONLY_TABS.map((definition) => [
-		...definition,
-	]);
-	// Export/rerun mutation surface: the server injects a SCOPED inspect token.
-	// The emergency kill switch suppresses the token;
-	// no token → no tab → the inspector stays strictly read-only.
-	if (globalThis.__INSPECT_MUTATION_TOKEN__) {
-		tabDefs.push([...DAG_INSPECTOR_MUTATION_TAB]);
-	}
+function buildDagInspectorTabs(node) {
+	const tabDefs = inspectorTabDefinitions(node);
 	const tabs = el("div", "dag-inspector-tabs");
+	tabs.dataset.tabsSignature = tabDefs.map(([tab]) => tab).join(",");
 	tabs.setAttribute("role", "tablist");
 	tabs.setAttribute("aria-label", "节点检查器面板");
 	for (const [tab, label, icon] of tabDefs) {
@@ -3781,6 +4324,10 @@ function buildDagInspectorHeader(dagRunId, node) {
 			renderDagInspectorForCurrent();
 			const next = document.getElementById(`dag-inspector-tab-${tab}`);
 			next?.focus();
+			revealInspectorTab(
+				document.querySelector(".dag-inspector-tabs"),
+				next,
+			);
 		});
 		button.addEventListener("keydown", (event) => {
 			if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
@@ -3793,17 +4340,106 @@ function buildDagInspectorHeader(dagRunId, node) {
 			const nextTab = order[(idx + delta + order.length) % order.length];
 			uiState.dagInspectorTab = nextTab;
 			renderDagInspectorForCurrent();
-			document.getElementById(`dag-inspector-tab-${nextTab}`)?.focus();
+			const next = document.getElementById(`dag-inspector-tab-${nextTab}`);
+			next?.focus();
+			revealInspectorTab(document.querySelector(".dag-inspector-tabs"), next);
 		});
 		tabs.appendChild(button);
 	}
+	// 溢出渐隐与选中可见性：挂载后测量（构建时 offsetLeft 不可用）。
+	tabs.addEventListener("scroll", () => syncInspectorTabOverflowClasses(tabs), { passive: true });
+	if (typeof ResizeObserver === "function") {
+		const overflowObserver = new ResizeObserver(() => {
+			syncInspectorTabOverflowClasses(tabs);
+		});
+		overflowObserver.observe(tabs);
+	}
+	if (typeof requestAnimationFrame === "function") {
+		requestAnimationFrame(() => {
+			if (!tabs.isConnected) return;
+			syncInspectorTabOverflowClasses(tabs);
+			const selected = tabs.querySelector("[role='tab'][aria-selected='true']");
+			revealInspectorTab(tabs, selected);
+		});
+	}
+	return tabs;
+}
+
+function buildDagInspectorHeader(dagRunId, node) {
+	const header = el("div", "dag-inspector-header");
+	header.dataset.dagRunId = String(dagRunId ?? "");
+	header.dataset.dagNodeId = String(node.nodeId ?? "");
+	const title = el("div", "dag-inspector-title");
+	title.appendChild(el("h3", null, "节点检查器"));
+	title.appendChild(el("div", "dag-inspector-node", node.nodeId));
+	appendInspectorPurpose(title, node);
+	header.appendChild(title);
+	const controls = el("div", "dag-inspector-controls");
+	const status = badge(node.status ?? "unknown");
+	status.classList.add("dag-inspector-status");
+	controls.appendChild(status);
+	const expand = iconButton(uiState.dagInspectorExpanded ? "还原宽度" : "展开阅读", uiState.dagInspectorExpanded ? "ri-contract-left-right-line" : "ri-expand-left-right-line");
+	expand.type = "button";
+	expand.setAttribute("aria-pressed", String(Boolean(uiState.dagInspectorExpanded)));
+	expand.addEventListener("click", () => {
+		uiState.dagInspectorExpanded = !uiState.dagInspectorExpanded;
+		document.getElementById("dag-inspector")?.classList.toggle("is-expanded", uiState.dagInspectorExpanded);
+		setIconButton(expand, uiState.dagInspectorExpanded ? "还原宽度" : "展开阅读", uiState.dagInspectorExpanded ? "ri-contract-left-right-line" : "ri-expand-left-right-line");
+		expand.setAttribute("aria-pressed", String(uiState.dagInspectorExpanded));
+	});
+	controls.appendChild(expand);
+	const share = iconButton("复制位置", "ri-link");
+	share.type = "button";
+	share.addEventListener("click", async () => {
+		const selection = inspectorSelection;
+		const query = new URLSearchParams({ node: selection.node.nodeId, tab: activeInspectorTab() });
+		const key = effectiveExecutionKey(selection.dagRunId, selection.node);
+		if (key) query.set("attempt", key);
+		const href = inspectPathToCanonicalHref(`/dag/${encodeURIComponent(selection.dagRunId)}?${query}`);
+		const copied = await copyText(new URL(href, location.href).href);
+		setIconButton(share, copied ? "已复制位置" : "复制失败", copied ? "ri-check-line" : "ri-error-warning-line");
+	});
+	controls.appendChild(share);
+	const close = document.createElement("button");
+	close.type = "button";
+	close.className = "dag-inspector-close";
+	close.setAttribute("aria-label", "关闭节点检查器");
+	const closeIcon = el("i", "ri-close-line");
+	closeIcon.setAttribute("aria-hidden", "true");
+	close.appendChild(closeIcon);
+	close.addEventListener("click", closeDagInspector);
+	controls.appendChild(close);
+	header.appendChild(controls);
+
+	const tabs = buildDagInspectorTabs(node);
 	header.appendChild(tabs);
+	const attempt = inspectorTabUsesAttempt(activeInspectorTab(), node) ? buildAttemptBar(dagRunId, node) : null;
+	if (attempt) header.appendChild(attempt.bar);
+	header.dataset.attemptSignature = JSON.stringify([activeInspectorTab(), effectiveExecutionKey(dagRunId, node), node.executionSummary, node.passes]);
 	return header;
 }
 
 function syncDagInspectorHeader(panel, dagRunId, node) {
 	const header = panel.querySelector(".dag-inspector-header");
 	if (!header) return;
+	const tabs = header.querySelector(".dag-inspector-tabs");
+	const tabsSignature = inspectorTabDefinitions(node).map(([tab]) => tab).join(",");
+	if (tabs && tabs.dataset.tabsSignature !== tabsSignature) {
+		const restoreFocus = document.activeElement?.getAttribute("role") === "tab" && tabs.contains(document.activeElement);
+		const nextTabs = buildDagInspectorTabs(node);
+		const scrollLeft = tabs.scrollLeft;
+		tabs.replaceWith(nextTabs);
+		nextTabs.scrollLeft = scrollLeft;
+		syncInspectorTabOverflowClasses(nextTabs);
+		if (restoreFocus) document.getElementById(`dag-inspector-tab-${activeInspectorTab()}`)?.focus();
+	}
+	const attemptSignature = JSON.stringify([activeInspectorTab(), effectiveExecutionKey(dagRunId, node), node.executionSummary, node.passes]);
+	if (header.dataset.dagNodeId !== String(node.nodeId) || header.dataset.attemptSignature !== attemptSignature) {
+		header.querySelector(".dag-inspector-attempt-bar")?.remove();
+		const attempt = inspectorTabUsesAttempt(activeInspectorTab(), node) ? buildAttemptBar(dagRunId, node) : null;
+		if (attempt) header.appendChild(attempt.bar);
+		header.dataset.attemptSignature = attemptSignature;
+	}
 	header.dataset.dagRunId = String(dagRunId ?? "");
 	header.dataset.dagNodeId = String(node.nodeId ?? "");
 	const nodeLabel = header.querySelector(".dag-inspector-node");
@@ -3833,7 +4469,7 @@ function syncDagInspectorHeader(panel, dagRunId, node) {
 
 function dagInspectorSignature(dagRunId, node) {
 	const tab = activeInspectorTab();
-	const execKey = effectiveExecutionKey(dagRunId, node);
+	const execKey = inspectorTabExecutionKey(dagRunId, node, tab);
 	const cachedBody = execKey
 		? getDagNodeExecutionOutputCache(dagRunId, node.nodeId, execKey)
 		: null;
@@ -3870,11 +4506,11 @@ function dagInspectorSignature(dagRunId, node) {
 	// the DOM while selection/history are unchanged; switching attempt or a
 	// changed attempt count rebuilds the selector.
 	const summary = node.executionSummary;
-	const attemptRevision = [
+	const attemptRevision = tab === "compare" ? attemptSelectorOptions(node) : inspectorTabUsesAttempt(tab, node) ? [
 		summary?.totalAttemptCount ?? 0,
 		(node.passes ?? []).join(","),
 		execKey ?? "latest",
-	];
+	] : null;
 	return JSON.stringify([
 		dagRunId,
 		node.nodeId,
@@ -3884,14 +4520,17 @@ function dagInspectorSignature(dagRunId, node) {
 	]);
 }
 
-export function renderDagInspector(dagRunId, node, initial = true) {
+export function renderDagInspector(dagRunId, node, initial = true, run = null) {
 	// Record the current selection before any early-return so tab handlers
 	// (which reference the mutable inspectorSelection slot) always re-render
 	// the currently selected node, never a stale build-time closure.
 	inspectorSelection.dagRunId = dagRunId;
 	inspectorSelection.node = node;
+	inspectorSelection.run = run;
 	const panel = document.getElementById("dag-inspector");
 	if (!panel) return;
+	// 运行状态标记：回到底部按钮由滚动位置自行显隐（终态同样可用），此标记仅供诊断。
+	panel.dataset.runEnded = run && !isDagRunActive(run) ? "1" : "0";
 	captureDagTimelineViewportState(panel);
 	if (!uiState.dagInspectorOpen || !node) {
 		panel.classList.remove("is-open");
@@ -3899,6 +4538,8 @@ export function renderDagInspector(dagRunId, node, initial = true) {
 		return;
 	}
 
+	uiState.dagInspectorTab = activeInspectorTab();
+
 	// Defer tearing down the inspector shell while the user is actively
 	// dragging the resize handle (or the graph) so the pointer-capture target
 	// is not destroyed mid-gesture; the next poll refreshes the content.
@@ -3918,6 +4559,7 @@ export function renderDagInspector(dagRunId, node, initial = true) {
 		if (panel.dataset.contentSignature === nextContentSignature) return;
 		const previousNode = existingContent.dataset.dagNodeId ?? "";
 		const previousRun = existingContent.dataset.dagRunId ?? "";
+		const previousExecutionKey = existingContent.dataset.executionKey;
 		const previousTab =
 			existingContent.dataset.inspectorTab ?? activeInspectorTab();
 		const nodeChanged =
@@ -3939,7 +4581,7 @@ export function renderDagInspector(dagRunId, node, initial = true) {
 			scrollTop: pre.scrollTop,
 		}));
 		clearNode(existingContent);
-		fillDagInspectorContent(existingContent, dagRunId, node);
+		fillDagInspectorContent(existingContent, dagRunId, node, run);
 		// Async tabs restore themselves after fetch; sync tabs restore here.
 		if (activeTab === "output" || activeTab === "timeline") {
 			restoreInspectorContentScroll(
@@ -3949,7 +4591,7 @@ export function renderDagInspector(dagRunId, node, initial = true) {
 				activeTab,
 			);
 		}
-		if (!nodeChanged && previousTab === activeTab) {
+		if (!nodeChanged && previousTab === activeTab && previousExecutionKey === existingContent.dataset.executionKey) {
 			for (const [index, pre] of [
 				...existingContent.querySelectorAll("pre"),
 			].entries()) {
@@ -3966,11 +4608,12 @@ export function renderDagInspector(dagRunId, node, initial = true) {
 	clearNode(panel);
 	panel.classList.add("is-open");
 	panel.setAttribute("aria-hidden", "false");
+	panel.classList.toggle("is-expanded", Boolean(uiState.dagInspectorExpanded));
 	panel.appendChild(createDagInspectorResizeHandle(panel));
 	panel.appendChild(buildDagInspectorHeader(dagRunId, node));
 
 	const content = el("div", "dag-inspector-content");
-	fillDagInspectorContent(content, dagRunId, node);
+	fillDagInspectorContent(content, dagRunId, node, run);
 	panel.appendChild(content);
 	panel.dataset.contentSignature = nextContentSignature;
 }