mainflow 0.26.0 → 0.28.0

package/dist/{host-Dr0bCHd8.js → host-CeN3dvXg.js}

@@ -1,6 +1,6 @@
-import { $ as grantRepo, A as configSchema, B as parseUntil, C as SLUG, D as TASK_SECTIONS, E as TASK_REQUIRED_SECTIONS, F as mainlineSchema, G as waitingForAction, H as refMainline, I as opsEntrySchema, K as waitingForRef, L as parseActionRef, M as findingSchema, N as formatOpsEntry, P as issueSchema, Q as grantForm, R as parseOpsLine, S as SESSION_STATUS, T as SURVEY_SECTION, U as sessionSchema, V as refExample, W as taskSchema, X as describeRequest, Z as grantCovers, _ as MERGE_STATES, a as DECISION_SECTIONS, b as RESERVED_HUB_NAMES, c as FINDING_SECTIONS, et as parseGrantTarget, f as ISSUE_SECTIONS, g as MAINLINE_STATUS, h as MAINLINE_SECTIONS, i as DECISION_BASES, j as decisionSchema, k as WORK_STATUS, l as FINDING_STATUS, n as CLOSED_STATUS, r as DECIDERS, s as DEFAULT_CATEGORIES, t as CHECKLIST_REF, w as SURVEY_LINES, x as SESSION_ID, y as REF_EXAMPLES, z as parseRef } from "./dist-DlmecRLf.js";
+import { $ as grantForm, A as WORK_STATUS, B as parseRef, C as SESSION_STATUS, D as TASK_REQUIRED_SECTIONS, E as SURVEY_SECTION, F as issueSchema, G as taskSchema, H as refExample, I as mainlineSchema, K as waitingForAction, L as opsEntrySchema, M as decisionSchema, N as findingSchema, O as TASK_SECTIONS, P as formatOpsEntry, Q as grantCovers, R as parseActionRef, S as SESSION_ID, T as SURVEY_LINES, U as refMainline, V as parseUntil, W as sessionSchema, Z as describeRequest, _ as MERGE_STATES, a as DECISION_SECTIONS, b as RESERVED_HUB_NAMES, c as FINDING_SECTIONS, et as grantRepo, f as ISSUE_SECTIONS, g as MAINLINE_STATUS, h as MAINLINE_SECTIONS, i as DECISION_BASES, j as configSchema, l as FINDING_STATUS, n as CLOSED_STATUS, q as waitingForRef, r as DECIDERS, s as DEFAULT_CATEGORIES, tt as parseGrantTarget, w as SLUG, x as SERVES_REF, y as REF_EXAMPLES, z as parseOpsLine } from "./dist-BbamrIPW.js";
 import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync, writeSync } from "node:fs";
-import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, matchesGlob, parse, posix, relative, resolve, sep } from "node:path";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { parse as parse$1, stringify } from "yaml";
@@ -419,6 +419,76 @@ function mainlineEdges(graph) {
 	return [...out.values()];
 }
 //#endregion
+//#region ../core/dist/touches.js
+/** Mainline statuses whose tasks are compared: work planned or under way. */
+const COMPARED_MAINLINE = ["planning", "active"];
+/** Parent directories of a path, nearest first, without the path itself. */
+function ancestors(path) {
+	const out = [];
+	for (let dir = posix.dirname(path); dir !== "." && dir !== "/" && dir !== path; dir = posix.dirname(dir)) out.push(dir);
+	return out;
+}
+const normal = (path) => posix.normalize(path.trim()).replace(/\/+$/, "");
+/**
+* Whether a `touches` entry covers a path: the same path, a path under it, or one the glob matches directly or
+* through a parent directory. A directory or a glob that matches a directory stands for everything under it.
+*/
+function covers(pattern, path) {
+	return [path, ...ancestors(path)].some((p) => p === pattern || matchesGlob(p, pattern));
+}
+/**
+* Whether two `touches` entries overlap: equal paths, or either one covers the other as a path. Two globs meet only
+* when one matches the other's text, so `a/*.ts` and `?/b.ts` are not seen to share `a/b.ts`.
+*/
+function touchesOverlap(a, b) {
+	const x = normal(a);
+	const y = normal(b);
+	return x === y || covers(x, y) || covers(y, x);
+}
+/** Whether a dependency edge leaves `from` at the mainline or the task level and lands on `to` at either level. */
+function dependsOn(edges, from, to) {
+	const fromRefs = [from.mainline, `${from.mainline}/${from.task.id}`];
+	const lands = (ref) => ref === to.mainline || ref.startsWith(`${to.mainline}#`) || ref === `${to.mainline}/${to.task.id}` || ref.startsWith(`${to.mainline}/${to.task.id}#`);
+	return edges.some((e) => fromRefs.includes(e.from) && lands(e.to));
+}
+/** Unfinished tasks of planning or active mainlines that list `touches`, each with the mainline it sits in. */
+function openTouching(mainlines) {
+	return mainlines.filter((m) => COMPARED_MAINLINE.includes(m.status)).flatMap((m) => m.tasks.filter((t) => !CLOSED_STATUS.task.includes(t.status) && t.touches?.length).map((task) => ({
+		mainline: m.id,
+		task
+	})));
+}
+/** Unfinished tasks that list `touches` but no `repo`: their paths have no root, so touchOverlaps skips them. */
+function touchesWithoutRepo(mainlines) {
+	return openTouching(mainlines).filter((p) => !p.task.repo).map((p) => ({
+		task: `${p.mainline}/${p.task.id}`,
+		file: p.task.file
+	}));
+}
+/**
+* Open tasks of different open mainlines whose `touches` overlap in the same repo and which have no depends-on
+* between them in either direction, written on the mainline or on the task. Tasks without a repo are not compared,
+* since their paths have no root to share; touchesWithoutRepo names them.
+*/
+function touchOverlaps(mainlines, edges) {
+	const open = openTouching(mainlines).filter((p) => p.task.repo);
+	const overlaps = [];
+	open.forEach((a, i) => {
+		for (const b of open.slice(i + 1)) {
+			if (a.mainline === b.mainline || a.task.repo !== b.task.repo) continue;
+			const paths = a.task.touches.flatMap((x) => b.task.touches.filter((y) => touchesOverlap(x, y)).map((y) => [x, y]));
+			if (paths.length === 0 || dependsOn(edges, a, b) || dependsOn(edges, b, a)) continue;
+			overlaps.push({
+				tasks: [`${a.mainline}/${a.task.id}`, `${b.mainline}/${b.task.id}`],
+				repo: a.task.repo,
+				paths,
+				file: a.task.file
+			});
+		}
+	});
+	return overlaps;
+}
+//#endregion
 //#region ../core/dist/templates.js
 const body = (headings) => ["", ...headings.flatMap((h) => [`## ${h}`, ""])].join("\n");
 const MAINLINE_BODY = body(MAINLINE_SECTIONS);
@@ -656,11 +726,18 @@ function loadHub(root, options = {}) {
 	});
 	const hubIssues = hubDocs(join(dataDir, "issues"), issueSchema);
 	const taskRefs = new Set(mainlines.flatMap((m) => m.tasks.map((t) => `${m.id}/${t.id}`)));
