@tea-agent/loop-agent 0.13.0-alpha.0 → 0.13.0

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

@@ -1,6 +1,165 @@
 /** DOM helpers (Observe UI R5). */
 
-export function clearNode(node) {
+/**
+ * Stable key → node maps, kept per (parent, scope) so reconcileKeyed never
+ * depends on dataset support. A WeakMap keyed by parent holds a map of
+ * scope → Map<key, node>. A stale parent (e.g. after view teardown) releases
+ * its bookkeeping automatically. The default scope "default" is used when a
+ * caller reconciles all keyed children of a parent in a single pass; multiple
+ * reconcilers that share one parent must pass distinct scope strings so they
+ * do not clobber each other's keys.
+ */
+const reconcileMaps = new WeakMap();
+
+/**
+ * Keyed DOM reconciliation: preserve node identity when a stable key recurs
+ * across renders; create a fresh node (with fresh closures) when the key is
+ * new; remove nodes whose key dropped out of the item set.
+ *
+ * Callers drive node construction via `create` and content sync via optional
+ * `update`. The parent is not bulk-cleared, so headings/headers placed outside
+ * this call survive, and scrolling/focus/pointer state on reused nodes is kept.
+ *
+ * @param {Node} parent
+ * @param {Array} items
+ * @param {{ getKey: (item: any, index: number) => string,
+ *           create: (item: any, index: number) => Node,
+ *           update?: (node: any, item: any, index: number) => void,
+ *           scope?: string }} opts
+ * @returns {Array<Node>} the (possibly reused) nodes in item order
+ */
+export function reconcileKeyed(parent, items, opts) {
+	const { getKey, create, update, scope = "default" } = opts;
+	let scopes = reconcileMaps.get(parent);
+	if (!scopes) {
+		scopes = new Map();
+		reconcileMaps.set(parent, scopes);
+	}
+	let map = scopes.get(scope);
+	if (!map) {
+		map = new Map();
+		scopes.set(scope, map);
+	}
+
+	const nextKeys = new Set();
+	const result = [];
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		const key = String(getKey(item, i));
+		nextKeys.add(key);
+		let node = map.get(key);
+		if (node) {
+			if (update) update(node, item, i);
+		} else {
+			node = create(item, i);
+			map.set(key, node);
+			// Sync freshly created nodes so callers can split structure (create) from
+			// content (update) and still populate the first paint.
+			if (update) update(node, item, i);
+		}
+		result.push(node);
+	}
+
+	// Remove nodes whose key is no longer present in THIS scope.
+	for (const [key, node] of map) {
+		if (!nextKeys.has(key)) {
+			parent.removeChild(node);
+			map.delete(key);
+		}
+	}
+
+	const resultSet = new Set(result);
+	const currentOrder = childNodesOf(parent).filter((node) => resultSet.has(node));
+	const orderChanged =
+		currentOrder.length !== result.length ||
+		currentOrder.some((node, index) => node !== result[index]);
+	if (orderChanged) {
+		for (const node of result) parent.appendChild(node);
+	}
+
+	return result;
+}
+
+function childNodesOf(node) {
+	return Array.from(node.childNodes ?? node.children ?? []);
+}
+
+function nodeKind(node) {
+	if (node.nodeType === 3) return "#text";
+	return node.nodeName ?? node.tagName ?? "";
+}
+
+function syncElementAttributes(current, next) {
+	if (current.getAttributeNames && next.getAttributeNames) {
+		const nextNames = new Set(next.getAttributeNames());
+		for (const name of current.getAttributeNames()) {
+			if (!nextNames.has(name)) current.removeAttribute(name);
+		}
+		for (const name of nextNames) {
+			current.setAttribute(name, next.getAttribute(name));
+		}
+	} else if (current.attrs && next.attrs) {
+		for (const name of Object.keys(current.attrs)) {
+			if (!(name in next.attrs)) delete current.attrs[name];
+		}
+		for (const [name, value] of Object.entries(next.attrs)) {
+			current.setAttribute(name, value);
+		}
+	}
+
+	for (const prop of [
+		"className",
+		"href",
+		"title",
+		"target",
+		"type",
+		"value",
+		"hidden",
+		"tabIndex",
+	]) {
+		if (prop in next) current[prop] = next[prop];
+	}
+}
+
+/**
+ * Recursively sync a structurally compatible node without replacing compatible
+ * descendants. Existing event listeners and focusable node identity survive;
+ * incompatible tag/node kinds are reported to the caller for replacement.
+ */
+export function syncCompatibleNode(current, next) {
+	if (!current || !next || nodeKind(current) !== nodeKind(next)) return false;
+	if (current.nodeType === 3 || nodeKind(current) === "#TEXT") {
+		current.textContent = next.textContent;
+		return true;
+	}
+
+	syncElementAttributes(current, next);
+	const currentChildren = childNodesOf(current);
+	const nextChildren = childNodesOf(next);
+	if (nextChildren.length === 0) {
+		current.textContent = next.textContent;
+		return true;
+	}
+
+	for (let index = 0; index < Math.max(currentChildren.length, nextChildren.length); index++) {
+		const currentChild = currentChildren[index];
+		const nextChild = nextChildren[index];
+		if (!nextChild && currentChild) {
+			current.removeChild(currentChild);
+			continue;
+		}
+		if (nextChild && !currentChild) {
+			current.appendChild(nextChild);
+			continue;
+		}
+		if (!syncCompatibleNode(currentChild, nextChild)) {
+			current.replaceChild(nextChild, currentChild);
+		}
+	}
+	return true;
+}
+
+export function clearNode(node) {
 	while (node.firstChild) node.removeChild(node.firstChild);
 }
 

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

