@tea-agent/loop-agent 0.26.1 → 0.26.2

package/dist/worker/observability/read-model.js

@@ -1287,6 +1287,12 @@ function mergeDagRun(existing, incoming) {
         ...(ranks && ranks.length > 0 ? { ranks } : {}),
         nodes: mergeDagNodes(existing.nodes, incoming.nodes),
         edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
+        ...((incoming.controlEdges ?? existing.controlEdges)
+            ? { controlEdges: incoming.controlEdges ?? existing.controlEdges }
+            : {}),
+        ...((incoming.convergence ?? existing.convergence)
+            ? { convergence: incoming.convergence ?? existing.convergence }
+            : {}),
         ...((incoming.dagPath ?? existing.dagPath)
             ? { dagPath: incoming.dagPath ?? existing.dagPath }
             : {}),
@@ -1321,6 +1327,10 @@ function mergeDagNode(existing, incoming) {
         finishedAt: incoming.finishedAt ?? existing.finishedAt,
         outputPreview: incoming.outputPreview ?? existing.outputPreview,
         errorPreview: incoming.errorPreview ?? existing.errorPreview,
+        attemptCount: incoming.attemptCount ?? existing.attemptCount,
+        failureCategory: incoming.failureCategory ?? existing.failureCategory,
+        originKind: incoming.originKind ?? existing.originKind,
+        passes: incoming.passes ?? existing.passes,
     };
 }
 function computeDurationMs(startedAt, finishedAt) {
@@ -1569,6 +1579,9 @@ async function parseDagStateFile(statePath, now) {
         const nodes = parseDagNodes(parsed, rankByNode, modelByNode);
         const edges = await parseDagEdges(runSpecPath, nodes);
         const state = parsed;
+        const controlEdges = await deriveControlLoopEdges(runSpecPath, nodes, state);
+        const convergence = projectConvergenceSummary(state);
+        applyNodePasses(nodes, state);
         const liveness = assessDagRunLiveness({ state, now });
         const effectiveStatus = lifecycle
             ? deriveDagRunEffectiveStatus({
@@ -1647,6 +1660,8 @@ async function parseDagStateFile(statePath, now) {
             ...(ranks.length > 0 ? { ranks } : {}),
             nodes,
             edges,
+            ...(controlEdges.length > 0 ? { controlEdges } : {}),
+            ...(convergence ? { convergence } : {}),
             dagPath: runDir,
             ...(continuation ? { continuation } : {}),
             ...(backendTest ? { backendTest } : {}),
@@ -1683,6 +1698,125 @@ async function parseDagEdges(runPath, nodes) {
     }
     return [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
 }
+/**
+ * Derive presentation-only control-loop edges from the run spec's convergence
+ * chain. When the chain contains both `review-gate-shell` and `repair-pi`, the
+ * bounded repair-reverify-review loop exists at runtime and Observe renders it
+ * as a dashed feedback loop. The derived edge is never merged into `edges` or
+ * `ranks`, so DAG topological layout stays acyclic.
+ */
+async function deriveControlLoopEdges(runPath, nodes, state) {
+    const runtimeConvergence = state.convergence;
+    if (!runtimeConvergence?.enabled ||
+        runtimeConvergence.terminalReason === "feature-flag-off" ||
+        runtimeConvergence.terminalReason === "unsupported-dag-shape") {
+        return [];
+    }
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const convergence = readObject(parsed, "convergence");
+    if (!convergence)
+        return [];
+    const chainNodeIds = readStringArray(convergence, "chainNodeIds");
+    if (chainNodeIds.length === 0)
+        return [];
+    if (!chainNodeIds.includes("review-gate-shell") ||
+        !chainNodeIds.includes("repair-pi")) {
+        return [];
+    }
+    const known = new Set(nodes.map((node) => node.nodeId));
+    if (!known.has("review-gate-shell") || !known.has("repair-pi")) {
+        return [];
+    }
+    return [{ from: "review-gate-shell", to: "repair-pi", kind: "control-loop" }];
+}
+/**
+ * Project `state.convergence` into the slim Observe summary. Keeps the budget
+ * envelope even when passHistory is empty.
+ */
+function projectConvergenceSummary(state) {
+    const convergence = state.convergence;
+    if (!convergence)
+        return undefined;
+    return {
+        enabled: convergence.enabled,
+        maxPasses: convergence.maxPasses,
+        currentPass: convergence.currentPass,
+        ...(convergence.terminalReason
+            ? { terminalReason: convergence.terminalReason }
+            : {}),
+        passHistory: convergence.passHistory.map((pass) => ({
+            pass: pass.pass,
+            ...(pass.reason ? { reason: pass.reason } : {}),
+            ...(pass.status ? { status: pass.status } : {}),
+            ...(pass.hardVerifyStatus
+                ? { hardVerifyStatus: pass.hardVerifyStatus }
+                : {}),
+            ...(pass.reviewVerdict ? { reviewVerdict: pass.reviewVerdict } : {}),
+            ...(pass.reviewGateStatus
+                ? { reviewGateStatus: pass.reviewGateStatus }
+                : {}),
+        })),
+    };
+}
+/**
+ * Record convergence participation from archived pass artifacts plus the live
+ * current pass. The controller archives only retry/terminal failures, so an
+ * active pass or a successful final pass must be derived from current node
+ * state to avoid dropping its pass marker from Observe.
+ */
+function applyNodePasses(nodes, state) {
+    const passesByNode = new Map();
+    const addPass = (nodeId, pass) => {
+        const passes = passesByNode.get(nodeId) ?? new Set();
+        passes.add(pass);
+        passesByNode.set(nodeId, passes);
+    };
+    for (const pass of state.convergence?.passHistory ?? []) {
+        for (const ref of pass.artifactRefs)
+            addPass(ref.nodeId, pass.pass);
+    }
+    const initialPassNodeIds = new Set([
+        "initial-review-pi",
+        "initial-review-gate-shell",
+        "initial-review-pass-shell",
+    ]);
+    for (const node of nodes) {
+        if (!initialPassNodeIds.has(node.nodeId))
+            continue;
+        const status = (node.status ?? "").toUpperCase();
+        if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+            addPass(node.nodeId, 1);
+        }
+    }
+    const currentPass = state.convergence?.currentPass;
+    if (currentPass && currentPass > 0) {
+        const convergenceNodeIds = new Set([
+            "process-supervisor-pi",
+            "process-gate-shell",
+            "repair-pi",
+            "hard-verify-shell",
+            "review-pi",
+            "review-verdict-recovery-pi",
+            "review-gate-shell",
+        ]);
+        for (const node of nodes) {
+            if (!convergenceNodeIds.has(node.nodeId))
+                continue;
+            const status = (node.status ?? "").toUpperCase();
+            if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+                addPass(node.nodeId, currentPass);
+            }
+        }
+    }
+    for (const node of nodes) {
+        const passes = passesByNode.get(node.nodeId);
+        if (passes && passes.size > 0) {
+            node.passes = [...passes].sort((left, right) => left - right);
+        }
+    }
+}
 function buildRankIndex(ranks) {
     const index = new Map();
     for (let i = 0; i < ranks.length; i++) {

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

@@ -53,6 +53,8 @@ export const uiState = {
 	dagTimelineViewportState: null,
 	dagNodeOutputViewportState: null,
 	dagNodeInputViewportState: null,
+	/** Spec-evidence inspector content scroll (single active region snapshot). */
+	dagNodeSpecEvidenceViewportState: null,
 	runOutputViewportState: null,
 	/**
 	 * Spec-evidence file preview drill-down. null = list view; otherwise
@@ -67,6 +69,65 @@ export const uiState = {
 /** Per-dagRunId graph viewport restore map (stable Map instance). */
 export const dagGraphViewportStates = new Map();
 
+/**
+ * Per-context inspector content scroll map.
+ * Key format: dag:<dagRunId>:<nodeId>:<tab>
+ */
+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 updateDagInspectorViewportState(
+	_previous,
+	regionKey,
+	scrollLeft,
+	scrollTop,
+) {
+	return {
+		regionKey,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+	};
+}
+
+/**
+ * Persist inspector scroll for a context. When `preserveIntent` is true and the
+ * incoming position is a zero clamp on short (loading) content while a non-zero
+ * intent already exists, keep the previous intent instead of overwriting to 0.
+ */
+export function saveDagInspectorViewportState(
+	regionKey,
+	scrollLeft,
+	scrollTop,
+	options = {},
+) {
+	if (!regionKey) return null;
+	const left = Math.max(0, Number(scrollLeft) || 0);
+	const top = Math.max(0, Number(scrollTop) || 0);
+	if (options.preserveIntent) {
+		const existing = dagInspectorViewportStates.get(regionKey);
+		if (
+			existing &&
+			left === 0 &&
+			top === 0 &&
+			(existing.scrollLeft > 0 || existing.scrollTop > 0)
+		) {
+			return existing;
+		}
+	}
+	const next = updateDagInspectorViewportState(null, regionKey, left, top);
+	dagInspectorViewportStates.set(regionKey, next);
+	return next;
+}
+
+export function getDagInspectorViewportState(regionKey) {
+	if (!regionKey) return null;
+	return dagInspectorViewportStates.get(regionKey) ?? null;
+}
+
 /** Build a fresh session-event identity token and bump the global sequence. */
 export function makeSessionEventIdentity(dagRunId, nodeId) {
 	uiState.sessionEventIdentitySeq += 1;

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

@@ -1522,6 +1522,14 @@ body.is-resizing-dag-graph {
 #dag-arrow path {
 	fill: color-mix(in srgb, var(--hairline-strong) 80%, var(--muted));
 }
+.dag-edge-control {
+	stroke: var(--orange);
+	stroke-width: 2;
+	stroke-dasharray: 6 4;
+}
+#dag-arrow-control path {
+	fill: var(--orange);
+}
 .dag-graph-node {
 	cursor: pointer;
 	transition: opacity var(--transition-fast);

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

@@ -26,30 +26,52 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 	const edges = dag.edges ?? [];
 	const layout = layoutDag(nodes, edges, dag.ranks ?? []);
 	const wrap = existingWrap ?? el("div", "dag-graph-wrap");
+	// Preserve .dag-graph-viewport DOM identity across poll refreshes so the
+	// user's active scroll/pointer target is not destroyed mid-gesture.
+	let viewport =
+		existingWrap?.querySelector?.(":scope > .dag-graph-viewport") ??
+		existingWrap?.querySelector?.(".dag-graph-viewport") ??
+		null;
 	if (existingWrap) {
-		// reuse-dag-graph-wrap: replace children while keeping wrap identity.
-		while (wrap.firstChild) wrap.removeChild(wrap.firstChild);
+		// Remove only non-interactive siblings. Keeping the viewport connected is
+		// important: detaching and re-inserting the same node still cancels a native
+		// scrollbar drag/pointer target even though object identity is unchanged.
+		for (const child of [...wrap.children]) {
+			if (child !== viewport) wrap.removeChild(child);
+		}
+		if (viewport) {
+			while (viewport.firstChild) viewport.removeChild(viewport.firstChild);
+		}
 	}
 	const toolbar = el("div", "dag-graph-toolbar");
-	toolbar.appendChild(
-		el(
-			"span",
-			"dag-graph-summary",
-			`${nodes.length} 节点 · ${layout.edges.length} 条依赖`,
-		),
-	);
+	let summaryText = `${nodes.length} 节点 · ${layout.edges.length} 条依赖`;
+	const convergence = dag.convergence;
+	if (convergence?.enabled) {
+		summaryText += ` · pass ${convergence.currentPass}/${convergence.maxPasses}`;
+		if (convergence.terminalReason) {
+			summaryText += ` · ${convergence.terminalReason}`;
+		}
+	}
+	toolbar.appendChild(el("span", "dag-graph-summary", summaryText));
 	const reset = el("button", "dag-graph-reset", "重置视图");
 	toolbar.appendChild(reset);
-	wrap.appendChild(toolbar);
-	if (edges.length === 0)
-		wrap.appendChild(
+	const appendBeforeViewport = (child) => {
+		if (viewport?.parentNode === wrap) wrap.insertBefore(child, viewport);
+		else wrap.appendChild(child);
+	};
+	appendBeforeViewport(toolbar);
+	if (edges.length === 0) {
+		appendBeforeViewport(
 			el(
 				"p",
 				"dag-graph-fallback",
 				"该运行没有可用依赖数据；图按并行层级展示，节点表格仍保留完整数据。",
 			),
 		);
-	const viewport = el("div", "dag-graph-viewport");
+	}
+	if (!viewport) {
+		viewport = el("div", "dag-graph-viewport");
+	}
 	viewport.dataset.dagRunId = dagRunId;
 	const svg = svgEl("svg", {
 		class: "dag-graph",
@@ -71,6 +93,17 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 	});
 	marker.appendChild(svgEl("path", { d: "M 0 0 L 10 5 L 0 10 z" }));
 	defs.appendChild(marker);
+	const controlMarker = svgEl("marker", {
+		id: "dag-arrow-control",
+		viewBox: "0 0 10 10",
+		refX: 9,
+		refY: 5,
+		markerWidth: 7,
+		markerHeight: 7,
+		orient: "auto-start-reverse",
+	});
+	controlMarker.appendChild(svgEl("path", { d: "M 0 0 L 10 5 L 0 10 z" }));
+	defs.appendChild(controlMarker);
 	svg.appendChild(defs);
 	const related = new Set([uiState.selectedDagNodeId]);
 	for (const edge of layout.edges)
@@ -91,6 +124,28 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 		path.firstChild.textContent = `${edge.from} → ${edge.to}`;
 		svg.appendChild(path);
 	}
+	// 控制回环：仅由 read model 派生（dag.controlEdges），不进 layout、不参与拓扑。
+	// 路径从 review-gate-shell 左侧绕回 repair-pi 右侧，避开节点矩形。
+	const layoutByNode = new Map(layout.nodes.map((n) => [n.nodeId, n]));
+	for (const ctrl of dag.controlEdges ?? []) {
+		const from = layoutByNode.get(ctrl.from);
+		const to = layoutByNode.get(ctrl.to);
+		if (!from || !to) continue;
+		const x1 = from.x;
+		const y1 = from.y + from.height / 2;
+		const x2 = to.x + to.width;
+		const y2 = to.y + to.height / 2;
+		const lift = Math.max(48, (from.x - to.x) / 2);
+		const rise = Math.max(40, Math.abs(from.y - to.y) / 2 + 16);
+		const path = svgEl("path", {
+			d: `M ${x1} ${y1} C ${x1 - lift} ${y1 - rise}, ${x2 + lift} ${y2 - rise}, ${x2} ${y2}`,
+			class: "dag-edge dag-edge-control",
+			"marker-end": "url(#dag-arrow-control)",
+		});
+		path.appendChild(svgEl("title"));
+		path.firstChild.textContent = `${ctrl.from} → ${ctrl.to} (control loop)`;
+		svg.appendChild(path);
+	}
 	const byId = Object.fromEntries(nodes.map((node) => [node.nodeId, node]));
 	for (const position of layout.nodes) {
 		const node = byId[position.nodeId] ?? { nodeId: position.nodeId };
@@ -115,7 +170,14 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 		executor.textContent = `◈ ${node.executor ?? "unknown"}`;
 		group.appendChild(executor);
 		const state = svgEl("text", { x: 14, y: 74, class: "dag-node-status" });
-		state.textContent = `${statusSymbol(status)} ${statusLabel(node.status)} · ${formatMs(node.durationMs)}`;
+		let stateText = `${statusSymbol(status)} ${statusLabel(node.status)} · ${formatMs(node.durationMs)}`;
+		if (node.passes?.length) {
+			stateText += ` · P${node.passes.join(",")}`;
+		}
+		if (node.attemptCount > 0) {
+			stateText += ` · attempt ${node.attemptCount}`;
+		}
+		state.textContent = stateText;
 		group.appendChild(state);
 		const activate = () => selectDagNode(dagRunId, node.nodeId);
 		group.addEventListener("click", activate);
@@ -128,36 +190,45 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 		svg.appendChild(group);
 	}
 	viewport.appendChild(svg);
-	wrap.appendChild(viewport);
+	if (viewport.parentNode !== wrap) wrap.appendChild(viewport);
 	const graphViewportState =
 		dagGraphViewportStates.get(dagRunId) ??
 		(uiState.dagGraphViewportState?.dagRunId === dagRunId
 			? uiState.dagGraphViewportState
 			: null);
-	viewport.addEventListener(
-		"scroll",
-		() => {
-			uiState.dagGraphViewportState = updateDagGraphViewportState(
-				uiState.dagGraphViewportState,
-				dagRunId,
-				viewport.scrollLeft,
-				viewport.scrollTop,
-			);
-			dagGraphViewportStates.set(dagRunId, uiState.dagGraphViewportState);
-		},
-		{ passive: true },
-	);
+	// Bind scroll capture once per viewport instance so reuse does not stack listeners.
+	if (viewport.dataset.scrollBound !== "1") {
+		viewport.dataset.scrollBound = "1";
+		viewport.addEventListener(
+			"scroll",
+			() => {
+				const id = viewport.dataset.dagRunId;
+				if (!id) return;
+				uiState.dagGraphViewportState = updateDagGraphViewportState(
+					uiState.dagGraphViewportState,
+					id,
+					viewport.scrollLeft,
+					viewport.scrollTop,
+				);
+				dagGraphViewportStates.set(id, uiState.dagGraphViewportState);
+			},
+			{ passive: true },
+		);
+	}
 	if (graphViewportState) {
 		const restoreViewport = () => {
+			if (viewport.dataset.dagRunId !== dagRunId) return;
 			viewport.scrollLeft = graphViewportState.scrollLeft;
 			viewport.scrollTop = graphViewportState.scrollTop;
 		};
+		// Apply immediately so identity reuse keeps position even before paint,
+		// then again on rAF after SVG layout settles.
+		restoreViewport();
 		if (typeof requestAnimationFrame === "function") {
 			requestAnimationFrame(restoreViewport);
-		} else {
-			restoreViewport();
 		}
 	}
+	// Toolbar is rebuilt each paint; bind reset to the current viewport/dagRunId.
 	reset.addEventListener("click", () => {
 		uiState.dagGraphViewportState = updateDagGraphViewportState(
 			uiState.dagGraphViewportState,
@@ -166,7 +237,12 @@ export function renderDagGraph(dag, dagRunId, existingWrap = null) {
 			0,
 		);
 		dagGraphViewportStates.set(dagRunId, uiState.dagGraphViewportState);
-		viewport.scrollTo({ left: 0, top: 0, behavior: "smooth" });
+		if (typeof viewport.scrollTo === "function") {
+			viewport.scrollTo({ left: 0, top: 0, behavior: "smooth" });
+		} else {
+			viewport.scrollLeft = 0;
+			viewport.scrollTop = 0;
+		}
 	});
 	return wrap;
 }