-	for (const issue of hubIssues) if (issue.plannedIn && !taskRefs.has(issue.plannedIn)) problems.push({
-		file: issue.file,
-		field: "plannedIn",
-		message: `task ${issue.plannedIn} does not exist`
-	});
+	for (const issue of hubIssues) {
+		if (issue.plannedIn && !taskRefs.has(issue.plannedIn)) problems.push({
+			file: issue.file,
+			field: "plannedIn",
+			message: `task ${issue.plannedIn} does not exist`
+		});
+		if (issue.status !== "closed" && !issue.archivedAt && !issue.labels?.length) warnings.push({
+			file: issue.file,
+			field: "labels",
+			message: `issue ${issue.id} is ${issue.status} but has no labels; add labels so it can be found by topic`
+		});
+	}
 	const findings = hubDocs(join(dataDir, "findings"), findingSchema);
 	const ops = [];
 	const opsPath = join(dataDir, "ops");
@@ -705,6 +782,19 @@ function loadHub(root, options = {}) {
 			message: `dependency cycle ${cycle.join(" → ")}; drop one of these dependencies`
 		});
 	}
+	for (const o of touchOverlaps(mainlines, deps.edges)) {
+		const pairs = o.paths.map(([a, b]) => a === b ? a : `${a} ~ ${b}`).join(", ");
+		warnings.push({
+			file: o.file,
+			field: "touches",
+			message: `${o.tasks[0]} and ${o.tasks[1]} both touch ${pairs} in repo ${o.repo}, and neither depends on the other; coordinate before both run, or add a depends-on link`
+		});
+	}
+	for (const t of touchesWithoutRepo(mainlines)) warnings.push({
+		file: t.file,
+		field: "repo",
+		message: `${t.task} lists touches but no repo, so its paths are not compared with other tasks; add the repo they are relative to`
+	});
 	return {
 		root,
 		config,
@@ -1026,7 +1116,8 @@ function createIssue(root, input) {
 			title: input.title,
 			status: "open",
 			created: today(),
-			...input.origin ? { origin: input.origin } : {}
+			...input.origin ? { origin: input.origin } : {},
+			...input.labels?.length ? { labels: input.labels } : {}
 		}, "issue");
 		const file = join(dir, `${id}-${input.slug}.md`);
 		writeAtomic(file, frontMatterText(issue, ISSUE_BODY));
@@ -1247,14 +1338,14 @@ function grantScope(root, session) {
 		reason: `${session.id} 同時有 ${doing.length} 個進行中的行動（${doing.map((a) => a.id).join("、")}），分不出授權範圍`
 	};
 	const action = doing[0];
-	const mainlines = [...new Set(action.serves.flatMap((ref) => {
+	const mainlineOf = (ref) => {
 		const parsed = parseRef(ref);
-		const mainline = parsed ? refMainline(parsed) : void 0;
-		return mainline ? [mainline] : [];
-	}))];
+		return parsed ? refMainline(parsed) : void 0;
+	};
+	const mainlines = [...new Set(action.serves.flatMap((ref) => mainlineOf(ref) ?? []))];
 	if (mainlines.length === 0) return {
 		ok: false,
-		reason: `${action.id} 沒有服務任何 checklist 項目`
+		reason: `${action.id} 沒有服務任何 checklist 項目或解決條件`
 	};
 	const grants = [];
 	const served = {};
@@ -1265,7 +1356,7 @@ function grantScope(root, session) {
 			closed.push(`${id} 是 ${mainline.status}`);
 			continue;
 		}
