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

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

@@ -141,7 +141,9 @@ export async function renderBatch(batchRunId) {
 		const snap = snapshot ?? uiState.lastSnapshot;
 		const rows = tasks.map((task) => {
 			const links = el("div", "artifact-links batch-task-links");
-			links.appendChild(objectRouteLink("task", task.taskId, snap));
+			links.appendChild(
+				objectRouteLink("task", task.taskId, snap, task.featureId ?? batch.featureId),
+			);
 			links.appendChild(document.createTextNode(" · "));
 			links.appendChild(objectRouteLink("run", task.workerRunId, snap));
 			if (task.dagRunId) {
@@ -223,4 +225,3 @@ export async function renderBatch(batchRunId) {
 		);
 	}
 }
-

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

@@ -9,6 +9,7 @@ import {
 	UI_TEXT,
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
+import { fetchJson } from "../api.js";
 import { badge, parseMarkdownBlocks, markdownLinkHref } from "../format.js";
 import {
 	uiState,
@@ -17,7 +18,10 @@ import {
 	computeFollowLatest,
 	isInteractiveGestureActive,
 } from "../state.js";
-import { renderSessionTimeline } from "./session-timeline.js";
+import {
+	formatSessionEventTime,
+	renderSessionTimeline,
+} from "./session-timeline.js";
 
 export function selectDagNode(dagRunId, nodeId) {
 	const nodeChanged = uiState.selectedDagNodeId !== nodeId;
@@ -268,14 +272,128 @@ export function renderMarkdown(content) {
 	return article;
 }
 
+async function renderSpecEvidence(content, dagRunId, nodeId) {
+	const evidence = await fetchJson(
+		`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence`,
+	);
+	if (!content.isConnected || content.dataset.dagNodeId !== String(nodeId)) return;
+	if (!evidence) {
+		content.appendChild(el("p", "empty", "无法加载规范证据。"));
+		return;
+	}
+
+	const statusLabels = {
+		"spec-read": "已读取规范",
+		"spec-injected": "仅注入 skill",
+		"search-only": "仅执行检索",
+		"kb-queried": "已观察知识库查询",
+		"no-evidence": "未观察到读取",
+	};
+	const statusSection = el("div", "spec-evidence-section");
+	statusSection.appendChild(el("h4", null, "证据状态"));
+	statusSection.appendChild(
+		el(
+			"span",
+			`badge badge-${evidence.status === "spec-read" ? "succeeded" : evidence.status === "no-evidence" ? "failed" : "pending"}`,
+			statusLabels[evidence.status] ?? evidence.status,
+		),
+	);
+	if (evidence.summary) {
+		statusSection.appendChild(
+			el("p", "spec-evidence-summary", evidence.summary),
+		);
+	}
+	content.appendChild(statusSection);
+
+	const appendListSection = (title, entries, renderEntry) => {
+		if (!entries?.length) return;
+		const section = el("div", "spec-evidence-section");
+		section.appendChild(el("h4", null, title));
+		const list = el("ul", "spec-evidence-list");
+		for (const entry of entries) list.appendChild(renderEntry(entry));
+		section.appendChild(list);
+		content.appendChild(section);
+	};
+
+	appendListSection("注入的 Skill", evidence.skillInjection?.skills, (skill) => {
+		const item = el("li", null);
+		const icon = el("i", "ri-bookmark-line");
+		icon.setAttribute("aria-hidden", "true");
+		item.append(icon, document.createTextNode(` ${skill}`));
+		return item;
+	});
+	appendListSection(
+		`已读取规范文件（${evidence.specReads?.length ?? 0}）`,
+		evidence.specReads,
+		(read) => {
+			const item = el("li", null);
+			const icon = el("i", "ri-file-text-line");
+			icon.setAttribute("aria-hidden", "true");
+			item.append(icon, el("code", null, read.path));
+			if (read.timestamp) {
+				item.appendChild(
+					el(
+						"span",
+						"spec-evidence-time",
+						formatSessionEventTime({ timestamp: read.timestamp }),
+					),
+				);
+			}
+			return item;
+		},
+	);
+	appendListSection(
+		`检索操作（${evidence.specSearches?.length ?? 0}）`,
+		evidence.specSearches,
+		(search) => {
+			const item = el("li", null);
+			const icon = el("i", "ri-search-line");
+			icon.setAttribute("aria-hidden", "true");
+			item.append(icon, document.createTextNode(` ${search.tool}: ${search.query}`));
+			return item;
+		},
+	);
+	appendListSection(
+		`知识库查询（${evidence.knowledgeBaseQueries?.length ?? 0}）`,
+		evidence.knowledgeBaseQueries,
+		(query) => {
+			const item = el("li", null);
+			const icon = el("i", "ri-database-2-line");
+			icon.setAttribute("aria-hidden", "true");
+			item.append(icon, document.createTextNode(` ${query.connector}`));
+			return item;
+		},
+	);
+
+	if (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"
+					? "未观察到规范读取。只有 session event 中成功配对的 read 工具调用才算已读取，模型总结或文件名命中不能作为证明。"
+					: "规范 skill 已注入，但未观察到规范读取或知识库查询；grep/find/ls 只能证明检索，不能替代 read。",
+			),
+		);
+		content.appendChild(warning);
+	}
+}
+
 function fillDagInspectorContent(content, dagRunId, node) {
-	const activeTab =
-		uiState.dagInspectorTab === "timeline" ? "timeline" : "output";
+	const activeTab = ["timeline", "spec-evidence"].includes(
+		uiState.dagInspectorTab,
+	)
+		? uiState.dagInspectorTab
+		: "output";
 	content.id = `dag-inspector-panel-${activeTab}`;
 	content.setAttribute("role", "tabpanel");
 	content.setAttribute("aria-labelledby", `dag-inspector-tab-${activeTab}`);
 	content.dataset.dagNodeId = String(node.nodeId ?? "");
-	if (activeTab === "timeline") {
+	if (activeTab === "spec-evidence") {
+		void renderSpecEvidence(content, dagRunId, node.nodeId);
+	} else if (activeTab === "timeline") {
 		renderSessionTimeline(content, node.nodeId);
 	} else if (!node.outputPreview && !node.errorPreview) {
 		content.appendChild(el("p", "empty", UI_TEXT.noOutput));
@@ -317,6 +435,7 @@ function buildDagInspectorHeader(dagRunId, node) {
 	const tabDefs = [
 		["output", "节点输出", "ri-file-text-line"],
 		["timeline", "执行过程", "ri-route-line"],
+		["spec-evidence", "规范证据", "ri-book-open-line"],
 	];
 	const tabs = el("div", "dag-inspector-tabs");
 	tabs.setAttribute("role", "tablist");

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

@@ -112,11 +112,14 @@ export async function renderDashboard(scrollTo) {
 						feature.featureId,
 						snapshot,
 					);
-					const nextHint =
-						feature.nextAction?.label ??
-						(feature.nextAction?.command
-							? truncateText(feature.nextAction.command, 48)
-							: "—");
+					// Prefer planner-selected next task; never re-rank ready pool order here.
+					const selected = feature.planning?.selected?.[0];
+					const nextHint = selected
+						? `Next Task: ${selected.taskId} (${selected.priority})`
+						: feature.nextAction?.label ??
+							(feature.nextAction?.command
+								? truncateText(feature.nextAction.command, 48)
+								: "—");
 					return {
 						onClick: feature.featureId
 							? () =>

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

@@ -234,7 +234,9 @@ export async function renderFeatureDetail(featureId) {
 					const meta = el("div", "blocking-meta");
 					if (item.taskId) {
 						meta.appendChild(document.createTextNode("Task "));
-						meta.appendChild(objectRouteLink("task", item.taskId, snapshot));
+						meta.appendChild(
+							objectRouteLink("task", item.taskId, snapshot, feature.featureId),
+						);
 					}
 					if (item.failureCategory) {
 						meta.appendChild(
@@ -277,6 +279,34 @@ export async function renderFeatureDetail(featureId) {
 
 	if (actionsEl) {
 		try {
+			const planning = feature.planning;
+			if (planning) {
+				actionsEl.appendChild(el("h3", "section-heading", "Ready 选择计划（只读）"));
+				const selected = planning.selected ?? [];
+				const deferred = planning.deferred ?? [];
+				const blocked = planning.blocked ?? [];
+				// Render planner facts in projection order; do not re-sort selected/deferred.
+				actionsEl.appendChild(buildTable(
+					["已选择", "延后", "阻塞"],
+					[{
+						cells: [
+							selected.map((task) => `${task.taskId} (${task.priority})`).join(", ") || "无",
+							deferred.map((task) => {
+								const ahead = Array.isArray(task.selectedAhead) && task.selectedAhead.length
+									? ` ahead=${task.selectedAhead.join("|")}`
+									: "";
+								return `${task.taskId}: ${task.reasonCode || "selection-limit"}${ahead}`;
+							}).join(", ") || "无",
+							blocked.map((task) => {
+								const by = Array.isArray(task.blockedBy) && task.blockedBy.length
+									? ` by ${task.blockedBy.join(",")}`
+									: "";
+								return `${task.taskId}: ${task.reasonCode || task.reason || "blocked"}${by}`;
+							}).join(", ") || "无",
+						],
+					}],
+				));
+			}
 			actionsEl.appendChild(
 				el("h3", "section-heading", "建议命令（derived/advisory · 仅可复制）"),
 			);
@@ -339,10 +369,14 @@ export async function renderFeatureDetail(featureId) {
 						["Task", "类型", "状态", "pool 关联"],
 						tasks.map((t) => {
 							const pool = (snapshot?.tasks ?? []).find(
-								(p) => p.taskId === t.taskId,
+								(p) =>
+									p.taskId === t.taskId &&
+									(!feature.featureId || p.featureId === feature.featureId),
 							);
 							const links = el("div", "artifact-links");
-							links.appendChild(objectRouteLink("task", t.taskId, snapshot));
+							links.appendChild(
+								objectRouteLink("task", t.taskId, snapshot, feature.featureId),
+							);
 							if (pool?.workerRunId) {
 								links.appendChild(document.createTextNode(" · "));
 								links.appendChild(
@@ -381,7 +415,12 @@ export async function renderFeatureDetail(featureId) {
 							cells: [
 								f.followUpId,
 								f.proposedTaskId ?? "—",
-								objectRouteLink("task", f.parentTaskId, snapshot),
+								objectRouteLink(
+									"task",
+									f.parentTaskId,
+									snapshot,
+									feature.featureId,
+								),
 								artifactLink("draft", f.draftPath),
 							],
 						})),

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

@@ -285,11 +285,14 @@ export async function renderPool() {
 	if (tasks.length > 0) {
 		const rows = tasks.map((task) => {
 			const taskLink = document.createElement("a");
-			taskLink.href = `#/task/${encodeURIComponent(task.taskId)}`;
+			const taskPath = task.featureId
+				? `/feature/${encodeURIComponent(task.featureId)}/task/${encodeURIComponent(task.taskId)}`
+				: `/task/${encodeURIComponent(task.taskId)}`;
+			taskLink.href = `#${taskPath}`;
 			taskLink.textContent = task.taskId;
 			taskLink.addEventListener("click", (e) => {
 				e.preventDefault();
-				navigate(`#/task/${encodeURIComponent(task.taskId)}`);
+				navigate(taskPath);
 			});
 
 			let runCell = "—";

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

@@ -229,7 +229,7 @@ export function renderRunPanels(task, events, snapshot) {
 	metaEl.appendChild(
 		metaGrid([
 			["Worker 运行 ID", task.workerRunId ?? "—"],
-			["Task", objectRouteLink("task", task.taskId, snapshot)],
+			["Task", objectRouteLink("task", task.taskId, snapshot, task.featureId)],
 			[
 				"Feature",
 				task.featureId

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

@@ -36,7 +36,12 @@ import {
 	markdownLinkHref,
 } from "../format.js";
 import { parseRoute, navigate, buildHashPath } from "../router.js";
-import { fetchJson, artifactUrl, parseArtifactPreviewResponse } from "../api.js";
+import {
+	fetchJson,
+	fetchJsonResult,
+	artifactUrl,
+	parseArtifactPreviewResponse,
+} from "../api.js";
 import {
 	objectRouteLink,
 	findFeatureInSnapshot,
@@ -68,12 +73,20 @@ import { showView, setBreadcrumb, updateHeaderRefresh, mountRelationBar } from "
 import { artifactLink } from "../kpi.js";
 import { findBatchRunIdForTask, taskRunHistoryRow } from "../run-processing.js";
 
-export async function renderTaskDetail(taskId) {
+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: taskId },
+		{ label: displayLabel },
 	]);
 
 	const titleEl = document.getElementById("task-title");
@@ -82,14 +95,16 @@ export async function renderTaskDetail(taskId) {
 	const evidenceEl = document.getElementById("task-evidence");
 	const runsEl = document.getElementById("task-runs");
 	if (!metaEl || !linksEl || !evidenceEl || !runsEl) return false;
-	if (titleEl) titleEl.textContent = taskId;
+	if (titleEl) titleEl.textContent = displayLabel;
 	mountViewState(metaEl, "loading", "加载 Task…");
 
-	const [task, history, snapshot] = await Promise.all([
-		fetchJson(`/api/tasks/${encodeURIComponent(taskId)}`),
-		fetchJson(`/api/tasks/${encodeURIComponent(taskId)}/runs?limit=20`),
+	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);
@@ -101,7 +116,34 @@ export async function renderTaskDetail(taskId) {
 	clearNode(runsEl);
 
 	if (!task) {
-		mountViewState(metaEl, "error", `未找到 Task：${taskId}`);
+		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;
 	}
@@ -200,7 +242,7 @@ export async function renderTaskDetail(taskId) {
 			const more = el("button", "link-button", "加载更早的运行");
 			more.type = "button";
 			more.addEventListener("click", () => {
-				void loadOlderTaskRuns(taskId, history.nextBefore, runsEl);
+				void loadOlderTaskRuns(featureId, taskId, history.nextBefore, runsEl);
 			});
 			runsEl.appendChild(more);
 		}
@@ -212,9 +254,18 @@ export async function renderTaskDetail(taskId) {
 	return active;
 }
 
-export async function loadOlderTaskRuns(taskId, before, runsEl) {
+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(
-		`/api/tasks/${encodeURIComponent(taskId)}/runs?limit=20&before=${encodeURIComponent(before)}`,
+		`${taskApi}/runs?limit=20&before=${encodeURIComponent(before)}`,
 	);
 	if (!page?.runs?.length) return;
 	const table = runsEl.querySelector("table");
@@ -234,7 +285,7 @@ export async function loadOlderTaskRuns(taskId, before, runsEl) {
 	if (btn) {
 		if (page.nextBefore) {
 			btn.onclick = () => {
-				void loadOlderTaskRuns(taskId, page.nextBefore, runsEl);
+				void loadOlderTaskRuns(featureId, taskId, page.nextBefore, runsEl);
 			};
 		} else {
 			btn.remove();
@@ -242,11 +293,15 @@ export async function loadOlderTaskRuns(taskId, before, runsEl) {
 	}
 }
 
-export function startTaskPolling(taskId) {
+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(taskId);
+		const active = await renderTaskDetail(featureId, taskId);
 		if (generation !== uiState.pollingGeneration || !active) return;
 		const delay = detailPollDelay("running", isPageVisible());
 		if (delay == null) return;
@@ -257,4 +312,3 @@ export function startTaskPolling(taskId) {
 	};
 	void poll();
 }
-

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);
+}