@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.2

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

@@ -1,8 +1,9 @@
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import { createHash } from "node:crypto";
-import { lstat, readFile, realpath } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
-import { effectiveNodeContextV1Schema, } from "../../shared/context-transfer.js";
+import { redactSecrets, truncateUtf8Preview, redactSensitivePathsWithFindings } from "../../shared/preview.js";
+import { effectiveNodeContextV1Schema, computeContextDigest, } from "../../shared/context-transfer.js";
 import { buildArtifactBindingGraph, } from "../../workflows/dag/artifact-bindings.js";
 import { dagSpecSchema } from "../../workflows/dag/types.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
@@ -133,8 +134,7 @@ export async function loadDagNodeContextSummary(repoRoot, dagRunId, nodeId, atte
         };
     }
     else {
-        const rawReceipt = await readJsonObject(receiptResolved.result.absolutePath);
-        const parsedReceipt = effectiveNodeContextV1Schema.safeParse(rawReceipt);
+        const parsedReceipt = await readValidatedContextReceipt(loaded.facts.runDir, receiptResolved.result.absolutePath);
         if (!parsedReceipt.success ||
             parsedReceipt.data.identity.runId !== dagRunId ||
             parsedReceipt.data.identity.nodeId !== nodeId ||
@@ -160,6 +160,14 @@ export async function loadDagNodeContextSummary(repoRoot, dagRunId, nodeId, atte
                 contextDigest: receipt.contextDigest,
                 capturedAt: receipt.identity.capturedAt,
                 componentCount: receipt.orderedComponents.length,
+                components: receipt.orderedComponents.map((component) => ({
+                    index: component.index, kind: component.kind,
+                    logicalName: redactSensitivePathsWithFindings(redactSecrets(component.logicalName)).redacted,
+                    sourceIdentity: redactSensitivePathsWithFindings(redactSecrets(component.source.identity)).redacted,
+                    inclusion: component.inclusion, bytes: component.bytes, mediaType: component.mediaType,
+                    previewAvailable: Boolean(component.materializedPath && !["reference-only", "omitted"].includes(component.inclusion)),
+                    ...(component.omissionReason ? { omissionReason: redactSecrets(component.omissionReason) } : {}),
+                })),
                 componentKinds,
                 inclusionCounts,
                 truncationCount: receipt.promptAssembly.truncations.length,
@@ -353,11 +361,7 @@ function isTextPreviewMediaType(mediaType) {
         "application/sql",
     ].includes(normalized) || normalized.endsWith("+json") || normalized.endsWith("+xml");
 }
-function isInsideDirectory(root, candidate) {
-    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
-    return candidate.startsWith(normalizedRoot);
-}
-export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, artifactId) {
+async function loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId) {
     if (!isSafeObservabilityIdentifier(nodeId) || !isSafeObservabilityIdentifier(artifactId)) {
         return {
             status: 400,
@@ -410,21 +414,7 @@ export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, art
     if (!resolved.ok)
         return failureForResolution(resolved.reason);
     try {
-        const [runRoot, artifactRealPath, fileStat] = await Promise.all([
-            realpath(resolved.result.runDir),
-            realpath(resolved.result.absolutePath),
-            lstat(resolved.result.absolutePath),
-        ]);
-        if (!isInsideDirectory(runRoot, artifactRealPath) ||
-            !fileStat.isFile() ||
-            fileStat.isSymbolicLink() ||
-            fileStat.nlink !== 1) {
-            return {
-                status: 422,
-                body: { error: "Artifact is not a safe regular file", reason: "unsafe-path" },
-            };
-        }
-        const bytes = await readFile(artifactRealPath);
+        const bytes = await readFileBoundarySafe({ boundaryRoot: resolved.result.runDir, targetPath: resolved.result.absolutePath, label: "recorded artifact" });
         const actualSha256 = createHash("sha256").update(bytes).digest("hex");
         if (actualSha256 !== fact.sha256 ||
             (typeof fact.bytes === "number" && fact.bytes !== bytes.byteLength)) {
@@ -436,57 +426,76 @@ export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, art
                 },
             };
         }
-        if (!isTextPreviewMediaType(artifact.mediaType)) {
-            return {
-                status: 200,
-                body: {
-                    schemaVersion: NODE_TRANSPARENCY_SCHEMA_VERSION,
-                    dagRunId,
-                    nodeId,
-                    producerNodeId: artifact.producerNodeId,
-                    artifactId,
-                    path: artifact.path,
-                    mediaType: artifact.mediaType,
-                    kind: artifact.kind,
-                    sha256: actualSha256,
-                    sourceBytes: bytes.byteLength,
-                    maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES,
-                    previewKind: "unsupported",
-                    content: null,
-                    truncated: false,
-                    redacted: false,
-                },
-            };
-        }
-        const raw = bytes.toString("utf8");
-        const redacted = redactSecrets(raw);
-        const content = truncateUtf8Preview(redacted, DAG_ARTIFACT_PREVIEW_MAX_BYTES);
+        return { status: 200, artifact, bytes, sha256: actualSha256 };
+    }
+    catch (error) {
         return {
-            status: 200,
-            body: {
-                schemaVersion: NODE_TRANSPARENCY_SCHEMA_VERSION,
-                dagRunId,
-                nodeId,
-                producerNodeId: artifact.producerNodeId,
-                artifactId,
-                path: artifact.path,
-                mediaType: artifact.mediaType,
-                kind: artifact.kind,
-                sha256: actualSha256,
-                sourceBytes: bytes.byteLength,
-                maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES,
-                previewKind: "text",
-                content,
-                truncated: content !== redacted,
-                redacted: redacted !== raw,
-            },
+            status: error.code === "ENOENT" ? 404 : 422,
+            body: { error: "Artifact file is unavailable or unsafe", reason: error.code === "ENOENT" ? "not-found" : "unsafe-path" },
         };
     }
+}
+export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, artifactId) {
+    const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
+    if (verified.status !== 200)
+        return verified;
+    const { artifact, bytes, sha256 } = verified;
+    const supported = isTextPreviewMediaType(artifact.mediaType);
+    const raw = supported ? bytes.toString("utf8") : "";
+    const safe = redactSecrets(raw);
+    const content = supported ? truncateUtf8Preview(safe, DAG_ARTIFACT_PREVIEW_MAX_BYTES) : null;
+    return { status: 200, body: { schemaVersion: 1, dagRunId, nodeId, producerNodeId: artifact.producerNodeId, artifactId, path: artifact.path, mediaType: artifact.mediaType, kind: artifact.kind, sha256, sourceBytes: bytes.byteLength, maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES, previewKind: supported ? "text" : "unsupported", content, truncated: supported && content !== safe, redacted: safe !== raw } };
+}
+/** Full text uses the same binding and safety checks as the bounded preview. */
+export async function loadDagNodeArtifactDownload(repoRoot, dagRunId, nodeId, artifactId) {
+    const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
+    if (verified.status !== 200)
+        return verified;
+    if (!isTextPreviewMediaType(verified.artifact.mediaType))
+        return { status: 422, body: { error: "Only text artifacts support redacted download", reason: "unsupported-media" } };
+    return { status: 200, download: { filename: `${artifactId}.redacted.txt`, bytes: Buffer.from(redactSecrets(verified.bytes.toString("utf8")), "utf8") } };
+}
+async function readValidatedContextReceipt(boundaryRoot, targetPath) {
+    try {
+        const bytes = await readFileBoundarySafe({ boundaryRoot, targetPath, label: "recorded context receipt" });
+        const parsed = effectiveNodeContextV1Schema.safeParse(JSON.parse(bytes.toString("utf8")));
+        if (parsed.success) {
+            const { contextDigest, ...context } = parsed.data;
+            if (computeContextDigest(context) === contextDigest)
+                return parsed;
+        }
+    }
+    catch { /* Missing, changed and unsafe receipts are unavailable. */ }
+    return effectiveNodeContextV1Schema.safeParse(null);
+}
+export async function loadDagNodeContextComponent(repoRoot, dagRunId, nodeId, attempt, componentIndex) {
+    if (!isSafeObservabilityIdentifier(nodeId) || !Number.isSafeInteger(attempt) || attempt < 1 || !Number.isSafeInteger(componentIndex) || componentIndex < 0)
+        return { status: 400, body: { error: "Invalid context selection", reason: "invalid-id" } };
+    const loaded = await loadRunFacts(repoRoot, dagRunId);
+    if (!loaded.ok)
+        return loaded.failure;
+    if (!loaded.facts.spec.tasks.some((task) => task.id === nodeId))
+        return { status: 404, body: { error: "DAG node not found", reason: "not-found" } };
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, "context-receipts", `attempt-${attempt}.json`]);
+    if (!resolved.ok)
+        return failureForResolution(resolved.reason);
+    try {
+        const parsed = await readValidatedContextReceipt(loaded.facts.runDir, resolved.result.absolutePath);
+        if (!parsed.success || parsed.data.identity.runId !== dagRunId || parsed.data.identity.nodeId !== nodeId || parsed.data.identity.attempt !== attempt)
+            return { status: 422, body: { error: "Invalid recorded context", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const component = parsed.data.orderedComponents.find((entry) => entry.index === componentIndex);
+        if (!component?.materializedPath || ["reference-only", "omitted"].includes(component.inclusion))
+            return { status: 404, body: { error: "No recorded body for this component", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const bytes = await readFileBoundarySafe({ boundaryRoot: loaded.facts.runDir, targetPath: path.resolve(loaded.facts.runDir, ...component.materializedPath.split("/")), label: "recorded context component" });
+        if (bytes.byteLength !== component.bytes || createHash("sha256").update(bytes).digest("hex") !== component.sha256)
+            return { status: 422, body: { error: "Recorded context component has changed", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const raw = bytes.toString("utf8");
+        const safe = redactSensitivePathsWithFindings(redactSecrets(raw)).redacted;
+        const content = truncateUtf8Preview(safe, DAG_ARTIFACT_PREVIEW_MAX_BYTES);
+        return { status: 200, body: { dagRunId, nodeId, attempt, componentIndex, sourceBytes: bytes.byteLength, content, redacted: safe !== raw, truncated: content !== safe, maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES } };
+    }
     catch {
-        return {
-            status: 404,
-            body: { error: "Artifact file is unavailable", reason: "not-found" },
-        };
+        return { status: 422, body: { error: "Recorded context is unavailable or unsafe", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
     }
 }
 function stringField(value, key) {

package/dist/worker/observe/routes.js

@@ -21,7 +21,7 @@ import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js
 import { buildDagNodeInput } from "./node-input.js";
 import { loadDagNodeExecutionOutput } from "./dag-node-execution-output.js";
 import { loadDagNodeProcess } from "./node-process.js";
-import { loadDagNodeArtifactInventory, loadDagNodeArtifactPreview, loadDagNodeContextSummary, loadDagRunLineage, } from "./node-transparency.js";
+import { loadDagNodeArtifactInventory, loadDagNodeArtifactPreview, loadDagNodeArtifactDownload, loadDagNodeContextComponent, loadDagNodeContextSummary, loadDagRunLineage, } from "./node-transparency.js";
 import { buildObserveHealthV1 } from "./health.js";
 import { buildNightJobDetail, buildNightJobsDoctor, buildNightJobsList, buildNightJobsMorning, } from "./night-jobs.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
@@ -125,6 +125,8 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/artifacts$/,
         handler: handleDagNodeArtifacts,
     },
+    { method: "GET", pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/context\/component$/, handler: handleDagNodeContextComponent },
+    { method: "GET", pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/artifacts\/download$/, handler: handleDagNodeArtifactDownload },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/execution-output$/,
@@ -795,6 +797,23 @@ async function handleDagNodeContext(_req, res, match, ctx) {
     const result = await loadDagNodeContextSummary(ctx.repoRoot, match.params.id, match.params.sub, attempt);
     sendJson(res, result.status, result.body);
 }
+async function handleDagNodeContextComponent(_req, res, match, ctx) {
+    if (!/^[1-9]\d*$/.test(match.query.get("attempt") ?? "") || !/^(0|[1-9]\d*)$/.test(match.query.get("componentIndex") ?? "") || match.query.has("path") || match.query.has("artifactPath")) {
+        sendJson(res, 400, { error: "Select a recorded attempt and component index" });
+        return;
+    }
+    const result = await loadDagNodeContextComponent(ctx.repoRoot, match.params.id, match.params.sub, Number(match.query.get("attempt")), Number(match.query.get("componentIndex")));
+    sendJson(res, result.status, result.body);
+}
+async function handleDagNodeArtifactDownload(_req, res, match, ctx) {
+    const result = await loadDagNodeArtifactDownload(ctx.repoRoot, match.params.id, match.params.sub, match.query.get("artifactId") ?? "");
+    if (result.status !== 200) {
+        sendJson(res, result.status, result.body);
+        return;
+    }
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Content-Disposition": `attachment; filename="${result.download.filename}"`, "Content-Length": result.download.bytes.byteLength, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+    res.end(result.download.bytes);
+}
 async function handleDagNodeArtifacts(_req, res, match, ctx) {
     const result = await loadDagNodeArtifactInventory(ctx.repoRoot, match.params.id, match.params.sub);
     sendJson(res, result.status, result.body);

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

@@ -278,6 +278,9 @@ const COMMON_VALUE_LABELS = Object.freeze({
 	true: "是",
 	false: "否",
 	"system-prompt": "系统说明",
+	"dag-pi-system-prompt": "系统说明",
+	"dag-pi-user-message": "任务消息",
+	"managed-task-contract": "任务约定",
 	"developer-prompt": "开发约束",
 	"user-prompt": "用户要求",
 	"task-contract": "任务约定",

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

@@ -1,5 +1,24 @@
+import { isRowNavigationClick } from "./router.js";
 /** DOM helpers (Observe UI R5). */
 
+/** Compact action with a visible icon and an accessible, focusable tooltip. */
+export function iconButton(label, icon, className = "") {
+	const button = el("button", `observe-icon-button ${className}`.trim());
+	button.type = "button";
+	setIconButton(button, label, icon);
+	return button;
+}
+
+export function setIconButton(button, label, icon) {
+	button.setAttribute("aria-label", label);
+	button.setAttribute("data-tooltip", label);
+	button.setAttribute("title", label);
+	while (button.firstChild) button.removeChild(button.firstChild);
+	const glyph = el("i", icon);
+	glyph.setAttribute("aria-hidden", "true");
+	button.appendChild(glyph);
+}
+
 /**
  * Stable key → node maps, kept per (parent, scope) so reconcileKeyed never
  * depends on dataset support. A WeakMap keyed by parent holds a map of
@@ -205,7 +224,7 @@ export function buildTable(headers, rows) {
 		if (row.className) tr.className = row.className;
 		if (row.onClick) {
 			tr.classList.add("clickable");
-			tr.addEventListener("click", row.onClick);
+			tr.addEventListener("click", (event) => { if (isRowNavigationClick(event)) row.onClick(event); });
 		}
 		for (const cell of row.cells) {
 			const td = document.createElement("td");

package/dist/worker/observe/static/format-pool.d.ts

@@ -69,3 +69,5 @@ export function taskIdentityKey(
 	featureId: string | null | undefined,
 	taskId: string | null | undefined,
 ): string;
+
+export function matchesPoolTaskFilter(task: Record<string, unknown>, filters?: { status?: string; q?: string ;}): boolean;

package/dist/worker/observe/static/format-pool.js

@@ -151,3 +151,9 @@ export function collectPlannerReadyTasks(features) {
 export function taskIdentityKey(featureId, taskId) {
 	return `${featureId ?? ""}\0${taskId ?? ""}`;
 }
+
+export function matchesPoolTaskFilter(task, filters = {}) {
+	if (!matchesPoolStatusFilter(task.status, filters.status)) return false;
+	const query = String(filters.q ?? "").trim().toLocaleLowerCase();
+	return !query || [task.title, task.taskId, task.featureId, task.workerRunId, task.failureCategory, task.recommendedFollowUp].join(" ").toLocaleLowerCase().includes(query);
+}

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

@@ -405,3 +405,10 @@ export function formatLedgerSummary(summary) {
 	}
 	return lines.join("\n");
 }
+
+/** A batch ending does not imply all child tasks passed. */
+export function batchStatusBadge(batch) {
+	const status = String(batch?.status ?? "").toLowerCase();
+	if (["succeeded", "completed"].includes(status)) return el("span", "badge", "已结束");
+	return badge(batch?.status);
+}

package/dist/worker/observe/static/inspect-workspace.js

@@ -1,3 +1,4 @@
+import { inspectRouteStates } from "./state.js";
 /**
  * Hosted Inspect workspace adapter.
  *
@@ -44,6 +45,9 @@ import {
 
 let instance = null;
 let lastInspectHash = "";
+let renderedHash = "";
+let renderedScope = null;
+let routeToken = 0;
 let listenersBound = false;
 
 export function getInspectWorkspaceInstance() {
@@ -129,7 +133,7 @@ function startView(routeValue) {
 	if (routeValue.view === "dashboard") {
 		startDashboardPolling(routeValue.scrollTo);
 	} else if (routeValue.view === "dags") {
-		void startDagsView();
+		return startDagsView();
 	} else if (routeValue.view === "batch") {
 		void renderBatch(routeValue.batchRunId);
 	} else if (routeValue.view === "run") {
@@ -137,9 +141,9 @@ function startView(routeValue) {
 	} else if (routeValue.view === "dag") {
 		startDagPolling(routeValue.dagRunId);
 	} else if (routeValue.view === "failures") {
-		void renderFailures();
+		return renderFailures();
 	} else if (routeValue.view === "pool") {
-		startPoolView();
+		return startPoolView();
 	} else if (routeValue.view === "night") {
 		void renderNightJobs(routeValue.scheduleId);
 	} else if (routeValue.view === "task") {
@@ -150,11 +154,34 @@ function startView(routeValue) {
 }
 
 export function route(hashValue) {
+	const scope = workspaceScope();
+	const scrollRoot = instance?.root ?? document.scrollingElement;
+	const destination = hashValue || (typeof location !== "undefined" ? location.hash : "#/inspect");
+	if (renderedHash && renderedScope === scope) {
+		const previous = parseHashRouteWithFilters(renderedHash);
+		if (["pool", "dags", "failures"].includes(previous.view)) {
+			inspectRouteStates.set(`list:${renderedHash}`, { top: scrollRoot?.scrollTop ?? 0, left: scrollRoot?.scrollLeft ?? 0 });
+			inspectRouteStates.set("return-list", renderedHash);
+		}
+		if (previous.view === "dag" && uiState.currentDagRunId) inspectRouteStates.set(`dag:${uiState.currentDagRunId}`, {
+			nodeId: uiState.selectedDagNodeId, tab: uiState.dagInspectorTab,
+			executionKey: uiState.dagInspectorAttempt?.key ?? null, open: uiState.dagInspectorOpen,
+		});
+	}
+	renderedHash = destination;
+	renderedScope = scope;
+	const token = ++routeToken;
 	stopTimers();
-	const parsed = hashValue
-		? parseHashRouteWithFilters(hashValue)
-		: parseRoute();
-	startView(parsed);
+	const parsed = parseHashRouteWithFilters(destination);
+	const saved = inspectRouteStates.get(`list:${destination}`);
+	Promise.resolve(startView(parsed)).then(() => {
+		if (!saved || token !== routeToken || scope !== workspaceScope()) return;
+		requestAnimationFrame(() => {
+			if (token !== routeToken || scope !== workspaceScope() || !scrollRoot) return;
+			scrollRoot.scrollTop = saved.top;
+			scrollRoot.scrollLeft = saved.left;
+		});
+	});
 }
 
 function resumeView(hashValue) {

package/dist/worker/observe/static/inspector-submission.js

@@ -0,0 +1,32 @@
+/** A retry always replays the exact reviewed payload and idempotency key. */
+export function createInspectorSubmission(action, payload) {
+	return {
+		action,
+		payload: JSON.parse(JSON.stringify(payload)),
+		requestId: `inspect-${action}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+		inFlight: false,
+		operationId: null,
+		rejected: false,
+	};
+}
+
+export async function sendInspectorSubmission(submission, send) {
+	if (submission.pending) return submission.pending;
+	if (submission.operationId) return submission.response;
+	submission.inFlight = true;
+	submission.pending = (async () => {
+		const response = await send(submission.action, submission.payload, submission.requestId);
+		submission.response = response;
+		submission.operationId = response.ok ? response.body?.operationId ?? null : null;
+		// Only a definitive client rejection permits a different payload. Transport
+		// failure and server failure can follow acceptance, so they require replay.
+		submission.rejected = !response.ok && response.status >= 400 && response.status < 500;
+		return response;
+	})();
+	try { return await submission.pending; }
+	finally { submission.inFlight = false; submission.pending = null; }
+}
+
+export function hasUnresolvedSubmission(submission) {
+	return Boolean(submission?.payload && !submission.operationId && !submission.rejected);
+}

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

@@ -21,6 +21,7 @@ export function artifactLink(label, refPath) {
 	const a = el("a", "artifact-link", label);
 	a.href = `/api/artifacts?path=${encodeURIComponent(refPath)}&tail=200`;
 	a.target = "_blank";
+	a.addEventListener("click", (event) => event.stopPropagation());
 	return a;
 }
 

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

@@ -1,3 +1,4 @@
+import { isPlainNavigationClick, isRowNavigationClick } from "./router.js";
 /** Object relation navigation (Observe UI R5). */
 import { el } from "./dom.js";
 import { inspectPathToCanonicalHref, navigate } from "./router.js";
@@ -50,6 +51,7 @@ export function objectRouteLink(kind, id, snapshot, featureId) {
 	const a = el("a", "object-link", id);
 	a.href = inspectPathToCanonicalHref(path);
 	a.addEventListener("click", (e) => {
+		if (!isPlainNavigationClick(e)) return;
 		e.preventDefault();
 		e.stopPropagation();
 		navigate(path);

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

@@ -201,6 +201,11 @@ export function parseHashRouteWithFilters(hashValue) {
 	const raw = String(hashValue ?? "");
 	const withoutQuery = raw.replace(/^#/, "").split("?")[0];
 	const base = parseHashRoute("#" + (withoutQuery || "/"));
+	if (base.view === "dag") {
+		const params = new URLSearchParams(raw.includes("?") ? raw.slice(raw.indexOf("?") + 1) : "");
+		const nodeId = params.get("node");
+		if (nodeId) return { ...base, inspector: { nodeId, tab: params.get("tab") || "output", executionKey: /^(attempt|pass)-[1-9]\d*$/.test(params.get("attempt") || "") ? params.get("attempt") : null } };
+	}
 	if (base.view === "dags") {
 		const history = parseDagHistoryQuery(raw);
 		return { ...base, page: history.page, pageSize: history.pageSize };
@@ -220,3 +225,11 @@ export function buildHashPath(path, filters = {}) {
 	const qs = params.toString();
 	return qs ? `${base}?${qs}` : base;
 }
+
+/** Leave browser-native modified clicks and text selection intact. */
+export function isPlainNavigationClick(event) {
+	return !event.defaultPrevented && (event.button == null || event.button === 0) && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
+}
+export function isRowNavigationClick(event) {
+	return isPlainNavigationClick(event) && !event.target?.closest?.("a, button, input, select, textarea, summary, [role='button']") && !String(globalThis.getSelection?.() ?? "").trim();
+}

package/dist/worker/observe/static/run-processing.js

@@ -1,3 +1,4 @@
+import { isPlainNavigationClick, isRowNavigationClick } from "./router.js";
 /** Run step/command/artifact processing and task history rows. */
 import {
 	STEP_LABELS,
@@ -132,6 +133,7 @@ export function taskRunHistoryRow(run) {
 		);
 		a.textContent = run.workerRunId;
 		a.addEventListener("click", (e) => {
+			if (!isPlainNavigationClick(e)) return;
 			e.preventDefault();
 			navigate(`#/run/${encodeURIComponent(run.workerRunId)}`);
 		});

package/dist/worker/observe/static/shell-chrome.js

@@ -1,6 +1,7 @@
+import { isPlainNavigationClick, isRowNavigationClick } from "./router.js";
 /** Shell chrome: view switching, breadcrumb, header refresh, relation bar. */
 import { UI_TEXT } from "./constants.js";
-import { clearNode, el } from "./dom.js";
+import { clearNode, el, iconButton } from "./dom.js";
 import { formatAgo } from "./format.js";
 import { inspectPathToCanonicalHref, navigate } from "./router.js";
 import { buildObjectRelations, renderObjectRelationBar } from "./relations.js";
@@ -26,12 +27,15 @@ export function setBreadcrumb(parts) {
 			a.href = inspectPathToCanonicalHref(part.href);
 			a.textContent = part.label;
 			a.addEventListener("click", (e) => {
+				if (!isPlainNavigationClick(e)) return;
 				e.preventDefault();
 				navigate(part.href);
 			});
 			nav.appendChild(a);
 		} else {
-			nav.appendChild(document.createTextNode(part.label));
+			// 当前位置包一层 span：窄屏可对末级做 ellipsis 截断。
+			const current = el("span", "breadcrumb-current", part.label);
+			nav.appendChild(current);
 		}
 	});
 }
@@ -43,7 +47,7 @@ export function updateHeaderRefresh(generatedAt, options = {}) {
 		elRefresh.textContent = "";
 		return;
 	}
-	const modeLabel =
+	const modeLabel = options.mode === "ended" ? "已结束 · 按需刷新" : options.mode === "paused" ? "刷新已暂停" :
 		options.mode === "manual"
 			? UI_TEXT.manualRefresh
 			: options.mode === "auto"
@@ -63,3 +67,32 @@ export function mountRelationBar(containerId, ids, snapshot) {
 		elBar.appendChild(el("p", "empty", "关联投影暂时不可用。"));
 	}
 }
+
+export function bindManualViewRefresh(view, refresh) {
+	const heading = document.querySelector(`#view-${view} .view-heading`);
+	if (!heading) return;
+	let button = heading.querySelector(".view-manual-refresh");
+	if (!button) { button = iconButton("刷新本页", "ri-refresh-line", "view-manual-refresh"); button.type = "button"; heading.appendChild(button); }
+	button.onclick = async () => { button.disabled = true; try { await refresh(); } finally { button.disabled = false; } };
+}
+
+export function mountTaskRelationPicker(containerId, ids, tasks, snapshot) {
+	const host = document.getElementById(containerId);
+	if (!host) return;
+	const previous = host.dataset.selectedTask;
+	const taskKey = (task) => JSON.stringify([task.featureId ?? ids.featureId ?? "", task.taskId]);
+	clearNode(host);
+	const select = el("select", "relation-task-picker");
+	select.setAttribute("aria-label", `选择关联任务，共 ${tasks.length} 个`);
+	for (const task of tasks) { const option = el("option", null, `${task.title || task.taskId} · ${task.status ?? "未记录"}`); option.value = taskKey(task); select.appendChild(option); }
+	select.value = tasks.some((task) => taskKey(task) === previous) ? previous : (tasks[0] ? taskKey(tasks[0]) : "");
+	const relations = el("div");
+	const render = () => {
+		host.dataset.selectedTask = select.value;
+		const task = tasks.find((task) => taskKey(task) === select.value) ?? tasks[0];
+		clearNode(relations);
+		relations.appendChild(renderObjectRelationBar(buildObjectRelations({ ...ids, taskId: task?.taskId, featureId: task?.featureId ?? ids.featureId, workerRunId: task?.workerRunId, dagRunId: task?.dagRunId, batchRunId: ids.batchRunId ?? task?.batchRunId }, snapshot), snapshot));
+	};
+	if (tasks.length > 1) { host.appendChild(el("span", "muted", `${tasks.length} 个关联任务 `)); host.appendChild(select); }
+	host.appendChild(relations); select.addEventListener("change", render); render();
+}

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

@@ -173,8 +173,25 @@ export function updateDagTrajectoryViewportState(
 export const dagInspectorViewportStates = new Map();
 
 /** Build a stable inspector scroll region key (AC-005 context isolation). */
-export function inspectorViewportRegionKey(dagRunId, nodeId, tab) {
-	return `dag:${dagRunId ?? ""}:${nodeId ?? ""}:${tab ?? "output"}`;
+export function inspectorViewportRegionKey(dagRunId, nodeId, tab, executionKey = "") {
+	return `dag:${dagRunId ?? ""}:${nodeId ?? ""}:${tab ?? "output"}${executionKey ? `:${executionKey}` : ""}`;
+}
+
+/** Session-only reading/draft state. Never persists prompt text to disk. */
+export const inspectorReadingStates = new Map();
+export const inspectorNodeSelections = new Map();
+export const inspectorDrafts = new Map();
+export const inspectorOperations = new Map();
+export const inspectRouteStates = new Map();
+export const taskHistoryStates = new Map();
+export function inspectorReadingState(dagRunId, nodeId, tab, executionKey, followLatest = false) {
+	const key = inspectorViewportRegionKey(dagRunId, nodeId, tab, executionKey || "latest");
+	if (!inspectorReadingStates.has(key)) inspectorReadingStates.set(key, {
+		key, scrollTop: 0, scrollLeft: 0, followLatest,
+		filter: "all", query: "", errorsOnly: false, showProtocol: false,
+		openDetails: new Set(), seenCount: 0, eventCount: 0,
+	});
+	return inspectorReadingStates.get(key);
 }
 
 export function updateDagInspectorViewportState(
@@ -403,6 +420,7 @@ export function applyWorkspaceScopeSwitch(
 	trace.push("abort-old");
 	// 2. clear old
 	uiState.lastSnapshot = null;
+	for (const cache of [dagInspectorViewportStates, inspectorReadingStates, inspectorNodeSelections, inspectorDrafts, inspectorOperations, inspectRouteStates, taskHistoryStates]) cache.clear();
 	uiState.specEvidenceDetail = null;
 	uiState.specEvidenceListEvidence = null;
 	clearDagNodeExecutionOutputCache();
@@ -531,6 +549,21 @@ export function computeFollowLatest(
 	return height - top - client < Math.max(0, Number(threshold) || 0);
 }
 
+// Chat-style jump-to-bottom visibility: the floating control is only useful
+// when the region can scroll and the viewport is away from the bottom. It
+// applies to every execution-record viewport, running or ended alike.
+export function isScrollRegionAboveBottom(content, overflowPx = 4) {
+	const scrollHeight = Number(content?.scrollHeight ?? 0);
+	const clientHeight = Number(content?.clientHeight ?? 0);
+	if (!Number.isFinite(scrollHeight) || !Number.isFinite(clientHeight)) {
+		return false;
+	}
+	if (scrollHeight - clientHeight <= Math.max(0, Number(overflowPx) || 0)) {
+		return false;
+	}
+	return !computeFollowLatest(content?.scrollTop ?? 0, scrollHeight, clientHeight);
+}
+
 // Generalised viewport-state record keyed by `regionKey`, so the same helper
 // serves the DAG node inspector output ("dag:<runId>:<nodeId>:output") and the
 // Worker run output ("run:<runId>:output").