-		served[id] = action.serves.find((ref) => ref.startsWith(`${id}/`));
+		served[id] = action.serves.find((ref) => mainlineOf(ref) === id);
 		for (const grant of mainline.grants ?? []) grants.push({
 			mainline: id,
 			grant,
@@ -1433,23 +1524,30 @@ function resolveAction(root, ref) {
 	}
 }
 /**
-* Every served checklist item must exist, so a session never points at work that is not in a mainline. Its
-* mainline must still be open: follow-up work on an ended one either reopens it with a criterion or task for the
-* follow-up, or starts a new mainline, so the follow-up is tracked instead of hanging off finished work.
+* Every served checklist item or criterion must exist, so a session never points at work that is not in a
+* mainline. A criterion stands in while the mainline has no task for it yet, as when it is still being surveyed
+* and planned. Its mainline must still be open: follow-up work on an ended one either reopens it with a criterion
+* or task for the follow-up, or starts a new mainline, so the follow-up is tracked instead of hanging off finished work.
 */
 function requireServes(root, serves) {
 	for (const ref of serves) {
 		const parsed = parseRef(ref);
-		if (!CHECKLIST_REF.test(ref) || parsed?.kind !== "checklistItem") throw new WriteError(`--serves takes checklist references like m001/t002#c003, got "${ref}"`);
+		if (!SERVES_REF.test(ref) || parsed?.kind !== "checklistItem" && parsed?.kind !== "criterion") throw new WriteError(`--serves takes checklist items like m001/t002#c003 or criteria like m001#r001, got "${ref}"`);
 		const mainline = readFrontMatter(mainlineFile(root, parsed.mainline), mainlineSchema).data;
 		if (CLOSED_STATUS.mainline.includes(mainline.status)) throw new WriteError(`${parsed.mainline} is ${mainline.status}; to continue it, run "mainline set ${parsed.mainline} --status active" and add a criterion or task for the follow-up, or start a new mainline with "new mainline"`);
+		if (parsed.kind === "criterion") {
+			if (!mainline.criteria.some((r) => r.id === parsed.criterion)) throw new WriteError(`criterion ${ref} not found`);
+			continue;
+		}
 		if (!readFrontMatter(taskFile(root, parsed.mainline, parsed.task), taskSchema).data.checklist.some((c) => c.id === parsed.item)) throw new WriteError(`checklist item ${ref} not found`);
 	}
 }
 const isOpen$1 = (a) => a.status === "todo" || a.status === "doing";
+const isCarried$1 = (a) => isOpen$1(a) || a.status === "blocked";
 /**
 * The previous session's unfinished actions, numbered after `existing`, with the previous session marked
-* handed-off. Each carried action is dropped in the previous session with a note naming its new reference,
+* handed-off. Blocked actions go along with their `blockedBy`, since the wait is still on and whoever is
+* waited for keeps seeing it. Each carried action is dropped in the previous session with a note naming its new reference,
 * so the work stays open in one place only and the old session still shows where it went. Runs inside the
 * caller's lock.
 */
@@ -1460,7 +1558,7 @@ function takeUnfinished(root, from, to, existing) {
 	const carried = [];
 	const at = nowMinute();
 	const left = previous.actions.map((a) => {
-		if (!isOpen$1(a)) return a;
+		if (!isCarried$1(a)) return a;
 		const id = nextId("a", ids);
 		ids.push(id);
 		carried.push({
@@ -1468,8 +1566,9 @@ function takeUnfinished(root, from, to, existing) {
 			id
 		});
 		const handedOff = handedOffNote(`${to}#${id}`);
+		const { blockedBy: _moved, ...rest } = a;
 		return {
-			...a,
+			...rest,
 			status: "dropped",
 			note: a.note ? `${a.note}; ${handedOff}` : handedOff,
 			doneAt: at
@@ -1545,7 +1644,7 @@ function handoffSession(root, id, from) {
 		if (session.handoffFrom && session.handoffFrom !== from) throw new WriteError(`session ${id} already took over from ${session.handoffFrom}`);
 		const open = session.actions.filter(isOpen$1);
 		if (open.length > 0) throw new WriteError(`session ${id} has unfinished actions (${open.map((a) => a.id).join(", ")}); finish or drop them before taking over from ${from}`);
-		if (!readYaml(requireSession(root, from), sessionSchema).data.actions.some(isOpen$1)) throw new WriteError(`session ${from} has no unfinished actions to take over`);
+		if (!readYaml(requireSession(root, from), sessionSchema).data.actions.some(isCarried$1)) throw new WriteError(`session ${from} has no unfinished actions to take over`);
 		const carried = takeUnfinished(root, from, id, session.actions.map((a) => a.id));
 		const next = validate(sessionSchema, {
 			...session,
@@ -1566,6 +1665,13 @@ function setSessionInfo(root, id, info) {
 		for (const [key, value] of Object.entries(info)) if (value !== void 0 && value !== null && value !== "") s[key] = value;
 	});
 }
+/** Remember the digest of what the last turn reminder listed in full; null forgets it, so the next reminder lists everything again. */
+function setReminderDigest(root, id, digest) {
+	mutateYaml(root, requireSession(root, id), sessionSchema, (s) => {
+		if (digest === null) delete s.reminderDigest;
+		else s.reminderDigest = digest;
+	});
+}
 function setSessionStatus(root, id, status) {
 	const value = requireOneOf(status, SESSION_STATUS, "session status");
 	return mutateYaml(root, requireSession(root, id), sessionSchema, (s) => {
@@ -1662,6 +1768,8 @@ function updateAction(root, ref, patch) {
 		const index = s.actions.findIndex((a) => a.id === action);
 		if (index < 0) throw new WriteError(`action ${ref} not found`);
 		const [current] = s.actions.splice(index, 1);
+		const movedTo = HANDED_OFF.exec(current.note ?? "")?.[1];
+		if (movedTo && current.status === "dropped" && status !== void 0 && status !== "dropped") throw new WriteError(`${ref} was handed off to ${movedTo}, and references to ${ref} follow its note only while it stays dropped; change ${movedTo} instead`);
 		const handedTo = patch.note ? HANDED_OFF.exec(current.note ?? "")?.[1] : void 0;
 		if (handedTo) throw new WriteError(`${ref} was handed off to ${handedTo}, and references to ${ref} follow its note there, so the note stays as it is; add the note to ${handedTo} instead`);
 		const next = {
@@ -1695,9 +1803,18 @@ function updateAction(root, ref, patch) {
 //#region ../core/dist/briefing.js
 function describe(root, ref) {
 	const parsed = parseRef(ref);
-	if (parsed?.kind !== "checklistItem") return null;
+	if (parsed?.kind !== "checklistItem" && parsed?.kind !== "criterion") return null;
 	try {
 		const mainline = readFrontMatter(mainlineFile(root, parsed.mainline), mainlineSchema).data;
+		if (parsed.kind === "criterion") {
+			const criterion = mainline.criteria.find((r) => r.id === parsed.criterion);
+			return criterion ? {
+				ref,
+				text: criterion.text,
+				checked: criterion.done,
+				where: `${mainline.id} ${mainline.title} › 解決條件`
+			} : null;
+		}
 		const task = readFrontMatter(taskFile(root, parsed.mainline, parsed.task), taskSchema).data;
 		const item = task.checklist.find((c) => c.id === parsed.item);
 		if (!item) return null;
@@ -1711,6 +1828,32 @@ function describe(root, ref) {
 		return null;
 	}
 }
+/** The criteria a served checklist item pushes forward, as m{NNN}#r{NNN}; empty for a criterion or an item that cannot be read. */
+function criteriaOf(root, ref) {
+	const parsed = parseRef(ref);
+	if (parsed?.kind !== "checklistItem") return [];
+	try {
+		return (readFrontMatter(taskFile(root, parsed.mainline, parsed.task), taskSchema).data.checklist.find((c) => c.id === parsed.item)?.serves ?? []).map((r) => `${parsed.mainline}#${r}`);
+	} catch {
+		return [];
+	}
+}
+/**
+* Where two served lists meet: a reference both serve, or a criterion one serves that a checklist item the other
+* serves pushes forward, named as the item with its criterion. Two items serving the same criterion do not meet,
+* since splitting a criterion into items is how work on it runs in parallel.
+*/
+function sharedServes(root, mine, theirs) {
+	const shared = mine.filter((ref) => theirs.includes(ref));
+	const pushes = (items, criteria) => items.flatMap((item) => criteriaOf(root, item).filter((r) => criteria.includes(r)).map((r) => `${item}（推進 ${r}）`));
+	const mineCriteria = mine.filter((ref) => parseRef(ref)?.kind === "criterion");
+	const theirCriteria = theirs.filter((ref) => parseRef(ref)?.kind === "criterion");
+	return [.../* @__PURE__ */ new Set([
+		...shared,
+		...pushes(theirs, mineCriteria),
+		...pushes(mine, theirCriteria)
+	])];
+}
 /** Problems in a session's queue that the executor should fix before going on, each with the command that fixes it. */
 function queueWarnings(root, session, cli) {
 	const warnings = [];
@@ -1718,8 +1861,8 @@ function queueWarnings(root, session, cli) {
 	if (doing.length > 1) warnings.push(`同時有 ${doing.length} 個進行中的行動（${doing.map((a) => a.id).join("、")}）。一次只推進一個，其餘改回 todo。`);
 	for (const action of doing) {
 		const served = action.serves.map((ref) => describe(root, ref));
-		if (served.some((s) => s === null)) warnings.push(`${action.id} 服務的項目有的已不存在，用 ${cli} action set ${action.id} --serves <m/t#c> 改正。`);
-		else if (served.length > 0 && served.every((s) => s.checked)) warnings.push(`${action.id} 服務的項目都已勾選。做完了就執行 ${cli} action set ${action.id} --status done。`);
+		if (served.some((s) => s === null)) warnings.push(`${action.id} 服務的項目有的已不存在，用 ${cli} action set ${action.id} --serves <m/t#c 或 m#r> 改正。`);
+		else if (served.length > 0 && served.every((s) => s.checked)) warnings.push(`${action.id} 服務的項目都已勾選或達成。做完了就執行 ${cli} action set ${action.id} --status done。`);
 	}
 	const next = session.actions.find((a) => a.status === "todo");
 	if (doing.length === 0 && next) warnings.push(`下一個行動是 ${next.id}。開始前先執行 ${cli} action set ${next.id} --status doing。`);
@@ -1727,6 +1870,8 @@ function queueWarnings(root, session, cli) {
 }
 const current = (session) => session.actions.find((a) => a.status === "doing");
 const isOpen = (a) => a.status === "todo" || a.status === "doing";
+/** What a handoff takes over: open actions and blocked ones, which are still unfinished. */
+const isCarried = (a) => isOpen(a) || a.status === "blocked";
 /** A blocked action and what it waits for: the reason, the other party and the condition, as `action set --status blocked` recorded them. */
 function waitingLine(a) {
 	const block = a.blockedBy;
@@ -1794,8 +1939,8 @@ function waiterLines(root, session) {
 	return lines;
 }
 /**
-* One reminder for each action in progress in another session that may still be running and serves an item
-* this action also serves. Sessions in the same delegation tree are left out: a subagent working on the item
+* One reminder for each action in progress in another session that may still be running and serves what this
+* action also serves: the same item or criterion, or a criterion and an item that pushes it forward. Sessions in the same delegation tree are left out: a subagent working on the item
 * its parent handed it is not a second claim.
 */
 function duplicateClaimLines(root, sessionId, actionId) {
@@ -1807,7 +1952,7 @@ function duplicateClaimLines(root, sessionId, actionId) {
 	for (const other of sessions) {
 		if (related.has(other.id) || !mayBeRunning(root, other)) continue;
 		for (const theirs of other.actions.filter((a) => a.status === "doing")) {
-			const shared = theirs.serves.filter((ref) => action.serves.includes(ref));
+			const shared = sharedServes(root, action.serves, theirs.serves);
 			if (shared.length > 0) lines.push(`⚠ ${other.id}#${theirs.id}（15 分鐘內有活動）也在做 ${shared.join("、")}，先協調再開始`);
 		}
 	}
@@ -1818,14 +1963,32 @@ function duplicateClaimLines(root, sessionId, actionId) {
 * over into this one. Subagent sessions are left out: their work returns to the session that delegated it.
 */
 function handoffLines(root, session, cli) {
-	const others = loadSessions(root).sessions.filter((s) => s.id !== session.id && !s.delegatedFrom && !s.archivedAt && (s.status === "active" || s.status === "paused") && s.actions.some(isOpen));
+	const others = loadSessions(root).sessions.filter((s) => s.id !== session.id && !s.delegatedFrom && !s.archivedAt && (s.status === "active" || s.status === "paused") && s.actions.some(isCarried));
 	if (others.length === 0) return [];
-	return [`其他會話還有沒做完的行動。要接續的是其中一場已經停下的工作時，先用 ${cli} session handoff <會話> 把它的行動接進這場會話，再開始做：`, ...others.map((s) => `- ${s.id}${mayBeRunning(root, s) ? "（15 分鐘內還有寫入對話紀錄，可能還在執行，不要接手）" : ""}：${s.actions.filter(isOpen).map((a) => `${a.id} ${a.do}（${a.status}，服務 ${a.serves.join("、") || "未指定"}）`).join("；")}`)];
+	return [`其他會話還有沒做完的行動。要接續的是其中一場已經停下的工作時，先用 ${cli} session handoff <會話> 把它的行動接進這場會話，再開始做：`, ...others.map((s) => `- ${s.id}${mayBeRunning(root, s) ? "（15 分鐘內還有寫入對話紀錄，可能還在執行，不要接手）" : ""}：${s.actions.filter(isCarried).map((a) => `${a.id} ${a.do}（${a.status}，服務 ${a.serves.join("、") || "未指定"}）`).join("；")}`)];
 }
 const servedLine = (root, action) => action.serves.map((ref) => {
 	const s = describe(root, ref);
-	return s ? `${ref} ${s.text}（${s.where}）` : `${ref}（找不到這個項目）`;
-}).join("；") || "沒有指定服務的 checklist 項目";
+	return s ? `${ref} ${s.text}（${s.where}）` : `${ref}（找不到這個項目或條件）`;
+}).join("；") || "沒有指定服務的 checklist 項目或解決條件";
+/**
+* Lines for each pair of overlapping touches that involves a mainline an action in progress serves: the other
+* mainline and task, and the paths they share. Empty when the session serves nothing that overlaps.
+*/
+function overlapLines(root, session) {
+	const mine = new Set(session.actions.filter((a) => a.status === "doing").flatMap((a) => a.serves.map((ref) => parseRef(ref))).flatMap((parsed) => parsed && "mainline" in parsed ? [parsed.mainline] : []));
+	if (mine.size === 0) return [];
+	const hub = loadHub(root, { remotes: false });
+	const lines = [];
+	for (const o of touchOverlaps(hub.mainlines, dependencyGraph(hub).edges)) {
+		const [own, other] = mine.has(o.tasks[0].split("/")[0]) ? [0, 1] : mine.has(o.tasks[1].split("/")[0]) ? [1, 0] : [-1, -1];
+		if (own < 0) continue;
+		const paths = o.paths.map(([a, b]) => own === 0 ? [a, b] : [b, a]).map(([a, b]) => a === b ? a : `${a} ~ ${b}`).join("、");
+		const title = hub.mainlines.find((m) => m.id === o.tasks[other].split("/")[0])?.title;
+		lines.push(`- ${o.tasks[own]} 和 ${o.tasks[other]}${title ? `（${title}）` : ""} 都會動到 ${paths}（倉庫 ${o.repo}），兩邊沒有 depends-on`);
+	}
+	return lines;
+}
 /** Full briefing for the start of a session, after resuming, clearing or compacting. */
 function sessionBriefing(root, session, options) {
 	const { cli } = options;
@@ -1850,13 +2013,18 @@ function sessionBriefing(root, session, options) {
 		if (blocked.length > 0) lines.push(`等外部條件：${blocked.map(waitingLine).join("；")}`);
 	}
 	lines.push(...waiterLines(root, session));
+	const overlaps = overlapLines(root, session);
+	if (overlaps.length > 0) lines.push("目前行動服務的主脈絡和其他進行中的主脈絡預計動到同樣的路徑，開始改之前先和對方協調，或加 depends-on：", ...overlaps);
 	if (!session.actions.some(isOpen)) lines.push(...handoffLines(root, session, cli));
 	const warnings = queueWarnings(root, session, cli);
 	if (warnings.length > 0) lines.push("需要處理：", ...warnings.map((w) => `- ${w}`));
-	lines.push("工作方式：", `- 開始一件新工作前，先列進佇列：${cli} action add "<做法>" --serves <m/t#c>。`, `- 開始做標 doing，做完標 done：${cli} action set <a編號> --status doing。`, `- 勾選 checklist 要附證據：${cli} item check <m/t#c> --evidence <commit、檔案:行號或指令輸出>。`, `- 內容直接寫進檔案：意圖或需求寫進 mainline.md 的內文，任務的目標與完成定義寫進 task.md，選擇寫成決策（${cli} new decision <m> <slug> --title <標題> 建檔後再寫內文）。`, `- 改完 .mainflow/ 的檔案跑 ${cli} check，把它列出的問題修到沒有。`, "- 用完其他 skill 或子流程後，回到上面的目前行動再繼續。", "- 要開主脈絡、拆任務、記決策、延後或收尾時，用 mainflow skill，它依序帶過並告訴你資訊該寫在哪裡。");
+	lines.push("工作方式：", `- 開始一件新工作前，先列進佇列：${cli} action add "<做法>" --serves <m/t#c>。主脈絡還沒拆任務時（查核與規劃階段），--serves 指向解決條件 <m#r>。`, `- 開始做標 doing，做完標 done：${cli} action set <a編號> --status doing。`, `- 勾選 checklist 要附證據：${cli} item check <m/t#c> --evidence <commit、檔案:行號或指令輸出>。`, `- 內容直接寫進檔案：意圖或需求寫進 mainline.md 的內文，任務的目標與完成定義寫進 task.md，選擇寫成決策（${cli} new decision <m> <slug> --title <標題> 建檔後再寫內文）。`, `- 改完 .mainflow/ 的檔案跑 ${cli} check，把它列出的問題修到沒有。`, "- 用完其他 skill 或子流程後，回到上面的目前行動再繼續。", "- 要開主脈絡、拆任務、記決策、延後或收尾時，用 mainflow skill，它依序帶過並告訴你資訊該寫在哪裡。");
 	return lines.join("\n");
 }
-/** One or two lines for every user turn; null when the session has no actions and the hub has no open mainline. */
+/**
+* One or two lines for every user turn; null when the session has no actions and the hub has no open mainline.
+* Records a digest of the grants, waits and warnings it lists in the session file, only when the digest changes.
+*/
 function turnReminder(root, session, options) {
 	if (session.actions.length === 0) return openMainlines(root).length > 0 ? `[mainflow] ${session.id} 還沒有行動。這一輪要推進主脈絡時，先用 ${options.cli} action add 列出行動並標為 doing，或用 ${options.cli} session handoff <會話> 接手上一場沒做完的行動，再開始做。回覆結尾的標頭只看這場會話進行中的行動。` : null;
 	const doing = current(session);
@@ -1866,13 +2034,28 @@ function turnReminder(root, session, options) {
 	const header = headerLine(session);
 	const marker = header ? [`- 這一輪最後一則回覆的最後一行寫「${header}」，回覆範例等其他內容都放在它前面。有顯示 hook 時，它會換成標題與連結。`] : [];
 	const grants = grantLines(root, session);
-	const granted = grants.length > 0 ? ["- 目前行動服務的主脈絡預先授權了這些動作：", ...grants.map((g) => `  ${g}`)] : [];
+	const waiters = waiterLines(root, session);
+	const warnings = queueWarnings(root, session, options.cli);
+	const digest = contentHash(JSON.stringify([
+		doing?.id ?? null,
+		grants,
+		waiters,
+		warnings
+	]));
+	const repeated = session.reminderDigest === digest;
+	if (!repeated && (session.reminderDigest !== void 0 || grants.length + waiters.length + warnings.length > 0) && readSession(root, session.id)) try {
+		setReminderDigest(root, session.id, digest);
+	} catch {}
+	const once = (lines, summary, full) => lines.length === 0 ? [] : repeated ? [summary] : full;
+	const granted = once(grants, `- 預先授權同上一輪，共 ${grants.length} 條。`, ["- 目前行動服務的主脈絡預先授權了這些動作：", ...grants.map((g) => `  ${g}`)]);
+	const waiting = once(waiters, `- 等待行同上一輪，共 ${waiters.length} 條。`, waiters.map((w) => `- ${w}`));
+	const warned = once(warnings, `- 佇列提醒同上一輪，共 ${warnings.length} 條。`, warnings.map((w) => `- ${w}`));
 	return [
 		head,
-		...waiterLines(root, session).map((w) => `- ${w}`),
+		...waiting,
 		...granted,
 		...marker,
-		...queueWarnings(root, session, options.cli).map((w) => `- ${w}`)
+		...warned
 	].join("\n");
 }
 //#endregion
@@ -2096,7 +2279,7 @@ function setCriterion(root, refInput, done, evidence, expectedVersion) {
 	return mutateFrontMatter(root, mainlineFile(root, ref.mainline), mainlineSchema, (m) => {
 		const criterion = m.criteria.find((c) => c.id === ref.criterion);
 		if (!criterion) throw new WriteError(`criterion ${refInput} not found`);
-		setListItem(criterion, done, evidence);
+		setListItem(criterion, done, evidence, `${refInput} is dropped; remove dropped and supersededBy in ${MAINLINE_FILE} to bring it back before checking it`);
 	}, expectedVersion);
 }
 /** Rewrite a criterion's text or doneWhen, leaving done and evidence as they are. */
@@ -2110,14 +2293,17 @@ function setCriterionText(root, refInput, patch, expectedVersion) {
 		if (patch.doneWhen !== void 0) criterion.doneWhen = patch.doneWhen;
 	}, expectedVersion);
 }
-/** Check or uncheck a criterion or checklist item; checking clears a drop. */
-function setListItem(item, done, evidence) {
+/**
+* Check or uncheck a criterion or checklist item. A dropped item cannot be checked, because a drop is a
+* ruling that the item is no longer needed; `droppedHint` says how to bring it back. Neither direction
+* touches dropped or supersededBy.
+*/
+function setListItem(item, done, evidence, droppedHint) {
+	if (done && item.dropped) throw new WriteError(droppedHint);
 	item.done = done;
 	if (done) {
 		item.evidence = evidence;
 		item.doneAt = today();
-		delete item.dropped;
-		delete item.supersededBy;
 	} else {
 		delete item.evidence;
 		delete item.doneAt;
@@ -2192,7 +2378,7 @@ function setChecklistItem(root, refInput, done, evidence, expectedVersion) {
 	return mutateFrontMatter(root, taskFile(root, ref.mainline, ref.task), taskSchema, (t) => {
 		const item = t.checklist.find((c) => c.id === ref.item);
 		if (!item) throw new WriteError(`checklist item ${refInput} not found`);
-		setListItem(item, done, evidence);
+		setListItem(item, done, evidence, `${refInput} is dropped; run item undrop ${refInput} to bring it back before checking it`);
 	}, expectedVersion);
 }
 /** Mark an item as no longer needed, naming what replaced it when something did. */
@@ -2207,6 +2393,20 @@ function dropChecklistItem(root, refInput, input = {}, expectedVersion) {
 		if (input.note) item.note = input.note;
 	}, expectedVersion);
 }
+/** Bring a dropped item back as an open one: clears dropped and supersededBy, keeps the note. */
+function undropChecklistItem(root, refInput, expectedVersion) {
+	const ref = requireRef(refInput, "checklistItem");
+	return mutateFrontMatter(root, taskFile(root, ref.mainline, ref.task), taskSchema, (t) => {
+		const item = t.checklist.find((c) => c.id === ref.item);
+		if (!item) throw new WriteError(`checklist item ${refInput} not found`);
+		if (!item.dropped) throw new WriteError(`${refInput} is not dropped`);
+		delete item.dropped;
+		delete item.supersededBy;
+		item.done = false;
+		delete item.evidence;
+		delete item.doneAt;
+	}, expectedVersion);
+}
 function createDecision(root, mainline, input) {
 	requireRef(mainline, "mainline");
 	requireSlug(input.slug);
@@ -2314,6 +2514,474 @@ function setArchivedMany(root, kind, ids, archived) {
 	return result;
 }
 //#endregion
+//#region ../core/dist/retro.js
+/** Where the prices come from and when they were read; every figure is USD per million tokens. */
+const PRICING_SOURCE = {
+	url: "https://platform.claude.com/docs/en/about-claude/pricing",
+	date: "2026-09-30",
+	unit: "USD/MTok"
+};
+const price = (input, cacheWrite5m, cacheWrite1h, cacheRead, output) => ({
+	input,
+	cacheWrite5m,
+	cacheWrite1h,
+	cacheRead,
+	output
+});
+/**
+* List prices by model id prefix. A model matches a prefix when the rest of its id is empty, a date suffix
+* (-20251001) or a bracketed variant ([1m]); any other model has no known price, so its cost is not guessed.
+*/
+const MODEL_PRICES = [
+	{
+		prefix: "claude-opus-5-5",
+		price: price(4, 5, 8, .2, 20)
+	},
+	{
+		prefix: "claude-opus-5",
+		price: price(5, 6.25, 10, .5, 25)
+	},
+	{
+		prefix: "claude-opus-4-8",
+		price: price(5, 6.25, 10, .5, 25)
+	},
+	{
+		prefix: "claude-sonnet-5-5",
+		price: price(2, 2.5, 4, .2, 10)
+	},
+	{
+		prefix: "claude-sonnet-5",
+		price: price(2, 2.5, 4, .2, 10)
+	},
+	{
+		prefix: "claude-sonnet-4-6",
+		price: price(3, 3.75, 6, .3, 15)
+	},
+	{
+		prefix: "claude-haiku-4-5",
+		price: price(1, 1.25, 2, .1, 5)
+	},
+	{
+		prefix: "claude-fable-5-1",
+		price: price(10, 12.5, 20, .25, 50)
+	}
+];
+/**
+* Prices at speed "fast", keyed by the MODEL_PRICES prefix. The cache multipliers stack on the fast input
+* price (5m write 1.25x, 1h write 2x, read 0.05x for Opus 5.5 and 0.1x otherwise), as with standard speed.
+*/
+const FAST_PRICES = {
+	"claude-opus-5-5": price(8, 10, 16, .4, 40),
+	"claude-opus-5": price(10, 12.5, 20, 1, 50),
+	"claude-opus-4-8": price(10, 12.5, 20, 1, 50)
+};
+/** Inference kept in the US (inference_geo "us") is billed at 1.1 times the list price. */
+const US_GEO_MULTIPLIER = 1.1;
+const PRICE_SUFFIX = /^(?:-\d{8})?(?:\[[^\]]*\])?$/;
+/** The price entry a model id falls under: the longest prefix whose remainder is only a date or a variant. */
+function priceEntry(model) {
+	return MODEL_PRICES.filter((p) => model.startsWith(p.prefix) && PRICE_SUFFIX.test(model.slice(p.prefix.length))).sort((a, b) => b.prefix.length - a.prefix.length)[0];
+}
+const priceOf = (model) => priceEntry(model)?.price;
+const emptyUsage = () => ({
+	input: 0,
+	cacheWrite5m: 0,
+	cacheWrite1h: 0,
+	cacheRead: 0,
+	output: 0
+});
+const addUsage = (to, from) => {
+	for (const key of Object.keys(to)) to[key] += from[key];
+};
+/** Everything the model read before answering: fresh input, cache writes and cache reads. */
+const contextTokens = (u) => u.input + u.cacheWrite5m + u.cacheWrite1h + u.cacheRead;
+/** Share of the context served from the cache; null when there was no context at all. */
+const cacheHitRate = (u) => contextTokens(u) > 0 ? u.cacheRead / contextTokens(u) : null;
+const num = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+/** Read message.usage; cache writes without the 5m and 1h split count as 5m, the default cache lifetime. */
+function readUsage(raw) {
+	const created = num(raw.cache_creation_input_tokens);
+	const split = raw.cache_creation ?? {};
+	const w1h = num(split.ephemeral_1h_input_tokens);
+	const w5m = split.ephemeral_5m_input_tokens === void 0 ? created - w1h : num(split.ephemeral_5m_input_tokens);
+	return {
+		input: num(raw.input_tokens),
+		cacheWrite5m: Math.max(0, w5m),
+		cacheWrite1h: w1h,
+		cacheRead: num(raw.cache_read_input_tokens),
+		output: num(raw.output_tokens)
+	};
+}
+/** The estimated cost of one message in USD, or null when the model has no known price. */
+function messageCost(model, usage, speed, geo) {
+	const entry = priceEntry(model);
+	if (!entry) return null;
+	const p = (speed === "fast" ? FAST_PRICES[entry.prefix] : void 0) ?? entry.price;
+	const usd = (usage.input * p.input + usage.cacheWrite5m * p.cacheWrite5m + usage.cacheWrite1h * p.cacheWrite1h + usage.cacheRead * p.cacheRead + usage.output * p.output) / 1e6;
+	return geo === "us" ? usd * US_GEO_MULTIPLIER : usd;
+}
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const blocks = (content) => Array.isArray(content) ? content.filter(isObject) : [];
+/** The text a hook attachment hands to the model, empty when it hands none. */
+function hookText(a) {
+	const parts = [];
+	if (typeof a.content === "string") parts.push(a.content);
+	if (Array.isArray(a.content)) parts.push(...a.content.filter((c) => typeof c === "string"));
+	const blocking = a.blockingError;
+	if (typeof blocking === "string") parts.push(blocking);
+	if (isObject(blocking) && typeof blocking.blockingError === "string") parts.push(blocking.blockingError);
+	return parts.join("");
+}
+const hookEvent = (a) => typeof a.hookEvent === "string" && a.hookEvent ? a.hookEvent : typeof a.hookName === "string" && a.hookName ? a.hookName.split(":")[0] : "unknown";
+const emptyStats = (file, found) => ({
+	file,
+	found,
+	versions: [],
+	lines: 0,
+	unreadable: 0,
+	messages: [],
+	toolUses: 0,
+	toolErrors: {},
+	bashRuns: {},
+	hooks: [],
+	misfires: {},
+	gaps: []
+});
+function readTranscript(file) {
+	const stats = emptyStats(file, existsSync(file));
+	if (!stats.found) return stats;
+	const versions = /* @__PURE__ */ new Set();
+	const byId = /* @__PURE__ */ new Map();
+	const toolNames = /* @__PURE__ */ new Map();
+	const hooks = /* @__PURE__ */ new Map();
+	/** Injections still waiting for the next assistant message, with the message they came after */
+	let pending = [];
+	const bound = [];
+	let lastAssistant;
+	let lastAt;
+	let lastAtText = "";
+	let anonymous = 0;
+	for (const text of readFileSync(file, "utf8").split("\n")) {
+		if (!text.trim()) continue;
+		stats.lines += 1;
+		let line;
+		try {
+			const parsed = JSON.parse(text);
+			if (!isObject(parsed)) throw new Error("not an object");
+			line = parsed;
+		} catch {
+			stats.unreadable += 1;
+			continue;
+		}
+		if (typeof line.version === "string") versions.add(line.version);
+		const at = typeof line.timestamp === "string" ? Date.parse(line.timestamp) : NaN;
+		if (!Number.isNaN(at)) {
+			if (lastAt !== void 0 && at - lastAt > 3e5) {
+				const turnEnded = lastAssistant !== void 0 && byId.get(lastAssistant)?.toolUses === 0;
+				stats.gaps.push({
+					from: lastAtText,
+					to: line.timestamp,
+					minutes: Math.round((at - lastAt) / 6e4),
+					waitingForUser: turnEnded
+				});
+			}
+			if (lastAt === void 0 || at > lastAt) {
+				lastAt = at;
+				lastAtText = line.timestamp;
+			}
+		}
+		if (line.type === "assistant") {
+			const m = line.message;
+			if (!isObject(m)) {
+				stats.unreadable += 1;
+				continue;
+			}
+			const id = typeof m.id === "string" && m.id ? m.id : `(no id ${++anonymous})`;
+			let message = byId.get(id);
+			if (!message) {
+				message = {
+					id,
+					model: typeof m.model === "string" ? m.model : "unknown",
+					usage: emptyUsage(),
+					toolUses: 0,
+					...typeof line.timestamp === "string" ? { at: line.timestamp } : {}
+				};
+				byId.set(id, message);
+				stats.messages.push(message);
+			}
+			if (isObject(m.usage)) {
+				const usage = readUsage(m.usage);
+				for (const key of Object.keys(usage)) message.usage[key] = Math.max(message.usage[key], usage[key]);
+				if (typeof m.usage.speed === "string") message.speed = m.usage.speed;
+				if (typeof m.usage.inference_geo === "string") message.geo = m.usage.inference_geo;
+			}
+			for (const block of blocks(m.content)) {
+				if (block.type !== "tool_use") continue;
+				message.toolUses += 1;
+				stats.toolUses += 1;
+				const name = typeof block.name === "string" ? block.name : "unknown";
+				if (typeof block.id === "string") toolNames.set(block.id, name);
+				const input = isObject(block.input) ? block.input : {};
+				if (name === "Bash" && typeof input.command === "string") {
+					const command = input.command.trim();
+					stats.bashRuns[command] = (stats.bashRuns[command] ?? 0) + 1;
+				}
+			}
+			if (id !== lastAssistant) {
+				for (const p of pending.filter((x) => x.after !== id)) bound.push({
+					event: p.event,
+					message: id
+				});
+				pending = pending.filter((x) => x.after === id);
+			}
+			lastAssistant = id;
+			continue;
+		}
+		if (line.type === "user" && line.message !== void 0) {
+			for (const block of blocks(line.message?.content)) {
+				if (block.type !== "tool_result" || block.is_error !== true) continue;
+				const name = typeof block.tool_use_id === "string" && toolNames.get(block.tool_use_id) || "unknown";
+				stats.toolErrors[name] = (stats.toolErrors[name] ?? 0) + 1;
+			}
+			continue;
+		}
+		if (line.type === "attachment") {
+			const a = line.attachment;
+			if (!isObject(a)) {
+				stats.unreadable += 1;
+				continue;
+			}
+			const kind = typeof a.type === "string" ? a.type : "";
+			if (!kind.includes("hook")) continue;
+			const event = hookEvent(a);
+			const hook = hooks.get(event) ?? {
+				event,
+				injections: 0,
+				chars: 0,
+				blocked: 0
+			};
+			hooks.set(event, hook);
+			if (kind.includes("blocking")) hook.blocked += 1;
+			const injected = hookText(a);
+			if (injected.length > 0) {
+				hook.injections += 1;
+				hook.chars += [...injected].length;
+				pending.push({
+					event,
+					after: lastAssistant
+				});
+			}
+		}
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const b of bound) {
+		const key = `${b.event}\u0000${b.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (byId.get(b.message)?.toolUses === 0) stats.misfires[b.event] = (stats.misfires[b.event] ?? 0) + 1;
+	}
+	stats.versions = [...versions].sort();
+	stats.hooks = [...hooks.values()];
+	return stats;
+}
+/** Whether any action of the session serves the mainline, through a checklist item or a criterion. */
+const servesMainline = (session, mainline) => session.actions.some((a) => a.serves.some((ref) => {
+	const parsed = parseRef(ref);
+	return parsed !== null && parsed.hub === void 0 && refMainline(parsed) === mainline;
+}));
+/** Subagent transcripts Claude Code keeps beside a session's: <dir>/<session>/subagents/*.jsonl. */
+function subagentFiles(transcript) {
+	const dir = join(transcript.replace(/\.jsonl$/, ""), "subagents");
+	try {
+		return readdirSync(dir).filter((n) => n.endsWith(".jsonl")).sort().map((n) => join(dir, n));
+	} catch {
+		return [];
+	}
+}
+function readMeta(file) {
+	try {
+		const meta = JSON.parse(readFileSync(file.replace(/\.jsonl$/, ".meta.json"), "utf8"));
+		if (!isObject(meta)) return {};
+		return {
+			...typeof meta.agentType === "string" ? { agentType: meta.agentType } : {},
+			...typeof meta.description === "string" ? { description: meta.description } : {}
+		};
+	} catch {
+		return {};
+	}
+}
+function summarize(stats) {
+	const usage = emptyUsage();
+	let cost = 0;
+	const unknown = /* @__PURE__ */ new Set();
+	const priced = stats.messages.filter((m) => m.model !== "<synthetic>");
+	for (const m of priced) {
+		addUsage(usage, m.usage);
+		const c = messageCost(m.model, m.usage, m.speed, m.geo);
+		if (c === null) unknown.add(m.model);
+		else cost += c;
+	}
+	const first = priced.find((m) => contextTokens(m.usage) > 0);
+	return {
+		file: stats.file,
+		found: stats.found,
+		calls: priced.length,
+		usage,
+		cost,
+		unknownPriceModels: [...unknown].sort(),
+		models: [...new Set(priced.map((m) => m.model))].sort(),
+		openingContext: first ? contextTokens(first.usage) : null,
+		cacheHitRate: cacheHitRate(usage)
+	};
+}
+/** Lines of a task's 紀錄 section that record a completion check that did not pass. */
+const FAILED_CHECK = (line) => line.includes("完成檢查") && line.includes("未過");
+/**
+* Read the transcripts of every session with an action serving the mainline, and their subagents', into cost
+* figures and candidates for where the work went wrong. Each transcript is read once, even when a subagent session
+* serves the mainline as well.
+*/
+function retroReport(root, mainlineId) {
+	const mainline = loadHub(root, { remotes: false }).mainlines.find((m) => m.id === mainlineId);
+	if (!mainline) throw new WriteError(`mainline ${mainlineId} not found; run "mainflow status --all" to list mainlines`);
+	const serving = loadSessions(root).sessions.filter((s) => servesMainline(s, mainlineId));
+	const read = /* @__PURE__ */ new Map();
+	const stats = (file) => {
+		let s = read.get(file);
+		if (!s) read.set(file, s = readTranscript(file));
+		return s;
+	};
+	const sessions = [];
+	const subagents = [];
+	const labels = /* @__PURE__ */ new Map();
+	const subagentFilesSeen = /* @__PURE__ */ new Set();
+	const addSubagent = (file, parent) => {
+		if (subagentFilesSeen.has(file)) return;
+		subagentFilesSeen.add(file);
+		labels.set(file, `${parent} › ${basename(file, ".jsonl")}`);
+		subagents.push({
+			...summarize(stats(file)),
+			parent,
+			...readMeta(file)
+		});
+	};
+	for (const s of [...serving].sort((a, b) => Number(Boolean(a.delegatedFrom)) - Number(Boolean(b.delegatedFrom)))) {
+		const file = s.transcript ? transcriptPath(root, s.transcript) : void 0;
+		if (s.delegatedFrom) {
+			if (file) addSubagent(file, s.delegatedFrom);
+			continue;
+		}
+		if (!file) {
+			sessions.push({
+				...summarize(emptyStats("", false)),
+				session: s.id,
+				missing: "the session records no transcript"
+			});
+			continue;
+		}
+		labels.set(file, s.id);
+		const summary = summarize(stats(file));
+		sessions.push({
+			...summary,
+			session: s.id,
+			...summary.found ? {} : { missing: `${file} does not exist` }
+		});
+		for (const sub of subagentFiles(file)) addSubagent(sub, s.id);
+	}
+	const all = [...read.values()];
+	const models = /* @__PURE__ */ new Map();
+	const total = emptyUsage();
+	for (const m of all.flatMap((t) => t.messages).filter((m) => m.model !== "<synthetic>")) {
+		const entry = models.get(m.model) ?? {
+			model: m.model,
+			calls: 0,
+			usage: emptyUsage(),
+			cost: priceOf(m.model) ? 0 : null
+		};
+		models.set(m.model, entry);
+		entry.calls += 1;
+		addUsage(entry.usage, m.usage);
+		addUsage(total, m.usage);
+		const c = messageCost(m.model, m.usage, m.speed, m.geo);
+		if (c !== null && entry.cost !== null) entry.cost += c;
+	}
+	const hooks = /* @__PURE__ */ new Map();
+	for (const h of all.flatMap((t) => t.hooks)) {
+		const entry = hooks.get(h.event) ?? {
+			event: h.event,
+			injections: 0,
+			chars: 0,
+			blocked: 0
+		};
+		hooks.set(h.event, entry);
+		entry.injections += h.injections;
+		entry.chars += h.chars;
+		entry.blocked += h.blocked;
+	}
+	const sum = (records) => {
+		const out = {};
+		for (const r of records) for (const [k, v] of Object.entries(r)) out[k] = (out[k] ?? 0) + v;
+		return out;
+	};
+	const count = (r) => Object.values(r).reduce((a, b) => a + b, 0);
+	const toolErrors = sum(all.map((t) => t.toolErrors));
+	const misfires = sum(all.map((t) => t.misfires));
+	const blocked = Object.fromEntries([...hooks.values()].filter((h) => h.blocked > 0).map((h) => [h.event, h.blocked]));
+	const reruns = all.flatMap((t) => Object.entries(t.bashRuns).filter(([, runs]) => runs > 1).map(([command, runs]) => ({
+		command,
+		runs,
+		session: labels.get(t.file) ?? t.file
+	}))).sort((a, b) => b.runs - a.runs);
+	const modelList = [...models.values()].sort((a, b) => b.calls - a.calls || a.model.localeCompare(b.model));
+	return {
+		mainline: {
+			id: mainline.id,
+			title: mainline.title,
+			status: mainline.status,
+			criteria: mainline.criteria.length,
+			tasks: mainline.tasks.length
+		},
+		versions: [...new Set(all.flatMap((t) => t.versions))].sort(),
+		unreadable: all.reduce((n, t) => n + t.unreadable, 0),
+		pricing: PRICING_SOURCE,
+		cost: {
+			total: modelList.reduce((n, m) => n + (m.cost ?? 0), 0),
+			unknownPriceModels: modelList.filter((m) => m.cost === null).map((m) => m.model),
+			cacheHitRate: cacheHitRate(total),
+			models: modelList,
+			sessions,
+			subagents,
+			hooks: [...hooks.values()].sort((a, b) => b.injections - a.injections || a.event.localeCompare(b.event))
+		},
+		precision: {
+			toolErrors: {
+				total: count(toolErrors),
+				byTool: toolErrors
+			},
+			bashReruns: {
+				total: reruns.reduce((n, r) => n + r.runs - 1, 0),
+				commands: reruns
+			},
+			misfireCandidates: {
+				total: count(misfires),
+				byEvent: misfires
+			},
+			blocked: {
+				total: count(blocked),
+				byEvent: blocked
+			},
+			gaps: all.flatMap((t) => t.gaps.map((g) => ({
+				...g,
+				session: labels.get(t.file) ?? t.file
+			}))),
+			failedChecks: mainline.tasks.flatMap((t) => (sectionText(t.body, "紀錄") ?? "").split("\n").filter(FAILED_CHECK).map((line) => ({
+				task: `${mainline.id}/${t.id}`,
+				line: line.trim()
+			})))
+		}
+	};
+}
+//#endregion
 //#region ../core/dist/migrate.js
 const drop = (o, ...keys) => keys.forEach((k) => delete o[k]);
 const dropNull = (o, ...keys) => keys.forEach((k) => o[k] === null && delete o[k]);
@@ -2597,4 +3265,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { createIssue as $, sessionBriefing as A, settleSession as B, setCriterionText as C, updateTask as D, supersedeDecision as E, loadSessions as F, matchGrants as G, transcriptPath as H, readSession as I, headerLine as J, decorateReply as K, setSessionArchived as L, addAction as M, ensureSession as N, untilState as O, handoffSession as P, createFinding as Q, setSessionInfo as R, setCriterion as S, setMainlineTitle as T, updateAction as U, startSession as V, grantScope as W, appendOps as X, mayDecorate as Y, closeIssue as Z, createTask as _, currentBranch as _t, openInApp as a, HubError as at, setArchived as b, syncHost as c, mainlineEdges as ct, setArchivedMany as d, MAINLINE_FILE as dt, planIssue as et, acceptDecision as f, TASK_FILE as ft, createMainline as g, DATA_DIR as gt, createDecision as h, readYaml as ht, hostName as i, setIssueArchived as it, turnReminder as j, duplicateClaimLines as k, migrateHub as l, linksInto as lt, addRepo as m, WriteError as mt, DEFAULT_UI_PORT as n, setFindingArchived as nt, removeHostLink as o, loadHub as ot, addHub as p, ConflictError as pt, endsWithMarker as q, caddySites as r, setFindingStatus as rt, siteBlock as s, dependencyGraph as st, APP_BUNDLE_ID as t, reopenIssue as tt, ARCHIVE_KINDS as u, refIndex as ut, dropChecklistItem as v, findHubRoot as vt, setMainlineStatus as w, setChecklistItem as x, initHub as y, worktreesOf as yt, setSessionStatus as z };
+export { appendOps as $, untilState as A, setSessionArchived as B, setCriterion as C, supersedeDecision as D, setMainlineTitle as E, ensureSession as F, transcriptPath as G, setSessionStatus as H, handoffSession as I, matchGrants as J, updateAction as K, loadSessions as L, sessionBriefing as M, turnReminder as N, undropChecklistItem as O, addAction as P, mayDecorate as Q, readSession as R, setChecklistItem as S, worktreesOf as St, setMainlineStatus as T, settleSession as U, setSessionInfo as V, startSession as W, endsWithMarker as X, decorateReply as Y, headerLine as Z, createMainline as _, WriteError as _t, openInApp as a, setFindingArchived as at, initHub as b, currentBranch as bt, syncHost as c, HubError as ct, ARCHIVE_KINDS as d, mainlineEdges as dt, closeIssue as et, setArchivedMany as f, linksInto as ft, createDecision as g, ConflictError as gt, addRepo as h, TASK_FILE as ht, hostName as i, reopenIssue as it, duplicateClaimLines as j, updateTask as k, migrateHub as l, loadHub as lt, addHub as m, MAINLINE_FILE as mt, DEFAULT_UI_PORT as n, createIssue as nt, removeHostLink as o, setFindingStatus as ot, acceptDecision as p, refIndex as pt, grantScope as q, caddySites as r, planIssue as rt, siteBlock as s, setIssueArchived as st, APP_BUNDLE_ID as t, createFinding as tt, retroReport as u, dependencyGraph as ut, createTask as v, readYaml as vt, setCriterionText as w, setArchived as x, findHubRoot as xt, dropChecklistItem as y, DATA_DIR as yt, setReminderDigest as z };