@@ -26,6 +26,12 @@ export const uiState = {
 	selectedDagNodeId: null,
 	sessionEventOffset: 0,
 	sessionEvents: [],
+	// Identity token ("<dagRunId>:<nodeId>#<seq>") bumped on every node/DAG
+	// switch. In-flight session-event fetches capture this before await and
+	// reject themselves when it no longer matches, so a stale response for a
+	// previous node can never mutate the current node's event cache.
+	sessionEventIdentity: null,
+	sessionEventIdentitySeq: 0,
 	lastSnapshot: null,
 	dagInspectorOpen: false,
 	dagInspectorTab: "output",
@@ -40,6 +46,12 @@ export const uiState = {
 /** Per-dagRunId graph viewport restore map (stable Map instance). */
 export const dagGraphViewportStates = new Map();
 
+/** Build a fresh session-event identity token and bump the global sequence. */
+export function makeSessionEventIdentity(dagRunId, nodeId) {
+	uiState.sessionEventIdentitySeq += 1;
+	return `${dagRunId}:${nodeId}#${uiState.sessionEventIdentitySeq}`;
+}
+
 export function isPageVisible() {
 	return (
 		typeof document === "undefined" || document.visibilityState !== "hidden"
@@ -188,6 +200,8 @@ export function stopTimers() {
 	uiState.selectedDagNodeId = null;
 	uiState.sessionEventOffset = 0;
 	uiState.sessionEvents = [];
+	uiState.sessionEventIdentity = null;
+	uiState.sessionEventIdentitySeq += 1;
 	uiState.runEventOffset = 0;
 	uiState.runEvents = [];
 }

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

@@ -13,6 +13,7 @@ import { fetchJson } from "../api.js";
 import { badge, parseMarkdownBlocks, markdownLinkHref } from "../format.js";
 import {
 	uiState,
+	makeSessionEventIdentity,
 	updateDagTimelineViewportState,
 	updateDagOutputViewportState,
 	computeFollowLatest,
@@ -23,6 +24,17 @@ import {
 	renderSessionTimeline,
 } from "./session-timeline.js";
 
+// Current inspector selection. Tab handlers reference this mutable slot so a
+// 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 };
+
+function renderDagInspectorForCurrent() {
+	if (!inspectorSelection.dagRunId || !inspectorSelection.node) return;
+	renderDagInspector(inspectorSelection.dagRunId, inspectorSelection.node, false);
+}
+
 export function selectDagNode(dagRunId, nodeId) {
 	const nodeChanged = uiState.selectedDagNodeId !== nodeId;
 	uiState.selectedDagNodeId = nodeId;
@@ -30,6 +42,9 @@ export function selectDagNode(dagRunId, nodeId) {
 	if (nodeChanged) {
 		uiState.sessionEventOffset = 0;
 		uiState.sessionEvents = [];
+		// Bump the session-event identity token so any in-flight response for the
+		// previous node is rejected before it can mutate the current node cache.
+		uiState.sessionEventIdentity = makeSessionEventIdentity(dagRunId, nodeId);
 	}
 	void import("./dag.js").then((m) => m.renderDagDetail(dagRunId, false));
 }
@@ -284,6 +299,7 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 
 	const statusLabels = {
 		"spec-read": "已读取规范",
+		"source-bound": "已绑定任务源",
 		"spec-injected": "仅注入 skill",
 		"search-only": "仅执行检索",
 		"kb-queried": "已观察知识库查询",
@@ -322,6 +338,14 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 		item.append(icon, document.createTextNode(` ${skill}`));
 		return item;
 	});
+	appendListSection("已绑定任务源", evidence.sourceBinding?.sources, (source) => {
+		const item = el("li", null);
+		const icon = el("i", "ri-links-line");
+		icon.setAttribute("aria-hidden", "true");
+		item.append(icon, document.createTextNode(` ${source.kind}: `), el("code", null, source.path), document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`));
+		return item;
+	});
+	appendListSection("显式需求编号", evidence.sourceBinding?.requirementIds, (id) => el("li", null, id));
 	appendListSection(
 		`已读取规范文件（${evidence.specReads?.length ?? 0}）`,
 		evidence.specReads,
@@ -365,14 +389,16 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 		},
 	);
 
-	if (evidence.status === "spec-injected" || evidence.status === "no-evidence") {
+	if (evidence.status === "source-bound" || evidence.status === "spec-injected" || evidence.status === "no-evidence") {
 		const warning = el("div", "spec-evidence-warning");
 		const icon = el("i", "ri-alert-line");
 		icon.setAttribute("aria-hidden", "true");
 		warning.append(
 			icon,
 			document.createTextNode(
-				evidence.status === "no-evidence"
+				evidence.status === "source-bound"
+					? "DAG 已绑定权威任务源及内容哈希，但尚未观察到成功的 read 工具调用；绑定证明上下文来源，read 事件才证明节点读取了完整文件。"
+					: evidence.status === "no-evidence"
 					? "未观察到规范读取。只有 session event 中成功配对的 read 工具调用才算已读取，模型总结或文件名命中不能作为证明。"
 					: "规范 skill 已注入，但未观察到规范读取或知识库查询；grep/find/ls 只能证明检索，不能替代 read。",
 			),
@@ -457,7 +483,7 @@ function buildDagInspectorHeader(dagRunId, node) {
 		button.appendChild(document.createTextNode(` ${label}`));
 		button.addEventListener("click", () => {
 			uiState.dagInspectorTab = tab;
-			renderDagInspector(dagRunId, node, false);
+			renderDagInspectorForCurrent();
 			const next = document.getElementById(`dag-inspector-tab-${tab}`);
 			next?.focus();
 		});
@@ -471,7 +497,7 @@ function buildDagInspectorHeader(dagRunId, node) {
 			const delta = event.key === "ArrowRight" ? 1 : -1;
 			const nextTab = order[(idx + delta + order.length) % order.length];
 			uiState.dagInspectorTab = nextTab;
-			renderDagInspector(dagRunId, node, false);
+			renderDagInspectorForCurrent();
 			document.getElementById(`dag-inspector-tab-${nextTab}`)?.focus();
 		});
 		tabs.appendChild(button);
@@ -512,6 +538,11 @@ function dagInspectorSignature(dagRunId, node) {
 }
 
 export function renderDagInspector(dagRunId, node, initial = true) {
+	// 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;
 	const panel = document.getElementById("dag-inspector");
 	if (!panel) return;
 	captureDagTimelineViewportState(panel);

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

@@ -60,6 +60,7 @@ import {
 	shouldPreserveDiagnosticsOpen,
 	renderViewState,
 	mountViewState,
+	makeSessionEventIdentity,
 } from "../state.js";
 import { uiState, dagGraphViewportStates } from "../state.js";
 import { sortPoolTasks } from "../format-pool.js";
@@ -104,6 +105,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		uiState.selectedDagNodeId = null;
 		uiState.sessionEventOffset = 0;
 		uiState.sessionEvents = [];
+		uiState.sessionEventIdentity = null;
 		uiState.dagInspectorOpen = false;
 		uiState.dagInspectorTab = "output";
 		uiState.dagGraphViewportState = null;
@@ -168,6 +170,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		if (initial) {
 			uiState.sessionEventOffset = 0;
 			uiState.sessionEvents = [];
+			uiState.sessionEventIdentity = null;
 		}
 	}
 
@@ -336,6 +339,12 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	nodesEl.scrollLeft = nodesScrollLeft;
 
 	if (uiState.dagInspectorOpen && uiState.selectedDagNodeId) {
+		if (!uiState.sessionEventIdentity) {
+			uiState.sessionEventIdentity = makeSessionEventIdentity(
+				dagRunId,
+				uiState.selectedDagNodeId,
+			);
+		}
 		await mergeSessionEvents(dagRunId, uiState.selectedDagNodeId);
 	}
 	renderDagInspector(