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

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

@@ -0,0 +1,314 @@
+/** Observe UI view module (R5). */
+import {
+	UI_TEXT,
+	LIVENESS_LABELS,
+	ARTIFACT_LABELS,
+	ARTIFACT_KEYS,
+	STEP_LABELS,
+	STEP_ORDER,
+	DAG_INSPECTOR_DEFAULT_WIDTH,
+	DAG_INSPECTOR_MIN_WIDTH,
+	DAG_INSPECTOR_MAX_WIDTH,
+	DAG_INSPECTOR_RIGHT_OFFSET,
+	DAG_INSPECTOR_VIEWPORT_MARGIN,
+	DAG_INSPECTOR_KEYBOARD_STEP,
+	TERMINAL_RUN_STATUSES,
+	DAG_EFFECTIVE_STATUS_LABELS,
+	STATUS_LABELS,
+} from "../constants.js";
+import { clearNode, el, metaGrid, buildTable } from "../dom.js";
+import {
+	badge,
+	badgeClass,
+	statusLabel,
+	formatTs,
+	formatMs,
+	formatDuration,
+	formatAgo,
+	dagStatusBadge,
+	livenessBadge,
+	displayDurationMs,
+	derivedDurationMs,
+	summaryText,
+	truncateText,
+	repoBaseName,
+	parseMarkdownBlocks,
+	markdownLinkHref,
+} from "../format.js";
+import { parseRoute, navigate, buildHashPath } from "../router.js";
+import {
+	fetchJson,
+	fetchJsonResult,
+	artifactUrl,
+	parseArtifactPreviewResponse,
+} from "../api.js";
+import {
+	objectRouteLink,
+	findFeatureInSnapshot,
+	featureLookupState,
+	buildObjectRelations,
+	renderObjectRelationBar,
+} from "../relations.js";
+import { copyText, renderRecommendedCommand } from "../copy.js";
+import {
+	isPageVisible,
+	detailPollDelay,
+	dashboardPollDelay,
+	captureDagGraphViewportState,
+	updateDagGraphViewportState,
+	updateDagTimelineViewportState,
+	renderViewState,
+	mountViewState,
+} from "../state.js";
+import { uiState } from "../state.js";
+import { sortPoolTasks } from "../format-pool.js";
+import {
+	dagMetaVisibility,
+	isDagRunActive,
+	dashboardVisibleFeatures,
+	findDagForRun,
+} from "../dag-model.js";
+import { layoutDag } from "../dag-layout.js";
+import { showView, setBreadcrumb, updateHeaderRefresh, mountRelationBar } from "../shell-chrome.js";
+import { artifactLink } from "../kpi.js";
+import { findBatchRunIdForTask, taskRunHistoryRow } from "../run-processing.js";
+
+export async function renderTaskDetail(featureId, taskId) {
+	if (taskId === undefined) {
+		taskId = featureId;
+		featureId = undefined;
+	}
+	const taskApi = featureId
+		? `/api/features/${encodeURIComponent(featureId)}/tasks/${encodeURIComponent(taskId)}`
+		: `/api/tasks/${encodeURIComponent(taskId)}`;
+	const displayLabel = featureId ? `${featureId}::${taskId}` : taskId;
+	showView("task");
+	setBreadcrumb([
+		{ label: UI_TEXT.dashboard, href: "#/" },
+		{ label: "资源池", href: "#/pool" },
+		{ label: displayLabel },
+	]);
+
+	const titleEl = document.getElementById("task-title");
+	const metaEl = document.getElementById("task-meta");
+	const linksEl = document.getElementById("task-links");
+	const evidenceEl = document.getElementById("task-evidence");
+	const runsEl = document.getElementById("task-runs");
+	if (!metaEl || !linksEl || !evidenceEl || !runsEl) return false;
+	if (titleEl) titleEl.textContent = displayLabel;
+	mountViewState(metaEl, "loading", "加载 Task…");
+
+	const [taskResult, historyResult, snapshot] = await Promise.all([
+		fetchJsonResult(taskApi),
+		fetchJsonResult(`${taskApi}/runs?limit=20`),
+		fetchJson("/api/snapshot"),
+	]);
+	const task = taskResult.ok ? taskResult.body : null;
+	const history = historyResult.ok ? historyResult.body : null;
+	if (snapshot) {
+		uiState.lastSnapshot = snapshot;
+		updateHeaderRefresh(snapshot.generatedAt);
+	}
+
+	clearNode(metaEl);
+	clearNode(linksEl);
+	clearNode(evidenceEl);
+	clearNode(runsEl);
+
+	if (!task) {
+		if (taskResult.status === 409) {
+			const candidates = Array.isArray(taskResult.body?.candidates)
+				? taskResult.body.candidates
+				: [];
+			mountViewState(
+				metaEl,
+				"error",
+				`Task 身份歧义：${taskId} 同时属于多个 Feature，请选择 Feature 作用域入口。`,
+			);
+			if (candidates.length > 0) {
+				const list = el("div", "artifact-links");
+				for (const c of candidates) {
+					if (!c?.featureId || !c?.taskId) continue;
+					const path = `/feature/${encodeURIComponent(c.featureId)}/task/${encodeURIComponent(c.taskId)}`;
+					const a = el("a", "object-link", `${c.featureId}::${c.taskId}`);
+					a.href = `#${path}`;
+					a.addEventListener("click", (e) => {
+						e.preventDefault();
+						navigate(path);
+					});
+					list.appendChild(a);
+					list.appendChild(document.createTextNode(" "));
+				}
+				metaEl.appendChild(list);
+			}
+		} else {
+			mountViewState(metaEl, "error", `未找到 Task：${taskId}`);
+		}
+		mountRelationBar("task-relations", {}, snapshot);
+		return false;
+	}
+
+	metaEl.appendChild(
+		metaGrid([
+			["Task ID", task.taskId],
+			["状态", badge(task.status)],
+			[
+				"Feature",
+				task.featureId
+					? objectRouteLink("feature", task.featureId, snapshot)
+					: el("span", "muted", "—"),
+			],
+			["更新时间", task.updatedAt ?? task.finishedAt ?? task.startedAt ?? "—"],
+			["最新 worker run", task.workerRunId ?? "—"],
+			["失败分类", task.failureCategory ?? "—"],
+			["建议跟进", task.recommendedFollowUp ?? "—"],
+			[
+				"活性",
+				task.liveness ? (LIVENESS_LABELS[task.liveness] ?? task.liveness) : "—",
+			],
+		]),
+	);
+
+	const batchRunId = findBatchRunIdForTask(snapshot, task);
+	const dag = findDagForRun(snapshot, task.workerRunId, task);
+	mountRelationBar(
+		"task-relations",
+		{
+			featureId: task.featureId,
+			taskId: task.taskId,
+			batchRunId: batchRunId ?? undefined,
+			workerRunId: task.workerRunId,
+			dagRunId: dag?.dagRunId ?? task.dagRunId,
+		},
+		snapshot,
+	);
+	linksEl.appendChild(el("h3", "section-heading", "真实关联"));
+	const linkList = el("div", "artifact-links");
+	linkList.appendChild(objectRouteLink("run", task.workerRunId, snapshot));
+	linkList.appendChild(document.createTextNode(" · "));
+	linkList.appendChild(
+		batchRunId
+			? objectRouteLink("batch", batchRunId, snapshot)
+			: el("span", "muted", "batch 缺失"),
+	);
+	linkList.appendChild(document.createTextNode(" · "));
+	linkList.appendChild(
+		dag
+			? objectRouteLink("dag", dag.dagRunId, snapshot)
+			: task.dagRunId
+				? el("span", "muted", task.dagRunId)
+				: el("span", "muted", "DAG 缺失"),
+	);
+	if (task.featureId) {
+		linkList.appendChild(document.createTextNode(" · "));
+		linkList.appendChild(objectRouteLink("feature", task.featureId, snapshot));
+	}
+	linksEl.appendChild(linkList);
+
+	evidenceEl.appendChild(el("h3", "section-heading", "失败证据"));
+	const r = task.artifactRefs ?? {};
+	const evidenceLinks = el("div", "artifact-links");
+	evidenceLinks.appendChild(artifactLink("报告", r.reportMarkdown));
+	evidenceLinks.appendChild(document.createTextNode(" "));
+	evidenceLinks.appendChild(artifactLink("诊断", r.doctorMarkdown));
+	evidenceLinks.appendChild(document.createTextNode(" "));
+	evidenceLinks.appendChild(artifactLink("收尾方案", r.closeoutDraft));
+	evidenceLinks.appendChild(document.createTextNode(" "));
+	evidenceLinks.appendChild(artifactLink("run 记录", r.runRecordPath));
+	if (
+		!r.reportMarkdown &&
+		!r.doctorMarkdown &&
+		!r.closeoutDraft &&
+		!r.runRecordPath
+	) {
+		evidenceEl.appendChild(el("p", "empty", "暂无 allowlist 内的证据路径。"));
+	} else {
+		evidenceEl.appendChild(evidenceLinks);
+	}
+
+	runsEl.appendChild(el("h3", "section-heading", "运行历史"));
+	const runs = history?.runs ?? [];
+	if (runs.length === 0) {
+		mountViewState(runsEl, "empty", "暂无 ledger 运行记录。");
+	} else {
+		const rows = runs.map(taskRunHistoryRow);
+		runsEl.appendChild(
+			buildTable(
+				["worker run", "状态", "时间", "batch", "retryOf", "失败分类"],
+				rows,
+			),
+		);
+		if (history?.nextBefore) {
+			const more = el("button", "link-button", "加载更早的运行");
+			more.type = "button";
+			more.addEventListener("click", () => {
+				void loadOlderTaskRuns(featureId, taskId, history.nextBefore, runsEl);
+			});
+			runsEl.appendChild(more);
+		}
+	}
+
+	const active = ["running", "pending", "blocked", "stale"].includes(
+		(task.status ?? "").toLowerCase(),
+	);
+	return active;
+}
+
+export async function loadOlderTaskRuns(featureId, taskId, before, runsEl) {
+	if (runsEl === undefined) {
+		runsEl = before;
+		before = taskId;
+		taskId = featureId;
+		featureId = undefined;
+	}
+	const taskApi = featureId
+		? `/api/features/${encodeURIComponent(featureId)}/tasks/${encodeURIComponent(taskId)}`
+		: `/api/tasks/${encodeURIComponent(taskId)}`;
+	const page = await fetchJson(
+		`${taskApi}/runs?limit=20&before=${encodeURIComponent(before)}`,
+	);
+	if (!page?.runs?.length) return;
+	const table = runsEl.querySelector("table");
+	if (!table) return;
+	const tbody = table.querySelector("tbody") || table;
+	for (const run of page.runs) {
+		const tr = document.createElement("tr");
+		for (const cell of taskRunHistoryRow(run).cells) {
+			const td = document.createElement("td");
+			if (cell instanceof Node) td.appendChild(cell);
+			else td.textContent = cell;
+			tr.appendChild(td);
+		}
+		tbody.appendChild(tr);
+	}
+	const btn = runsEl.querySelector("button.link-button");
+	if (btn) {
+		if (page.nextBefore) {
+			btn.onclick = () => {
+				void loadOlderTaskRuns(featureId, taskId, page.nextBefore, runsEl);
+			};
+		} else {
+			btn.remove();
+		}
+	}
+}
+
+export function startTaskPolling(featureId, taskId) {
+	if (taskId === undefined) {
+		taskId = featureId;
+		featureId = undefined;
+	}
+	if (uiState.taskPollTimer) clearTimeout(uiState.taskPollTimer);
+	const generation = ++uiState.pollingGeneration;
+	const poll = async () => {
+		const active = await renderTaskDetail(featureId, taskId);
+		if (generation !== uiState.pollingGeneration || !active) return;
+		const delay = detailPollDelay("running", isPageVisible());
+		if (delay == null) return;
+		uiState.taskPollTimer = setTimeout(() => {
+			uiState.taskPollTimer = null;
+			void poll();
+		}, delay);
+	};
+	void poll();
+}

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

