@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/observe/static/dag-edge-routing.js

@@ -0,0 +1,368 @@
+/**
+ * Deterministic edge routing for Observe DAG logical topology (P1 simple).
+ * Ordinary dependency edges: same stable port-y → explicit straight M...L...;
+ * different port-y → single-segment M...C... cubic. Control-loop edges keep an
+ * independent top-lane rounded-orthogonal path. Pure geometry — no DOM.
+ *
+ * Ordinary ports use a logical-row axis (base nodeHeight / 2 from card top),
+ * not the visual card center, so dynamic history height does not tilt edges.
+ */
+
+const CORNER_RADIUS = 10;
+const CONTROL_LANE_HEIGHT = 36;
+const CONTROL_LANE_TOP = 20;
+const GUTTER_MARGIN = 12;
+/** Port-y equality tolerance for straight ordinary edges (float only; px). */
+const SAME_Y_EPS = 0.5;
+
+/**
+ * Stable ordinary dependency port y for a laid-out node.
+ * Uses baseNodeHeight (logical row axis) when provided; otherwise falls back
+ * to the node's own height (equal-height layouts / direct unit calls).
+ */
+export function dependencyPortY(node, baseNodeHeight) {
+	const base = Number(baseNodeHeight);
+	const axisHeight =
+		Number.isFinite(base) && base > 0 ? base : Number(node?.height) || 0;
+	return (Number(node?.y) || 0) + axisHeight / 2;
+}
+
+/**
+ * Build a smooth cubic SVG path between two ports, or an explicit straight
+ * segment when port-y values match within SAME_Y_EPS.
+ * Control-point x stays strictly inside the rank gutter (source right → target left).
+ */
+export function pointsToSmoothCubicPath(fromPoint, toPoint, options = {}) {
+	if (!fromPoint || !toPoint) return "";
+	const x1 = fromPoint.x;
+	const y1 = fromPoint.y;
+	const x2 = toPoint.x;
+	const y2 = toPoint.y;
+	// AC-001: same port-y → explicit straight M...L...
+	if (Math.abs(y1 - y2) <= SAME_Y_EPS) {
+		return `M ${fmt(x1)} ${fmt(y1)} L ${fmt(x2)} ${fmt(y2)}`;
+	}
+	const spanX = x2 - x1;
+	if (!(spanX > 0)) {
+		// Degenerate / backward: fall back to a straight segment.
+		return `M ${fmt(x1)} ${fmt(y1)} L ${fmt(x2)} ${fmt(y2)}`;
+	}
+	// Keep both control x values inside the open gutter (x1, x2).
+	// channelOffset is intentionally ignored for ordinary P1 edges.
+	void options;
+	const inset = Math.max(GUTTER_MARGIN, spanX / 3);
+	let c1x = x1 + inset;
+	let c2x = x2 - inset;
+	const lo = x1 + 1;
+	const hi = x2 - 1;
+	c1x = clamp(c1x, lo, hi);
+	c2x = clamp(c2x, lo, hi);
+	if (c1x > c2x) {
+		const mid = (c1x + c2x) / 2;
+		c1x = mid;
+		c2x = mid;
+	}
+	return `M ${fmt(x1)} ${fmt(y1)} C ${fmt(c1x)} ${fmt(y1)}, ${fmt(c2x)} ${fmt(y2)}, ${fmt(x2)} ${fmt(y2)}`;
+}
+
+/**
+ * Build a rounded-orthogonal SVG path from structured polyline points.
+ * Used by control-loop edges only under the P1 ordinary-edge rollback.
+ */
+export function pointsToRoundedOrthogonalPath(points = [], radius = CORNER_RADIUS) {
+	if (!Array.isArray(points) || points.length === 0) return "";
+	if (points.length === 1) {
+		const p = points[0];
+		return `M ${fmt(p.x)} ${fmt(p.y)}`;
+	}
+	const cleaned = collapseColinear(points);
+	if (cleaned.length === 1) {
+		return `M ${fmt(cleaned[0].x)} ${fmt(cleaned[0].y)}`;
+	}
+	let d = `M ${fmt(cleaned[0].x)} ${fmt(cleaned[0].y)}`;
+	for (let i = 1; i < cleaned.length; i++) {
+		const prev = cleaned[i - 1];
+		const curr = cleaned[i];
+		const next = cleaned[i + 1];
+		if (!next) {
+			d += ` L ${fmt(curr.x)} ${fmt(curr.y)}`;
+			break;
+		}
+		const dx1 = curr.x - prev.x;
+		const dy1 = curr.y - prev.y;
+		const dx2 = next.x - curr.x;
+		const dy2 = next.y - curr.y;
+		const len1 = Math.hypot(dx1, dy1);
+		const len2 = Math.hypot(dx2, dy2);
+		if (len1 === 0 || len2 === 0) continue;
+		const r = Math.min(radius, len1 / 2, len2 / 2);
+		const x1 = curr.x - (dx1 / len1) * r;
+		const y1 = curr.y - (dy1 / len1) * r;
+		const x2 = curr.x + (dx2 / len2) * r;
+		const y2 = curr.y + (dy2 / len2) * r;
+		d += ` L ${fmt(x1)} ${fmt(y1)} Q ${fmt(curr.x)} ${fmt(curr.y)} ${fmt(x2)} ${fmt(y2)}`;
+	}
+	return d;
+}
+
+/**
+ * Route an ordinary dependency edge with P1 simple geometry.
+ * Stable logical-row ports (baseNodeHeight axis) — no port/channel/bypass hybrid.
+ * Arrow endpoint sits on the target outer left edge.
+ *
+ * - Same port-y: explicit straight M...L... (kind: "line")
+ * - Different port-y: single-segment cubic M...C... (kind: "cubic")
+ * - All forward spans (including long edges) use the same simple path family.
+ * - context.baseNodeHeight: logical row axis; dynamic card height is ignored for ports.
+ * - SAME_Y_EPS stays 0.5 (float equality only; never enlarged to hide true misalign).
+ */
+export function routeDependencyEdge(from, to, context = {}) {
+	const baseNodeHeight = context?.baseNodeHeight;
+	const y1 = dependencyPortY(from, baseNodeHeight);
+	const y2 = dependencyPortY(to, baseNodeHeight);
+	const x1 = from.x + from.width;
+	const x2 = to.x;
+	const start = { x: x1, y: y1 };
+	const end = { x: x2, y: y2 };
+	const sameY = Math.abs(y1 - y2) <= SAME_Y_EPS;
+	const path = pointsToSmoothCubicPath(start, end);
+	return {
+		points: [start, end],
+		path,
+		kind: sameY ? "line" : "cubic",
+	};
+}
+
+/**
+ * Route a control-loop edge on an independent top lane (rounded-orthogonal).
+ * Path leaves the source left edge into its local left gutter, rises into the
+ * lane, travels horizontally above the node canvas, descends in the target
+ * right gutter, and enters the target right edge — never through node rects.
+ */
+export function routeControlEdge(from, to, laneIndex = 0, options = {}) {
+	const laneHeight = options.controlLaneHeight ?? CONTROL_LANE_HEIGHT;
+	const laneTop = options.controlLaneTop ?? CONTROL_LANE_TOP;
+	const laneY = laneTop + laneIndex * laneHeight + laneHeight / 2;
+	const y1 = from.y + from.height / 2;
+	const y2 = to.y + to.height / 2;
+	// Per-lane gutter offsets keep multi-edge paths from fully overlapping.
+	const leftLift = Math.max(28, GUTTER_MARGIN + 8 + laneIndex * 6);
+	const rightLift = Math.max(28, GUTTER_MARGIN + 8 + laneIndex * 6);
+	const xLeave = from.x;
+	const xEnter = to.x + to.width;
+	// Rise only in the source-local left gutter (not across intermediate ranks).
+	const xRise = from.x - leftLift;
+	// Descend only in the target-local right gutter.
+	const xDescend = to.x + to.width + rightLift;
+
+	const points = collapseColinear([
+		{ x: xLeave, y: y1 },
+		{ x: xRise, y: y1 },
+		{ x: xRise, y: laneY },
+		{ x: xDescend, y: laneY },
+		{ x: xDescend, y: y2 },
+		{ x: xEnter, y: y2 },
+	]);
+	// Label anchors on the top horizontal lane segment midpoint (not a corner).
+	const topA = points.find((p, i) => i > 0 && nearlyEqual(p.y, laneY));
+	const topB = [...points]
+		.reverse()
+		.find((p) => nearlyEqual(p.y, laneY));
+	const labelX =
+		topA && topB ? (topA.x + topB.x) / 2 : (from.x + to.x + to.width) / 2;
+	const labelY = laneY - 8;
+	return {
+		points,
+		path: pointsToRoundedOrthogonalPath(points),
+		laneIndex,
+		laneY,
+		labelX,
+		labelY,
+	};
+}
+
+/**
+ * True if any polyline segment intersects a non-endpoint node rectangle.
+ * Endpoint contact at source/target ports is allowed.
+ */
+export function edgeCollidesNonEndpointNodes(points, nodes, fromId, toId) {
+	if (!Array.isArray(points) || points.length < 2) return false;
+	const obstacles = (nodes ?? []).filter(
+		(node) => node.nodeId !== fromId && node.nodeId !== toId,
+	);
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		for (const node of obstacles) {
+			if (segmentIntersectsRect(a, b, nodeRect(node))) return true;
+		}
+	}
+	return false;
+}
+
+export function controlLaneMetrics(laneCount = 0, options = {}) {
+	const count = Math.max(0, Number(laneCount) || 0);
+	const laneHeight = options.controlLaneHeight ?? CONTROL_LANE_HEIGHT;
+	const laneTop = options.controlLaneTop ?? CONTROL_LANE_TOP;
+	const controlLaneHeight = count === 0 ? 0 : laneTop + count * laneHeight;
+	return {
+		controlLaneCount: count,
+		controlLaneHeight,
+		controlLaneOffset: controlLaneHeight,
+		laneHeight,
+		laneTop,
+	};
+}
+
+export function assignControlLanes(controlEdges = [], layoutById = new Map()) {
+	const valid = (controlEdges ?? [])
+		.filter((edge) => layoutById.has(edge.from) && layoutById.has(edge.to))
+		.map((edge) => {
+			const from = layoutById.get(edge.from);
+			const to = layoutById.get(edge.to);
+			const span = Math.abs((from?.x ?? 0) - (to?.x ?? 0));
+			return { edge, span, key: `${edge.from}\0${edge.to}` };
+		});
+	// Stable multi-edge assignment: longer span first, then identity.
+	valid.sort(
+		(a, b) => b.span - a.span || a.key.localeCompare(b.key),
+	);
+	return valid.map((entry, laneIndex) => ({
+		...entry.edge,
+		laneIndex,
+		span: entry.span,
+	}));
+}
+
+function nodeRect(node) {
+	return {
+		x: node.x,
+		y: node.y,
+		width: node.width,
+		height: node.height,
+	};
+}
+
+/** Axis-aligned segment vs rect intersection (closed). Degenerate points ok. */
+function segmentIntersectsRect(a, b, rect) {
+	const minX = rect.x;
+	const maxX = rect.x + rect.width;
+	const minY = rect.y;
+	const maxY = rect.y + rect.height;
+	// Both endpoints strictly inside → collision.
+	if (pointInRect(a, rect) && pointInRect(b, rect)) return true;
+	// Liang–Barsky style against four edges.
+	const edges = [
+		[
+			{ x: minX, y: minY },
+			{ x: maxX, y: minY },
+		],
+		[
+			{ x: maxX, y: minY },
+			{ x: maxX, y: maxY },
+		],
+		[
+			{ x: maxX, y: maxY },
+			{ x: minX, y: maxY },
+		],
+		[
+			{ x: minX, y: maxY },
+			{ x: minX, y: minY },
+		],
+	];
+	// Interior open-segment probe: if midpoint is inside, it crosses the body.
+	const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+	if (pointStrictlyInside(mid, rect)) return true;
+	for (const [c, d] of edges) {
+		if (segmentsIntersect(a, b, c, d)) {
+			// Touching only at a corner/edge that is not interior still counts
+			// as crossing the obstacle boundary when the other point is beyond.
+			if (pointStrictlyInside(a, rect) || pointStrictlyInside(b, rect)) {
+				return true;
+			}
+			// Segment crosses through the rect (not merely grazing a corner
+			// outside the open interior). Check a slight inset sample.
+			const samples = 4;
+			for (let s = 1; s < samples; s++) {
+				const t = s / samples;
+				const p = { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+				if (pointStrictlyInside(p, rect)) return true;
+			}
+		}
+	}
+	return false;
+}
+
+function pointInRect(p, rect) {
+	return (
+		p.x >= rect.x &&
+		p.x <= rect.x + rect.width &&
+		p.y >= rect.y &&
+		p.y <= rect.y + rect.height
+	);
+}
+
+function pointStrictlyInside(p, rect) {
+	const eps = 0.51;
+	return (
+		p.x > rect.x + eps &&
+		p.x < rect.x + rect.width - eps &&
+		p.y > rect.y + eps &&
+		p.y < rect.y + rect.height - eps
+	);
+}
+
+function segmentsIntersect(p1, p2, p3, p4) {
+	const d1 = direction(p3, p4, p1);
+	const d2 = direction(p3, p4, p2);
+	const d3 = direction(p1, p2, p3);
+	const d4 = direction(p1, p2, p4);
+	if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
+		((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
+		return true;
+	}
+	return false;
+}
+
+function direction(a, b, c) {
+	return (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x);
+}
+
+function collapseColinear(points) {
+	if (points.length <= 2) return points.map(clonePoint);
+	const out = [clonePoint(points[0])];
+	for (let i = 1; i < points.length - 1; i++) {
+		const prev = out[out.length - 1];
+		const curr = points[i];
+		const next = points[i + 1];
+		const colinear =
+			(nearlyEqual(prev.x, curr.x) && nearlyEqual(curr.x, next.x)) ||
+			(nearlyEqual(prev.y, curr.y) && nearlyEqual(curr.y, next.y));
+		if (!colinear && !samePoint(prev, curr)) out.push(clonePoint(curr));
+	}
+	const last = points[points.length - 1];
+	if (!samePoint(out[out.length - 1], last)) out.push(clonePoint(last));
+	return out;
+}
+
+function clonePoint(p) {
+	return { x: p.x, y: p.y };
+}
+
+function samePoint(a, b) {
+	return nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
+}
+
+function nearlyEqual(a, b) {
+	return Math.abs(a - b) < 1e-6;
+}
+
+function clamp(value, lo, hi) {
+	return Math.min(Math.max(value, lo), hi);
+}
+
+function fmt(n) {
+	const v = Number(n);
+	if (!Number.isFinite(v)) return "0";
+	return Number.isInteger(v) ? String(v) : v.toFixed(2).replace(/\.?0+$/, "");
+}

package/dist/worker/observe/static/dag-helpers.js

@@ -0,0 +1,161 @@
+/** DAG status helpers, progress, active cards, rank lanes. */
+import { UI_TEXT } from "./constants.js";
+import { el } from "./dom.js";
+import {
+	dagStatusBadge,
+	formatDuration,
+	formatAgo,
+} from "./format.js";
+import { navigate } from "./router.js";
+
+export function isNodeActive(status) {
+	if (!status) return false;
+	const s = status.toLowerCase();
+	return (
+		s === "running" || s === "started" || s === "pending" || s === "queued"
+	);
+}
+
+export function isNodeFinished(status) {
+	if (!status) return false;
+	const s = status.toLowerCase();
+	return (
+		s === "finished" ||
+		s === "completed" ||
+		s === "succeeded" ||
+		s === "done" ||
+		s === "error" ||
+		s === "failed" ||
+		s === "skipped"
+	);
+}
+
+export function isNodeFailed(status) {
+	if (!status) return false;
+	const s = status.toLowerCase();
+	return s === "error" || s === "failed" || s === "partial_failed";
+}
+
+export function dagProgress(dag) {
+	const nodes = dag.nodes ?? [];
+	const finished = nodes.filter((n) => isNodeFinished(n.status)).length;
+	return { finished, total: nodes.length };
+}
+
+export function getActiveNodes(dag) {
+	return (dag.nodes ?? []).filter((n) => isNodeActive(n.status));
+}
+
+export function frontendLintSummary(frontendLint) {
+	if (!frontendLint) return null;
+	const statusLabels = {
+		passed: "passed",
+		"baseline-debt": "baseline-debt",
+		failed: "failed",
+		unavailable: "unavailable",
+	};
+	const status = statusLabels[frontendLint.status] ?? "unavailable";
+	const changed = frontendLint.writerChangedFiles?.length ?? 0;
+	const tolerated = frontendLint.toleratedDiagnosticCount ?? 0;
+	const blocked = frontendLint.blockingDiagnosticCount ?? 0;
+	const reason = (frontendLint.blockingReasons ?? []).join("；");
+	return [
+		status,
+		`修改文件 ${changed}`,
+		`容忍存量诊断 ${tolerated}`,
+		`阻断诊断 ${blocked}`,
+		...(reason ? [`原因：${reason}`] : []),
+	].join(" · ");
+}
+
+	export function dagSortTime(dag) {
+		return dag.startedAt ?? dag.finishedAt ?? "";
+	}
+
+	/** Visual urgency for active DAG cards: attention > running > idle. */
+	export function dagCardUrgency(dag) {
+		const status = (dag?.effectiveStatus ?? "").toLowerCase();
+		const liveness = (dag?.liveness ?? "").toLowerCase();
+		const lifecycle = (dag?.lifecycle ?? "").toLowerCase();
+		if (
+			lifecycle === "paused" ||
+			dag?.stateConsistent === false ||
+			["interrupted", "remote-unknown"].includes(status) ||
+			["stale", "orphaned"].includes(liveness)
+		) {
+			return "attention";
+		}
+		if (isNodeActive(dag?.status) || getActiveNodes(dag).length > 0) {
+			return "running";
+		}
+		return "idle";
+	}
+
+	export function compareActiveDagUrgency(a, b) {
+		const rank = { attention: 0, running: 1, idle: 2 };
+		const diff = (rank[dagCardUrgency(a)] ?? 2) - (rank[dagCardUrgency(b)] ?? 2);
+		if (diff !== 0) return diff;
+		return dagSortTime(b).localeCompare(dagSortTime(a));
+	}
+
+	export function renderActiveDagCard(dag, nowMs) {
+		const card = el("div", "active-dag-card");
+		const urgency = dagCardUrgency(dag);
+		if (urgency === "attention") {
+			card.classList.add("active-dag-card-attention");
+		} else if (urgency === "running") {
+			card.classList.add("active-dag-card-running");
+		}
+		const title = dag.title || dag.dagRunId;
+	const header = el("div", "active-dag-header");
+	header.appendChild(el("span", "active-dag-title", title));
+	header.appendChild(dagStatusBadge(dag.effectiveStatus ?? dag.status));
+	card.appendChild(header);
+
+	const progress = dagProgress(dag);
+	const activeNodes = getActiveNodes(dag);
+	const currentLabel =
+		activeNodes.length > 0
+			? activeNodes
+					.map((n) => {
+						const parts = [n.nodeId];
+						if (n.executor) parts.push(`(${n.executor})`);
+						if (n.model) parts.push(n.model);
+						return parts.join(" ");
+					})
+					.join(", ")
+			: "—";
+
+	const elapsed =
+		dag.durationMs ??
+		(dag.startedAt
+			? Math.max(0, nowMs - Date.parse(dag.startedAt))
+			: undefined);
+	const lastUpdate = dag.finishedAt ?? dag.startedAt;
+
+	const meta = el("div", "active-dag-meta");
+	meta.appendChild(
+		el(
+			"span",
+			null,
+			`进度 ${progress.finished}/${progress.total} · 当前节点：${currentLabel}`,
+		),
+	);
+	meta.appendChild(
+		el(
+			"span",
+			null,
+			`已用时 ${formatDuration(elapsed)} · 最近活动 ${formatAgo(lastUpdate, nowMs)}`,
+		),
+	);
+	card.appendChild(meta);
+
+	const link = el("a", "active-dag-link", UI_TEXT.enterDetail);
+	link.href = `#/dag/${encodeURIComponent(dag.dagRunId)}`;
+	link.addEventListener("click", (e) => {
+		e.preventDefault();
+		navigate(`/dag/${encodeURIComponent(dag.dagRunId)}`);
+	});
+	card.appendChild(link);
+	return card;
+}

package/dist/worker/observe/static/dag-history-labels.js

@@ -0,0 +1,95 @@
+/**
+ * DAG 执行轨迹业务文案映射（Observe UI，2026-08-08-observe-trajectory-business-labels）。
+ *
+ * 纯函数表驱动映射：raw 内部 token（attempt failureCategory / occurrence
+ * semanticVerdict / lane nextReason）仅保留在 title 等诊断属性中，主文案
+ * （textContent 与 aria-label）一律使用中文业务术语。未知或缺失分类
+ * fail-closed 为通用中文，不猜测、不新增授权外映射键（AC-001/AC-002/AC-003）。
+ */
+
+/** 表一：attempt 失败分类 → 中文业务术语（未知/缺失 → 其他失败原因）。 */
+const ATTEMPT_FAILURE_LABELS = {
+	"protocol-invalid": "格式校验失败",
+	unavailable: "服务暂不可用",
+	timeout: "执行超时",
+	"nonzero-exit": "命令执行失败",
+	"invalid-output": "输出格式无效",
+	"empty-output": "输出为空",
+	auth: "认证失败",
+	quota: "额度或限流",
+	"rate-limit": "额度或限流",
+	"context-overflow": "上下文超限",
+	"tool-policy": "工具权限受限",
+	"write-guard": "写入边界阻断",
+};
+
+export const ATTEMPT_FAILURE_UNKNOWN_LABEL = "其他失败原因";
+
+/**
+ * 表一映射：attempt 失败分类 → 中文。未知或缺失分类 fail-closed 为
+ * 「其他失败原因」（AC-001）。
+ */
+export function attemptFailureLabel(category) {
+	if (!category) return ATTEMPT_FAILURE_UNKNOWN_LABEL;
+	return ATTEMPT_FAILURE_LABELS[String(category)] ?? ATTEMPT_FAILURE_UNKNOWN_LABEL;
+}
+
+/** 表二：语义 verdict → 中文业务术语（未知 → 状态待确认；纯中文原样透传）。 */
+const SEMANTIC_VERDICT_LABELS = {
+	"request-revision": "要求修订",
+	pass: "审查通过",
+	"auto-approve": "自动批准",
+	"hard-verify-failed": "验证失败",
+	"review-request-revision": "要求修订，进入下一轮",
+	"review-pass": "审查通过",
+	"hard-verify-pass": "验证通过",
+};
+
+export const SEMANTIC_VERDICT_UNKNOWN_LABEL = "状态待确认";
+
+/** 投影层半中文混合串（hard-verify 失败）归入 hard-verify-failed → 验证失败。 */
+const HARD_VERIFY_MIXED_FAILURE = /^hard-verify\s*失败$/;
+const CJK_RE = /[\u4e00-\u9fff]/;
+
+/**
+ * 表二映射：occurrence 语义 verdict → 中文。投影半中文混合串
+ * 「hard-verify 失败」归入「验证失败」；既有纯中文取值（如「失败」）
+ * 原样透传；未知英文 token fail-closed 为「状态待确认」；空值返回空串
+ * 供调用方守卫（AC-002）。
+ */
+export function semanticVerdictLabel(verdict) {
+	if (!verdict) return "";
+	const key = String(verdict);
+	if (SEMANTIC_VERDICT_LABELS[key]) return SEMANTIC_VERDICT_LABELS[key];
+	if (HARD_VERIFY_MIXED_FAILURE.test(key)) {
+		return SEMANTIC_VERDICT_LABELS["hard-verify-failed"];
+	}
+	// 既有投影产出的纯中文取值原样透传，不做猜测。
+	if (CJK_RE.test(key)) return key;
+	return SEMANTIC_VERDICT_UNKNOWN_LABEL;
+}
+
+/** 表三：lane transition 原因 → 中文业务术语（未知 → 状态待确认）。 */
+const TRANSITION_REASON_LABELS = {
+	"review-request-revision": "要求修订，进入下一轮",
+	"hard-verify-failed": "验证失败，进入下一轮",
+	"review-pass": "审查通过",
+	"hard-verify-pass": "验证通过",
+	// 既有生产 token 的中文文案（repository fallback，非本任务新增授权键）。
+	"non-retry-failure": "不可重试失败",
+	"blocked-boundary": "边界阻断",
+	"no-progress": "无进展",
+	regression: "回归",
+	"max-passes": "达到最大轮次",
+};
+
+export const TRANSITION_REASON_UNKNOWN_LABEL = "状态待确认";
+
+/**
+ * 表三映射：lane 间 transition 原因 → 中文。未知 token fail-closed 为
+ * 「状态待确认」；空值返回空串（无 nextReason 时不渲染箭头，既有守卫）。
+ */
+export function transitionReasonLabel(reason) {
+	if (!reason) return "";
+	return TRANSITION_REASON_LABELS[String(reason)] ?? TRANSITION_REASON_UNKNOWN_LABEL;
+}

package/dist/worker/observe/static/dag-layout.d.ts

@@ -0,0 +1,36 @@
+export type DagLayoutNodeInput = { nodeId: string };
+export type DagLayoutEdgeInput = { from: string; to: string };
+export type DagLayoutNode = {
+	nodeId: string;
+	rank: number;
+	index: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type DagLayoutEdge = DagLayoutEdgeInput & { path: string };
+export type DagLayout = {
+	width: number;
+	height: number;
+	nodes: DagLayoutNode[];
+	edges: DagLayoutEdge[];
+};
+
+export type DagLayoutOptions = Partial<{
+	nodeWidth: number;
+	nodeHeight: number;
+	rankGap: number;
+	nodeGap: number;
+	padding: number;
+	controlLaneCount: number;
+	/** Per-node visual card height overrides; ordinary ports still use nodeHeight axis. */
+	nodeHeights: Record<string, number>;
+}>;
+
+export function layoutDag(
+	nodes?: DagLayoutNodeInput[],
+	edges?: DagLayoutEdgeInput[],
+	ranks?: string[][],
+	options?: DagLayoutOptions,
+): DagLayout;