@@ -0,0 +1,163 @@
+/** Observe UI view module (R5). */
+import {
+	UI_TEXT,
+	LIVENESS_LABELS,
+	ARTIFACT_LABELS,
+	ARTIFACT_KEYS,
+	STEP_LABELS,
+	STEP_ORDER,
+	DAG_INSPECTOR_DEFAULT_WIDTH,
+	DAG_INSPECTOR_MIN_WIDTH,
+	DAG_INSPECTOR_MAX_WIDTH,
+	DAG_INSPECTOR_RIGHT_OFFSET,
+	DAG_INSPECTOR_VIEWPORT_MARGIN,
+	DAG_INSPECTOR_KEYBOARD_STEP,
+	TERMINAL_RUN_STATUSES,
+	DAG_EFFECTIVE_STATUS_LABELS,
+	STATUS_LABELS,
+} from "../constants.js";
+import { clearNode, el, metaGrid, buildTable } from "../dom.js";
+import {
+	badge,
+	badgeClass,
+	statusLabel,
+	formatTs,
+	formatMs,
+	formatDuration,
+	formatAgo,
+	dagStatusBadge,
+	livenessBadge,
+	displayDurationMs,
+	derivedDurationMs,
+	summaryText,
+	truncateText,
+	repoBaseName,
+	parseMarkdownBlocks,
+	markdownLinkHref,
+} from "../format.js";
+import { parseRoute, navigate, buildHashPath } from "../router.js";
+import {
+	fetchJson,
+	artifactUrl,
+	parseArtifactPreviewResponse,
+} from "../api.js";
+import {
+	objectRouteLink,
+	findFeatureInSnapshot,
+	featureLookupState,
+	buildObjectRelations,
+	renderObjectRelationBar,
+} from "../relations.js";
+import { copyText, renderRecommendedCommand } from "../copy.js";
+import {
+	isPageVisible,
+	detailPollDelay,
+	dashboardPollDelay,
+	captureDagGraphViewportState,
+	updateDagGraphViewportState,
+	updateDagTimelineViewportState,
+	renderViewState,
+	mountViewState,
+} from "../state.js";
+import { uiState } from "../state.js";
+import { sortPoolTasks } from "../format-pool.js";
+import {
+	dagMetaVisibility,
+	isDagRunActive,
+	dashboardVisibleFeatures,
+	findDagForRun,
+} from "../dag-model.js";
+import { layoutDag } from "../dag-layout.js";
+
+export async function mountBoundedEventTimeline(container, apiBase, title) {
+	clearNode(container);
+	container.appendChild(el("h3", "section-heading", title));
+	const note = el(
+		"p",
+		"process-timeline-note",
+		"有界历史（默认 50 / 最大 200）；分页使用 cursor，与 SSE 行号 offset 分离。",
+	);
+	container.appendChild(note);
+	const scroll = el("div", "process-timeline-scroll event-history-scroll");
+	const listHost = el("div", "event-history-list");
+	scroll.appendChild(listHost);
+	container.appendChild(scroll);
+	const footer = el("div", "event-history-footer");
+	container.appendChild(footer);
+
+	let nextCursor = null;
+	let loading = false;
+	const accumulated = [];
+
+	const renderList = () => {
+		clearNode(listHost);
+		if (accumulated.length === 0) {
+			mountViewState(listHost, "empty", "暂无事件");
+			return;
+		}
+		const ul = el("ul", "process-timeline");
+		for (let index = 0; index < accumulated.length; index += 1) {
+			const event = accumulated[index];
+			const li = el(
+				"li",
+				`process-timeline-item process-timeline-event has-time${index === 0 ? " is-first" : ""}${index === accumulated.length - 1 ? " is-last" : ""}`,
+			);
+			const rail = el("span", "process-timeline-rail");
+			rail.appendChild(el("span", "process-timeline-dot"));
+			li.appendChild(rail);
+			li.appendChild(
+				el("span", "process-timeline-time", formatTs(event.at) || "—"),
+			);
+			const label = `${event.type ?? "event"}${event.taskId ? ` · ${event.taskId}` : ""}${event.workerRunId ? ` · ${event.workerRunId}` : ""}`;
+			li.appendChild(el("span", "process-timeline-label", label));
+			ul.appendChild(li);
+		}
+		listHost.appendChild(ul);
+	};
+
+	const loadPage = async (cursor) => {
+		if (loading) return;
+		loading = true;
+		if (accumulated.length === 0) {
+			mountViewState(listHost, "loading", "加载事件…");
+		}
+		const qs = new URLSearchParams();
+		qs.set("limit", "50");
+		if (cursor) qs.set("cursor", cursor);
+		const page = await fetchJson(`${apiBase}?${qs.toString()}`);
+		loading = false;
+		if (!page) {
+			mountViewState(listHost, "error", "无法加载事件历史。");
+			return;
+		}
+		const events = page.events ?? [];
+		for (const event of events) accumulated.push(event);
+		nextCursor = page.nextCursor ?? null;
+		renderList();
+		clearNode(footer);
+		if (page.corruptLineCount > 0) {
+			footer.appendChild(
+				renderViewState(
+					"degraded",
+					`跳过损坏行 ${page.corruptLineCount} 条（failure-safe）。`,
+				),
+			);
+		}
+		if (nextCursor) {
+			const btn = el(
+				"button",
+				"btn-secondary event-history-more",
+				"加载更早事件",
+			);
+			btn.type = "button";
+			btn.addEventListener("click", () => {
+				void loadPage(nextCursor);
+			});
+			footer.appendChild(btn);
+		} else if (accumulated.length > 0) {
+			footer.appendChild(el("p", "muted", "已到历史边界"));
+		}
+	};
+
+	await loadPage(null);
+}

package/dist/worker/pool/doctor.js

@@ -0,0 +1,165 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { findRunByWorkerRunId, getEventsJsonlPath, listLegacyStateFiles, listTaskPoolStates, pathExists, readJsonlFile, sha256File, } from "./run-store.js";
+import { TASK_POOL_STATE_ERROR_CODES, } from "./types.js";
+/**
+ * Read-only inventory of legacy flat states and feature-scoped v2 states.
+ */
+export async function diagnoseTaskPoolStates(repoRoot, options = {}) {
+    const findings = [];
+    const legacyFiles = await listLegacyStateFiles(repoRoot);
+    const legacy = [];
+    for (const file of legacyFiles) {
+        const sha256 = await sha256File(file.path);
+        let state;
+        try {
+            state = JSON.parse(await readFile(file.path, "utf-8"));
+        }
+        catch {
+            legacy.push({
+                taskId: file.taskId,
+                legacyPath: file.path,
+                sha256,
+                resolution: "unresolved",
+                code: TASK_POOL_STATE_ERROR_CODES.MIGRATION_REQUIRED,
+                detail: "legacy state file is corrupt",
+            });
+            findings.push({
+                code: TASK_POOL_STATE_ERROR_CODES.MIGRATION_REQUIRED,
+                message: `corrupt legacy state: ${file.taskId}`,
+            });
+            continue;
+        }
+        const resolved = await resolveLegacyIdentity(repoRoot, state, options.mapping);
+        legacy.push({
+            taskId: file.taskId,
+            legacyPath: file.path,
+            sha256,
+            status: state.status,
+            ...resolved,
+        });
+        if (resolved.resolution === "unresolved" || resolved.resolution === "ambiguous") {
+            findings.push({
+                code: resolved.code ?? TASK_POOL_STATE_ERROR_CODES.MIGRATION_REQUIRED,
+                message: resolved.detail ??
+                    `legacy state requires migration: ${file.taskId}`,
+            });
+        }
+        else {
+            findings.push({
+                code: TASK_POOL_STATE_ERROR_CODES.MIGRATION_REQUIRED,
+                message: `legacy state ${file.taskId} maps to ${resolved.featureId}/${file.taskId} via ${resolved.resolution}`,
+            });
+        }
+    }
+    const v2States = await listTaskPoolStates(repoRoot);
+    const v2 = v2States.map((state) => ({
+        featureId: state.featureId,
+        taskId: state.taskId,
+        status: state.status,
+    }));
+    return {
+        schemaVersion: 1,
+        repoRoot,
+        legacyCount: legacy.length,
+        v2Count: v2.length,
+        legacy,
+        v2,
+        findings,
+    };
+}
+export async function resolveLegacyIdentity(repoRoot, state, mapping) {
+    const candidates = [];
+    if (state.workerRunId) {
+        const run = await findRunByWorkerRunId(repoRoot, state.workerRunId);
+        if (run && run.taskId === state.taskId) {
+            return {
+                resolution: "workerRunId",
+                featureId: run.featureId,
+            };
+        }
+    }
+    if (state.retryOfWorkerRunId) {
+        const run = await findRunByWorkerRunId(repoRoot, state.retryOfWorkerRunId);
+        if (run && run.taskId === state.taskId) {
+            return {
+                resolution: "retryOfWorkerRunId",
+                featureId: run.featureId,
+            };
+        }
+    }
+    const events = await readJsonlFile(getEventsJsonlPath(repoRoot));
+    const followUpHits = events.filter((event) => event.type === "follow-up-approved" &&
+        event.proposedTaskId === state.taskId);
+    const uniqueFeatureIds = [...new Set(followUpHits.map((event) => event.featureId))];
+    if (uniqueFeatureIds.length === 1) {
+        return {
+            resolution: "follow-up-approved",
+            featureId: uniqueFeatureIds[0],
+        };
+    }
+    if (uniqueFeatureIds.length > 1) {
+        for (const featureId of uniqueFeatureIds) {
+            candidates.push({ featureId, taskId: state.taskId });
+        }
+        return {
+            resolution: "ambiguous",
+            candidates,
+            code: TASK_POOL_STATE_ERROR_CODES.IDENTITY_AMBIGUOUS,
+            detail: `multiple follow-up-approved features for ${state.taskId}`,
+        };
+    }
+    const mapped = mapping?.[state.taskId];
+    if (mapped) {
+        return {
+            resolution: "operator-mapping",
+            featureId: mapped,
+        };
+    }
+    return {
+        resolution: "unresolved",
+        code: TASK_POOL_STATE_ERROR_CODES.MIGRATION_REQUIRED,
+        detail: `no unique identity evidence for legacy state ${state.taskId}`,
+    };
+}
+export async function loadOperatorMapping(mappingPath) {
+    if (!mappingPath)
+        return undefined;
+    if (!(await pathExists(mappingPath))) {
+        throw new Error(`mapping file not found: ${mappingPath}`);
+    }
+    const raw = JSON.parse(await readFile(mappingPath, "utf-8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("mapping file must be a JSON object of taskId -> featureId");
+    }
+    const mapping = {};
+    for (const [taskId, featureId] of Object.entries(raw)) {
+        if (typeof featureId !== "string" || featureId.length === 0) {
+            throw new Error(`mapping for ${taskId} must be a non-empty featureId string`);
+        }
+        mapping[taskId] = featureId;
+    }
+    return mapping;
+}
+export function formatDoctorHuman(report) {
+    const lines = [
+        `Task Pool doctor`,
+        `repo: ${report.repoRoot}`,
+        `legacy states: ${report.legacyCount}`,
+        `v2 states: ${report.v2Count}`,
+    ];
+    for (const item of report.legacy) {
+        const target = item.featureId != null ? `${item.featureId}/${item.taskId}` : "(unresolved)";
+        lines.push(`- legacy ${item.taskId}: ${item.resolution} -> ${target}${item.detail ? ` (${item.detail})` : ""}`);
+    }
+    for (const finding of report.findings) {
+        lines.push(`[${finding.code}] ${finding.message}`);
+    }
+    if (report.findings.length === 0) {
+        lines.push("No migration-required findings.");
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function relativeLegacyName(legacyPath) {
+    return path.basename(legacyPath);
+}