mainflow 0.28.0 → 0.29.0

package/dist/host-CeN3dvXg.js

@@ -1,3268 +0,0 @@
-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 { 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";
-//#region ../core/dist/paths.js
-const DATA_DIR = ".mainflow";
-const ENTRY_DIR = /^([mtdif]\d{3})-(.+)$/;
-const isHub = (dir) => existsSync(join(dir, DATA_DIR, "config.yaml"));
-const git = (cwd, ...args) => {
-	const result = spawnSync("git", [
-		"-C",
-		cwd,
-		...args
-	], { encoding: "utf8" });
-	return result.status === 0 ? result.stdout.trim() : "";
-};
-/** The main working tree and the current working tree of the repository containing `cwd`, or null outside git. */
-function worktreesOf(cwd) {
-	const common = git(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
-	const current = git(cwd, "rev-parse", "--show-toplevel");
-	if (!common.endsWith(`${sep}.git`) || !current) return null;
-	return {
-		main: dirname(common),
-		current
-	};
-}
-/** The branch checked out at `cwd`, or null outside git or on a detached HEAD. */
-function currentBranch(cwd) {
-	return git(cwd, "branch", "--show-current") || null;
-}
-/**
-* The hub for `cwd`: the first directory upwards holding `.mainflow/config.yaml`, except that a linked
-* worktree's checkout of a hub at the repository root resolves to the same hub in the main working tree.
-* A worktree is another checkout of the same repository, so without this every worktree would write its
-* own copy of the hub and the copies would conflict on merge. A hub below the root (a sample hub under
-* examples/, a scratch hub under tmp/) stays as found: it is data the worktree's own branch owns, and
-* mapping it would let tests and migrations in the worktree write the main tree's copy.
-*/
-function findHubRoot(cwd) {
-	let found = null;
-	for (let dir = cwd;; dir = dirname(dir)) {
-		if (isHub(dir)) {
-			found = dir;
-			break;
-		}
-		if (dirname(dir) === dir) break;
-	}
-	const trees = worktreesOf(cwd);
-	if (!trees || trees.main === trees.current) return found;
-	if (found && found !== trees.current) return found;
-	return isHub(trees.main) ? trees.main : found;
-}
-function subdirs(dir) {
-	if (!existsSync(dir)) return [];
-	return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(dir, entry.name)).sort();
-}
-/** Split a Markdown file into its YAML front matter and the body after it. */
-function splitFrontMatter(source) {
-	const match = /^---\n([\s\S]*?)\n---\n?/.exec(source);
-	if (!match) return {
-		data: null,
-		body: source
-	};
-	return {
-		data: parse$1(match[1] ?? ""),
-		body: source.slice(match[0].length)
-	};
-}
-/** Find the entry directory whose name starts with `{id}-` inside `parent`. */
-function findEntryDir(parent, id) {
-	return subdirs(parent).find((dir) => ENTRY_DIR.exec(dir.split("/").at(-1) ?? "")?.[1] === id) ?? null;
-}
-/** The next free id with the given prefix, e.g. `m003` after `m001` and `m002`. */
-function nextId(prefix, existing) {
-	const max = existing.filter((id) => id.startsWith(prefix)).map((id) => Number(id.slice(prefix.length))).reduce((a, b) => Math.max(a, b), 0);
-	if (max >= 999) throw new Error(`no ${prefix} ids left after ${prefix}999`);
-	return `${prefix}${String(max + 1).padStart(3, "0")}`;
-}
-const contentHash = (text) => createHash("sha1").update(text).digest("hex");
-/** Read a UTF-8 file, or return null when it does not exist. */
-function readText(file) {
-	return existsSync(file) ? readFileSync(file, "utf8") : null;
-}
-/** List every file below `dir`, sorted, skipping dot files. */
-function listFiles(dir) {
-	if (!existsSync(dir)) return [];
-	return readdirSync(dir, {
-		recursive: true,
-		withFileTypes: true
-	}).filter((entry) => entry.isFile() && !entry.name.startsWith(".")).map((entry) => join(entry.parentPath, entry.name)).sort();
-}
-//#endregion
-//#region ../core/dist/io.js
-var WriteError = class extends Error {};
-/** The file changed after the caller read it; the caller must reload and retry. */
-var ConflictError = class extends WriteError {};
-const LOCK_WAIT_MS = 5e3;
-const LOCK_STALE_MS = 3e4;
-const sleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-/** Run `fn` while holding the hub-wide write lock in `.mainflow/local/`. */
-function withLock(root, fn) {
-	const dir = join(root, DATA_DIR, "local");
-	mkdirSync(dir, { recursive: true });
-	const lock = join(dir, "write.lock");
-	const deadline = Date.now() + LOCK_WAIT_MS;
-	for (;;) try {
-		const fd = openSync(lock, "wx");
-		writeSync(fd, String(process.pid));
-		closeSync(fd);
-		break;
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		if (Date.now() - statSync(lock, { throwIfNoEntry: false }).mtimeMs > LOCK_STALE_MS) {
-			rmSync(lock, { force: true });
-			continue;
-		}
-		if (Date.now() > deadline) throw new WriteError(`hub is locked by another writer (${lock}); retry in a moment`);
-		sleep(50);
-	}
-	try {
-		return fn();
-	} finally {
-		rmSync(lock, { force: true });
-	}
-}
-const today = () => (/* @__PURE__ */ new Date()).toLocaleDateString("sv-SE");
-/** Local time to the minute, the form sessions, actions and decisions use: 2026-09-24T15:30. */
-const nowMinute = () => {
-	const d = /* @__PURE__ */ new Date();
-	return `${d.toLocaleDateString("sv-SE")}T${d.toTimeString().slice(0, 5)}`;
-};
-function validate(schema, data, file) {
-	const result = schema.safeParse(data);
-	if (result.success) return result.data;
-	throw new WriteError(`${file} would become invalid: ${result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
-}
-function writeAtomic(file, text) {
-	const temp = `${file}.${process.pid}.tmp`;
-	writeFileSync(temp, text);
-	renameSync(temp, file);
-}
-const toYaml = (data) => stringify(data, { lineWidth: 0 });
-function readYaml(file, schema) {
-	const text = readFileSync(file, "utf8");
-	return {
-		data: validate(schema, parse$1(text), file),
-		version: contentHash(text)
-	};
-}
-/** Read, mutate, validate and write back a YAML document under the hub lock. */
-function mutateYaml(root, file, schema, mutate, expectedVersion) {
-	return withLock(root, () => {
-		const text = readFileSync(file, "utf8");
-		if (expectedVersion && contentHash(text) !== expectedVersion) throw new ConflictError(`${file} changed since it was read; reload and retry`);
-		const data = validate(schema, parse$1(text), file);
-		mutate(data);
-		const next = validate(schema, data, file);
-		writeAtomic(file, toYaml(next));
-		return next;
-	});
-}
-const frontMatterText = (data, body) => `---\n${toYaml(data)}---\n${body}`;
-/** Read and validate the front matter of a Markdown file, with its body and content hash. */
-function readFrontMatter(file, schema) {
-	const text = readFileSync(file, "utf8");
-	const { data, body } = splitFrontMatter(text);
-	return {
-		data: validate(schema, data, file),
-		body,
-		version: contentHash(text)
-	};
-}
-/**
-* Read, mutate, validate and write back the front matter of a Markdown file. The body is kept unless
-* `mutate` returns a new one.
-*/
-function mutateFrontMatter(root, file, schema, mutate, expectedVersion) {
-	return withLock(root, () => {
-		const text = readFileSync(file, "utf8");
-		if (expectedVersion && contentHash(text) !== expectedVersion) throw new ConflictError(`${file} changed since it was read; reload and retry`);
-		const { data, body } = splitFrontMatter(text);
-		const current = validate(schema, data, file);
-		const nextBody = mutate(current, body) ?? body;
-		const next = validate(schema, current, file);
-		writeAtomic(file, frontMatterText(next, nextBody));
-		return next;
-	});
-}
-//#endregion
-//#region ../core/dist/resolve.js
-const mainlinesDir = (root) => join(root, DATA_DIR, "mainlines");
-/** The document inside each mainline and task directory: front matter for attributes, body for prose. */
-const MAINLINE_FILE = "mainline.md";
-const TASK_FILE = "task.md";
-function requireRef(input, kind) {
-	const ref = parseRef(input);
-	if (ref?.kind !== kind) throw new WriteError(`expected a ${kind} reference like ${refExample(kind)}, got "${input}"`);
-	return ref;
-}
-function mainlineDir(root, id) {
-	const dir = findEntryDir(mainlinesDir(root), id);
-	if (!dir) throw new WriteError(`mainline ${id} not found; run "mainflow status --all" to list mainlines`);
-	return dir;
-}
-function taskDir(root, mainline, task) {
-	const dir = findEntryDir(join(mainlineDir(root, mainline), "tasks"), task);
-	if (!dir) throw new WriteError(`task ${mainline}/${task} not found`);
-	return dir;
-}
-const mainlineFile = (root, id) => join(mainlineDir(root, id), MAINLINE_FILE);
-const taskFile = (root, mainline, task) => join(taskDir(root, mainline, task), TASK_FILE);
-function decisionFile(root, mainline, decision) {
-	const dir = join(mainlineDir(root, mainline), "decisions");
-	const name = existsSync(dir) ? readdirSync(dir).find((n) => n.startsWith(`${decision}-`) && n.endsWith(".md")) : void 0;
-	if (!name) throw new WriteError(`decision ${mainline}/${decision} not found`);
-	return join(dir, name);
-}
-function requireSlug(slug) {
-	if (!SLUG.test(slug)) throw new WriteError(`slug "${slug}" must be kebab-case, e.g. mainflow-rebuild`);
-}
-function requireOneOf(value, allowed, what) {
-	if (!allowed.includes(value)) throw new WriteError(`${what} "${value}" must be one of: ${allowed.join(", ")}`);
-	return value;
-}
-function readConfig(root) {
-	return readYaml(join(root, DATA_DIR, "config.yaml"), configSchema).data;
-}
-/** Entry ids (m001, t002, d003) found among the names in `dir`. */
-const idsIn = (dir) => (existsSync(dir) ? readdirSync(dir) : []).map((n) => ENTRY_DIR.exec(n)?.[1]).filter((id) => !!id);
-//#endregion
-//#region ../core/dist/refs.js
-const itemStatus = (item) => item.done ? "done" : item.dropped ? "dropped" : "open";
-/** Every reference a hub can resolve, keyed by the reference without a hub prefix. */
-function refIndex(hub) {
-	const index = /* @__PURE__ */ new Map();
-	for (const m of hub.mainlines) {
-		index.set(m.id, {
-			kind: "mainline",
-			title: m.title,
-			status: m.status,
-			mainline: m.id
-		});
-		for (const r of m.criteria) index.set(`${m.id}#${r.id}`, {
-			kind: "criterion",
-			title: r.text,
-			status: itemStatus(r),
-			mainline: m.id
-		});
-		for (const d of m.decisions) index.set(`${m.id}/${d.id}`, {
-			kind: "decision",
-			title: d.title,
-			status: d.status,
-			mainline: m.id
-		});
-		for (const t of m.tasks) {
-			index.set(`${m.id}/${t.id}`, {
-				kind: "task",
-				title: t.title,
-				status: t.status,
-				mainline: m.id
-			});
-			for (const c of t.checklist) index.set(`${m.id}/${t.id}#${c.id}`, {
-				kind: "checklistItem",
-				title: c.text,
-				status: itemStatus(c),
-				mainline: m.id
-			});
-		}
-	}
-	for (const i of hub.issues) index.set(i.id, {
-		kind: "issue",
-		title: i.title,
-		status: i.status
-	});
-	for (const f of hub.findings) index.set(f.id, {
-		kind: "finding",
-		title: f.title,
-		status: f.status
-	});
-	return index;
-}
-const isHubRoot = (dir) => existsSync(join(dir, DATA_DIR, "config.yaml"));
-/** Absolute root of a registered hub; `path` is relative to the registering hub's root. */
-const remoteRoot = (root, path) => resolve(root, path);
-/** Documents in `hub` whose links point at `hubName`'s documents; `hubName` undefined means links without a prefix. */
-function linksInto(hub, hubName) {
-	const out = [];
-	const add = (from, links) => {
-		for (const l of links ?? []) {
-			const colon = l.to.indexOf(":");
-			const prefix = colon < 0 ? void 0 : l.to.slice(0, colon);
-			const local = colon < 0 ? l.to : l.to.slice(colon + 1);
-			if (prefix === hubName || prefix === hub.config.hub && hubName === void 0) out.push({
-				to: local,
-				link: {
-					from,
-					rel: l.rel,
-					...l.note ? { note: l.note } : {}
-				}
-			});
-		}
-	};
-	for (const m of hub.mainlines) {
-		add(m.id, m.links);
-		for (const d of m.decisions) add(`${m.id}/${d.id}`, d.links);
-		for (const t of m.tasks) add(`${m.id}/${t.id}`, t.links);
-	}
-	for (const i of hub.issues) add(i.id, i.links);
-	for (const f of hub.findings) add(f.id, f.links);
-	return out;
-}
-//#endregion
-//#region ../core/dist/deps.js
-const MET = /* @__PURE__ */ new Set([
-	"done",
-	"closed",
-	"accepted",
-	"superseded",
-	"obsolete"
-]);
-const depState = (target) => !target ? "unknown" : MET.has(target.status) ? "met" : target.status === "dropped" ? "dropped" : "pending";
-function dependencyGraph(hub) {
-	const own = refIndex(hub);
-	const others = new Map((hub.remotes ?? []).flatMap((r) => r.hub ? [[r.name, refIndex(r.hub)]] : []));
-	/** A reference as this hub writes it: this hub's own prefix is dropped, another hub's is kept. */
-	const normal = (ref) => parseRef(ref)?.hub === hub.config.hub ? ref.slice(ref.indexOf(":") + 1) : ref;
-	const target = (ref) => {
-		const hubName = parseRef(ref)?.hub;
-		return hubName === void 0 ? own.get(ref) : others.get(hubName)?.get(ref.slice(ref.indexOf(":") + 1));
-	};
-	const edges = [];
-	const edge = (from, to, source, extra) => edges.push({
-		from,
-		to,
-		source,
-		state: depState(target(to)),
-		...extra
-	});
-	const links = (from, file, list) => list?.forEach((l, i) => l.rel === "depends-on" && edge(from, normal(l.to), "link", {
-		file,
-		field: `links.${i}.to`,
-		...l.note ? { note: l.note } : {}
-	}));
-	for (const m of hub.mainlines) {
-		links(m.id, m.file, m.links);
-		for (const d of m.decisions) links(`${m.id}/${d.id}`, d.file, d.links);
-		for (const t of m.tasks) {
-			links(`${m.id}/${t.id}`, t.file, t.links);
-			t.dependsOn?.forEach((dep, i) => edge(`${m.id}/${t.id}`, `${m.id}/${dep}`, "task", {
-				file: t.file,
-				field: `dependsOn.${i}`
-			}));
-		}
-	}
-	for (const d of [...hub.issues, ...hub.findings]) links(d.id, d.file, d.links);
-	for (const remote of hub.remotes ?? []) {
-		if (!remote.hub) continue;
-		for (const { to, link } of linksInto(remote.hub, hub.config.hub)) if (link.rel === "depends-on") edge(`${remote.name}:${link.from}`, to, "link", link.note ? { note: link.note } : {});
-	}
-	return {
-		edges,
-		cycles: findCycles(edges)
-	};
-}
-/** Cycles among this hub's own documents, each once, starting from its smallest reference. */
-function findCycles(edges) {
-	const next = /* @__PURE__ */ new Map();
-	for (const e of edges) if (!e.from.includes(":") && !e.to.includes(":")) next.set(e.from, [...next.get(e.from) ?? [], e.to]);
-	const state = /* @__PURE__ */ new Map();
-	const stack = [];
-	const cycles = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		state.set(node, "open");
-		stack.push(node);
-		for (const to of next.get(node) ?? []) if (state.get(to) === "open") {
-			const loop = stack.slice(stack.indexOf(to));
-			const start = loop.indexOf([...loop].sort()[0]);
-			const ordered = [...loop.slice(start), ...loop.slice(0, start)];
-			cycles.set(ordered.join(" "), [...ordered, ordered[0]]);
-		} else if (!state.has(to)) visit(to);
-		stack.pop();
-		state.set(node, "closed");
-	};
-	for (const node of [...next.keys()].sort()) if (!state.has(node)) visit(node);
-	return [...cycles.values()];
-}
-/** The mainline a reference sits in, keeping another hub's prefix; undefined for issues and findings. */
-function mainlineOf(ref) {
-	const parsed = parseRef(ref);
-	const m = parsed ? refMainline(parsed) : void 0;
-	return m && (parsed.hub ? `${parsed.hub}:${m}` : m);
-}
-/** Dependencies lifted to mainlines, for a map of how mainlines wait for one another. */
-function mainlineEdges(graph) {
-	const out = /* @__PURE__ */ new Map();
-	for (const e of graph.edges) {
-		const from = mainlineOf(e.from);
-		const to = mainlineOf(e.to);
-		if (!from || !to || from === to) continue;
-		const key = `${from} ${to}`;
-		const entry = out.get(key) ?? {
-			from,
-			to,
-			state: e.state,
-			edges: []
-		};
-		entry.edges.push(e);
-		const states = entry.edges.map((x) => x.state);
-		entry.state = [
-			"pending",
-			"unknown",
-			"dropped",
-			"met"
-		].find((s) => states.includes(s));
-		out.set(key, entry);
-	}
-	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);
-const TASK_BODY = body(TASK_SECTIONS);
-/** 建議 carries the recommendation while a decision is proposed; 決定 is filled once it is accepted. */
-const DECISION_BODY = body(DECISION_SECTIONS);
-const ISSUE_BODY = body(ISSUE_SECTIONS);
-const FINDING_BODY = body(FINDING_SECTIONS);
-/** The text under `## {heading}` up to the next H2, trimmed; null when the heading is missing. */
-function sectionText(markdown, heading) {
-	const lines = markdown.split("\n");
-	const start = lines.findIndex((l) => l.trim() === `## ${heading}`);
-	if (start === -1) return null;
-	const end = lines.findIndex((l, i) => i > start && l.startsWith("## "));
-	return lines.slice(start + 1, end === -1 ? void 0 : end).join("\n").trim();
-}
-const SKIP_WORDS = [...new Set(SURVEY_LINES.flatMap((l) => l.skip ? [l.skip] : []))];
-/** The survey lines as a writer fills them in, one `- {label}：{what it holds}` per source. */
-const SURVEY_TEMPLATE = SURVEY_LINES.map((l) => `- ${l.label}：{${l.holds}}${l.skip ? `，或「${l.skip}：{理由}」` : ""}`).join("\n");
-/**
-* What is missing from a mainline's 現況查核, one message per source; empty when every source has a line.
-* A line is `- {label}：{text}`. The text must not be blank, a source without `skip` must really be checked,
-* and a checked line must contain what the source `requires`.
-*/
-function surveyGaps(mainlineBody) {
-	const text = sectionText(mainlineBody, SURVEY_SECTION);
-	if (text === null) return [`"## ${SURVEY_SECTION}" is missing`];
-	const lines = text.split("\n").map((l) => l.trim());
-	return SURVEY_LINES.flatMap((source) => {
-		const prefix = `- ${source.label}：`;
-		const content = lines.find((l) => l.startsWith(prefix))?.slice(prefix.length).trim();
-		if (!content) return [`"- ${source.label}：" needs what was found`];
-		const skipped = SKIP_WORDS.find((w) => content.startsWith(`${w}：`));
-		if (skipped) {
-			if (skipped !== source.skip) return [`"- ${source.label}：" cannot be ${skipped}; this source is always checked`];
-			if (!content.slice(skipped.length + 1).trim()) return [`"- ${source.label}：${skipped}：" needs a reason`];
-			return [];
-		}
-		if (source.requires && !content.includes(source.requires)) return [`"- ${source.label}：" needs ${source.requires}{…} for where it ran`];
-		return [];
-	});
-}
-/** Put `text` under `## {heading}`, replacing what was there; appends the section when it is missing. */
-function withSection(markdown, heading, text) {
-	const lines = markdown.split("\n");
-	const start = lines.findIndex((l) => l.trim() === `## ${heading}`);
-	if (start === -1) return `${markdown.trimEnd()}\n\n## ${heading}\n\n${text}\n`;
-	const found = lines.findIndex((l, i) => i > start && l.startsWith("## "));
-	const end = found === -1 ? lines.length : found;
-	const rest = lines.slice(end);
-	return [
-		...lines.slice(0, start + 1),
-		"",
-		text,
-		...rest.length ? ["", ...rest] : [""]
-	].join("\n");
-}
-//#endregion
-//#region ../core/dist/load.js
-function loadHub(root, options = {}) {
-	const problems = [];
-	const warnings = [];
-	/** References checked once everything they may point at is loaded */
-	const pending = [];
-	/** Documents whose file is there but failed to load; references into them are not reported twice */
-	const unreadable = /* @__PURE__ */ new Set();
-	const idOf = (path) => ENTRY_DIR.exec(path.split("/").at(-1)?.replace(/\.md$/, "") ?? "")?.[1];
-	const dataDir = join(root, DATA_DIR);
-	const rel = (path) => relative(root, path);
-	const read = (file, schema, raw) => {
-		let data = raw;
-		if (data === void 0) try {
-			data = parse$1(readText(file) ?? "");
-		} catch (error) {
-			problems.push({
-				file: rel(file),
-				field: "",
-				message: `cannot parse YAML: ${error.message}`
-			});
-			return null;
-		}
-		const result = schema.safeParse(data);
-		if (result.success) return result.data;
-		for (const issue of result.error.issues) problems.push({
-			file: rel(file),
-			field: issue.path.join("."),
-			message: issue.message
-		});
-		return null;
-	};
-	const checkDirName = (dir, id) => {
-		const match = ENTRY_DIR.exec(dir.split("/").at(-1) ?? "");
-		if (!match || match[1] !== id || !SLUG.test(match[2] ?? "")) problems.push({
-			file: rel(dir),
-			field: "",
-			message: `directory name must be "${id}-{slug}" in kebab-case`
-		});
-	};
-	const config = read(join(dataDir, "config.yaml"), configSchema);
-	if (!config) throw new HubError("invalid config.yaml", problems);
-	if (config.formatVersion !== 2) throw new HubError(config.formatVersion < 2 ? `data format version ${config.formatVersion} is older than this CLI's (2); run "mainflow migrate --dry-run" to preview the conversion, then "mainflow migrate"` : `data format version ${config.formatVersion} is newer than this CLI supports (2); install the matching mainflow version in this hub`, problems);
-	problems.push(...repoPathProblems(root, config));
-	const categories = /* @__PURE__ */ new Set([...DEFAULT_CATEGORIES, ...config.categories ?? []]);
-	/** Read a Markdown document's front matter against `schema`, with the attributes every document shares. */
-	const readDocument = (file, schema) => {
-		const text = readText(file);
-		if (text === null) {
-			problems.push({
-				file: rel(file),
-				field: "",
-				message: "file is missing"
-			});
-			return null;
-		}
-		let split;
-		try {
-			split = splitFrontMatter(text);
-		} catch (error) {
-			problems.push({
-				file: rel(file),
-				field: "",
-				message: `cannot parse front matter: ${error.message}`
-			});
-			return null;
-		}
-		const doc = read(file, schema, split.data);
-		if (!doc) return null;
-		if (doc.category && !categories.has(doc.category)) problems.push({
-			file: rel(file),
-			field: "category",
-			message: `category "${doc.category}" is not one of ${[...categories].join(", ")}; add it under categories in config.yaml or pick one of these`
-		});
-		const updated = new Date(statSync(file).mtimeMs).toLocaleDateString("sv-SE");
-		return {
-			...doc,
-			file: rel(file),
-			body: split.body,
-			version: contentHash(text),
-			updated
-		};
-	};
-	const mainlines = [];
-	for (const mainlineDir of subdirs(join(dataDir, "mainlines"))) {
-		const mainline = readDocument(join(mainlineDir, MAINLINE_FILE), mainlineSchema);
-		if (!mainline) {
-			const id = idOf(mainlineDir);
-			if (id) unreadable.add(id);
-			continue;
-		}
-		checkDirName(mainlineDir, mainline.id);
-		problems.push(...grantProblems(mainline, config));
-		const decisions = [];
-		const decisionsDir = join(mainlineDir, "decisions");
-		for (const name of existsSync(decisionsDir) ? readdirSync(decisionsDir).filter((n) => n.endsWith(".md")).sort() : []) {
-			const file = join(decisionsDir, name);
-			const decision = readDocument(file, decisionSchema);
-			if (!decision) unreadable.add(`${mainline.id}/${idOf(file)}`);
-			if (decision) {
-				checkDirName(file.replace(/\.md$/, ""), decision.id);
-				decisions.push(decision);
-			}
-		}
-		const tasks = [];
-		for (const taskDir of subdirs(join(mainlineDir, "tasks"))) {
-			const task = readDocument(join(taskDir, TASK_FILE), taskSchema);
-			if (!task) {
-				unreadable.add(`${mainline.id}/${idOf(taskDir)}`);
-				continue;
-			}
-			checkDirName(taskDir, task.id);
-			if (task.repo && !(task.repo in config.repos)) problems.push({
-				file: task.file,
-				field: "repo",
-				message: `repo "${task.repo}" is not listed in config.yaml`
-			});
-			tasks.push({
-				...task,
-				dir: rel(taskDir),
-				artifacts: listFiles(join(taskDir, "artifacts")).map(rel)
-			});
-		}
-		problems.push(...contentGaps(mainline, tasks));
-		const taskIds = new Set(tasks.map((t) => t.id));
-		const criterionIds = new Set(mainline.criteria.map((c) => c.id));
-		const itemRefs = new Set(tasks.flatMap((t) => t.checklist.map((c) => `${mainline.id}/${t.id}#${c.id}`)));
-		for (const task of tasks) {
-			if (task.parent && !taskIds.has(task.parent)) problems.push({
-				file: task.file,
-				field: "parent",
-				message: `parent task ${task.parent} does not exist`
-			});
-			task.dependsOn?.forEach((dep, i) => {
-				if (!taskIds.has(dep)) problems.push({
-					file: task.file,
-					field: `dependsOn.${i}`,
-					message: `task ${dep} does not exist`
-				});
-			});
-			task.checklist.forEach((item, i) => {
-				item.serves?.forEach((r, j) => {
-					if (!criterionIds.has(r)) problems.push({
-						file: task.file,
-						field: `checklist.${i}.serves.${j}`,
-						message: `criterion ${mainline.id}#${r} does not exist`
-					});
-				});
-			});
-		}
-		for (const decision of decisions) decision.affects?.forEach((ref, i) => {
-			if (!(ref.includes("#") ? itemRefs.has(ref) : taskIds.has(ref.split("/")[1] ?? "") && ref.startsWith(`${mainline.id}/`))) problems.push({
-				file: decision.file,
-				field: `affects.${i}`,
-				message: `${ref} is not a task or checklist item of ${mainline.id}`
-			});
-		});
-		mainlines.push({
-			...mainline,
-			dir: rel(mainlineDir),
-			artifacts: listFiles(join(mainlineDir, "artifacts")).map(rel),
-			views: listFiles(join(mainlineDir, "views")).map(rel),
-			decisions,
-			tasks
-		});
-	}
-	const hubDocs = (dir, schema) => (existsSync(dir) ? readdirSync(dir).filter((n) => n.endsWith(".md")).sort() : []).flatMap((name) => {
-		const file = join(dir, name);
-		const doc = readDocument(file, schema);
-		if (!doc) {
-			const id = idOf(file);
-			if (id) unreadable.add(id);
-			return [];
-		}
-		checkDirName(file.replace(/\.md$/, ""), doc.id);
-		return [doc];
-	});
-	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`
-		});
-		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");
-	for (const name of existsSync(opsPath) ? readdirSync(opsPath).filter((n) => n.endsWith(".log")).sort() : []) readFileSync(join(opsPath, name), "utf8").split("\n").forEach((line, index) => {
-		if (!line.trim()) return;
-		const entry = parseOpsLine(line);
-		if (entry?.ref) pending.push({
-			ref: entry.ref,
-			file: rel(join(opsPath, name)),
-			field: `line ${index + 1}`
-		});
-		if (entry) ops.push(entry);
-		else problems.push({
-			file: rel(join(opsPath, name)),
-			field: `line ${index + 1}`,
-			message: "expected \"YYYY-MM-DDTHH:mm | target | operation | result [| ref]\""
-		});
-	});
-	const remotes = options.remotes === false ? [] : loadRemotes(root, config, problems, warnings);
-	checkReferences({
-		config,
-		mainlines,
-		issues: hubIssues,
-		findings,
-		remotes,
-		pending,
-		unreadable,
-		problems
-	});
-	const deps = dependencyGraph({
-		config,
-		mainlines,
-		issues: hubIssues,
-		findings,
-		remotes
-	});
-	for (const cycle of deps.cycles) {
-		const first = deps.edges.find((e) => e.from === cycle[0] && e.to === cycle[1]);
-		problems.push({
-			file: first.file,
-			field: first.field,
-			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,
-		mainlines,
-		issues: hubIssues,
-		findings,
-		ops,
-		problems,
-		warnings,
-		remotes
-	};
-}
-/** Load every hub registered in config.yaml, read-only and without its own remotes. */
-function loadRemotes(root, config, problems, warnings) {
-	const file = `${DATA_DIR}/config.yaml`;
-	return Object.entries(config.hubs ?? {}).map(([name, path]) => {
-		const remote = {
-			name,
-			path,
-			root: remoteRoot(root, path)
-		};
-		if (name === config.hub) {
-			problems.push({
-				file,
-				field: `hubs.${name}`,
-				message: `"${name}" is this hub's own name; references without a prefix already point here`
-			});
-			return {
-				...remote,
-				unavailable: "this hub"
-			};
-		}
-		if (!isHubRoot(remote.root)) {
-			warnings.push({
-				file,
-				field: `hubs.${name}`,
-				message: `hub "${name}" is not at ${path} on this machine; references into it are not checked`
-			});
-			return {
-				...remote,
-				unavailable: `not found at ${path}`
-			};
-		}
-		try {
-			const hub = loadHub(remote.root, { remotes: false });
-			if (hub.config.hub !== name) {
-				problems.push({
-					file,
-					field: `hubs.${name}`,
-					message: `${path} holds hub "${hub.config.hub}", not "${name}"; register it under its own name`
-				});
-				return {
-					...remote,
-					unavailable: `holds hub "${hub.config.hub}"`
-				};
-			}
-			return {
-				...remote,
-				hub
-			};
-		} catch (error) {
-			warnings.push({
-				file,
-				field: `hubs.${name}`,
-				message: `hub "${name}" at ${path} cannot be loaded: ${error.message}`
-			});
-			return {
-				...remote,
-				unavailable: error.message
-			};
-		}
-	});
-}
-/**
-* Every reference in a document must point at something that exists: in this hub, or in a registered
-* hub that is on this machine. A reference into a registered hub that is missing here is left unchecked,
-* since another machine may not keep every hub; the missing hub itself is reported once as a warning.
-* Links are for relations across mainlines; inside one mainline, parent, dependsOn and affects say it.
-*/
-function checkReferences(input) {
-	const { config, mainlines, issues, findings, remotes, pending, unreadable, problems } = input;
-	/** A target inside a document that failed to load: its schema problem is already reported. */
-	const inUnreadable = (target) => [
-		target,
-		target.split(/[#/]/)[0],
-		target.split("#")[0]
-	].some((t) => unreadable.has(t));
-	const local = refIndex({
-		mainlines,
-		issues,
-		findings
-	});
-	const remoteIndex = new Map(remotes.map((r) => [r.name, r.hub ? refIndex(r.hub) : null]));
-	/** The document's own mainline, when it sits in one; links may not point back into it. */
-	const add = (file, doc, self, mainline) => {
-		if (doc.origin) pending.push({
-			ref: doc.origin,
-			file,
-			field: "origin"
-		});
-		doc.links?.forEach((link, i) => {
-			pending.push({
-				ref: link.to,
-				file,
-				field: `links.${i}.to`
-			});
-			const parsed = parseRef(link.to);
-			const here = parsed && (parsed.hub === void 0 || parsed.hub === config.hub);
-			if (!parsed || !here) return;
-			if (link.to.slice(link.to.indexOf(":") + 1) === self) problems.push({
-				file,
-				field: `links.${i}.to`,
-				message: "a document cannot link to itself"
-			});
-			else if (mainline && refMainline(parsed) === mainline) problems.push({
-				file,
-				field: `links.${i}.to`,
-				message: `${link.to} is inside ${mainline}; links are for other mainlines, so use parent, dependsOn or affects within one`
-			});
-		});
-	};
-	const items = (file, field, list) => list.forEach((item, i) => item.supersededBy && pending.push({
-		ref: item.supersededBy,
-		file,
-		field: `${field}.${i}.supersededBy`
-	}));
-	for (const m of mainlines) {
-		add(m.file, m, m.id, m.id);
-		items(m.file, "criteria", m.criteria);
-		for (const d of m.decisions) add(d.file, d, `${m.id}/${d.id}`, m.id);
-		for (const t of m.tasks) {
-			add(t.file, t, `${m.id}/${t.id}`, m.id);
-			items(t.file, "checklist", t.checklist);
-			const waiting = waitingForRef(t.blockedBy?.waitingFor);
-			if (waiting) pending.push({
-				ref: waiting,
-				file: t.file,
-				field: "blockedBy.waitingFor"
-			});
-		}
-	}
-	for (const i of issues) add(i.file, i, i.id);
-	for (const f of findings) add(f.file, f, f.id);
-	for (const p of pending) {
-		const parsed = parseRef(p.ref);
-		if (!parsed) continue;
-		const target = p.ref.slice(p.ref.indexOf(":") + 1);
-		if (parsed.hub === void 0 || parsed.hub === config.hub) {
-			if (!local.has(target) && !inUnreadable(target)) problems.push({
-				file: p.file,
-				field: p.field,
-				message: `${p.ref} does not exist in this hub`
-			});
-			continue;
-		}
-		if (!remoteIndex.has(parsed.hub)) {
-			problems.push({
-				file: p.file,
-				field: p.field,
-				message: `hub "${parsed.hub}" is not registered; run "mainflow hub add ${parsed.hub} <path>"`
-			});
-			continue;
-		}
-		const index = remoteIndex.get(parsed.hub);
-		if (index && !index.has(target)) problems.push({
-			file: p.file,
-			field: p.field,
-			message: `${p.ref} does not exist in hub "${parsed.hub}"`
-		});
-	}
-}
-/**
-* A listed repository counts as part of the hub, so the PreToolUse hook lets grants act inside it. A path that
-* resolves to / or to a directory above the hub would put everything under it in scope. A path that does not
-* exist is fine: another machine may not have cloned that repository yet.
-*/
-function repoPathProblems(root, config) {
-	const real = (path) => {
-		try {
-			return realpathSync(path);
-		} catch {
-			return null;
-		}
-	};
-	const hub = real(root) ?? root;
-	return Object.entries(config.repos).flatMap(([name, path]) => {
-		const dir = real(resolve(root, path));
-		if (dir === null) return [];
-		const problem = (message) => [{
-			file: `${DATA_DIR}/config.yaml`,
-			field: `repos.${name}`,
-			message
-		}];
-		if (dir === parse(dir).root) return problem(`"${path}" resolves to the file system root; list the repository's own directory`);
-		if (hub.startsWith(dir.endsWith(sep) ? dir : dir + sep)) return problem(`"${path}" resolves to ${dir}, above the hub; list the repository's own directory`);
-		return [];
-	});
-}
-/**
-* What the schema cannot see about a mainline's grants: ids must be unique, since the file is edited directly,
-* and a target that names a repository must name one listed in config.yaml.
-*/
-function grantProblems(mainline, config) {
-	const problems = [];
-	const seen = /* @__PURE__ */ new Set();
-	mainline.grants?.forEach((grant, i) => {
-		if (seen.has(grant.id)) problems.push({
-			file: mainline.file,
-			field: `grants.${i}.id`,
-			message: `${grant.id} is used twice; give it the next free id`
-		});
-		seen.add(grant.id);
-		const parsed = parseGrantTarget(grant.action, grant.target);
-		const repo = parsed.ok ? grantRepo(parsed.target) : void 0;
-		if (repo !== void 0 && !(repo in config.repos)) problems.push({
-			file: mainline.file,
-			field: `grants.${i}.target`,
-			message: `repo "${repo}" is not listed in config.yaml; use one of ${Object.keys(config.repos).join(", ") || "(none registered)"}`
-		});
-	});
-	return problems;
-}
-const isOpen$2 = (kind, status) => !CLOSED_STATUS[kind].includes(status);
-/**
-* What a reader without the conversation needs to pick the work up: an open mainline with tasks says what
-* was checked before they were written, every open task says what it is for and when it is done, and
-* every open criterion or item says what has to be true to check it. Closed
-* entries are skipped, because their evidence already says what was done. Ids must also be unique within
-* a list, since the files are edited directly and nothing else allocates them.
-*/
-function contentGaps(mainline, tasks) {
-	const gaps = [];
-	const list = (file, field, items, open) => {
-		const seen = /* @__PURE__ */ new Set();
-		items.forEach((item, i) => {
-			if (seen.has(item.id)) gaps.push({
-				file,
-				field: `${field}.${i}.id`,
-				message: `${item.id} is used twice; give it the next free id`
-			});
-			seen.add(item.id);
-			if (open && !item.done && !item.dropped && !item.doneWhen?.trim()) gaps.push({
-				file,
-				field: `${field}.${i}.doneWhen`,
-				message: `${item.id} is open and needs doneWhen: what has to be true to check it`
-			});
-		});
-	};
-	const mainlineOpen = isOpen$2("mainline", mainline.status);
-	list(mainline.file, "criteria", mainline.criteria, mainlineOpen);
-	if (mainlineOpen && tasks.length > 0) for (const message of surveyGaps(mainline.body)) gaps.push({
-		file: mainline.file,
-		field: `## ${SURVEY_SECTION}`,
-		message
-	});
-	for (const task of tasks) {
-		const open = mainlineOpen && isOpen$2("task", task.status);
-		list(task.file, "checklist", task.checklist, open);
-		if (!open) continue;
-		for (const section of TASK_REQUIRED_SECTIONS) if (!sectionText(task.body, section)) gaps.push({
-			file: task.file,
-			field: `## ${section}`,
-			message: `the task is open and needs text under "## ${section}"`
-		});
-	}
-	return gaps;
-}
-var HubError = class extends Error {
-	problems;
-	constructor(message, problems) {
-		super(message);
-		this.problems = problems;
-	}
-};
-//#endregion
-//#region ../core/dist/hub-items.js
-const issuesDir = (root) => join(root, DATA_DIR, "issues");
-const findingsDir = (root) => join(root, DATA_DIR, "findings");
-const opsDir = (root) => join(root, DATA_DIR, "ops");
-function entryFile(dir, id, what) {
-	const name = existsSync(dir) ? readdirSync(dir).find((n) => n.startsWith(`${id}-`) && n.endsWith(".md")) : void 0;
-	if (!name) throw new WriteError(`${what} ${id} not found`);
-	return join(dir, name);
-}
-/**
-* Any reference the schema accepts must also point at something that exists. A reference into another
-* hub only needs that hub registered here; check verifies the target when that hub is on this machine.
-*/
-function requireExisting(root, ref) {
-	const parsed = parseRef(ref);
-	if (!parsed) throw new WriteError(`"${ref}" is not a reference like ${REF_EXAMPLES}`);
-	const config = readConfig(root);
-	if (parsed.hub !== void 0 && parsed.hub !== config.hub) {
-		if (!config.hubs?.[parsed.hub]) throw new WriteError(`hub "${parsed.hub}" is not registered; run "mainflow hub add ${parsed.hub} <path>" first`);
-		return;
-	}
-	switch (parsed.kind) {
-		case "issue":
-			entryFile(issuesDir(root), parsed.issue, "issue");
-			return;
-		case "finding":
-			entryFile(findingsDir(root), parsed.finding, "finding");
-			return;
-		default:
-			mainlineDir(root, parsed.mainline);
-			if ("task" in parsed) taskDir(root, parsed.mainline, parsed.task);
-			if (parsed.kind === "decision") decisionFile(root, parsed.mainline, parsed.decision);
-	}
-}
-function createIssue(root, input) {
-	requireSlug(input.slug);
-	if (input.origin) requireExisting(root, input.origin);
-	return withLock(root, () => {
-		const dir = issuesDir(root);
-		mkdirSync(dir, { recursive: true });
-		const id = nextId("i", idsIn(dir));
-		const issue = validate(issueSchema, {
-			id,
-			title: input.title,
-			status: "open",
-			created: today(),
-			...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));
-		return {
-			id,
-			file
-		};
-	});
-}
-/** Schedule an issue into the task that will carry it out. */
-function planIssue(root, id, taskRef, expectedVersion) {
-	const ref = requireRef(taskRef, "task");
-	taskDir(root, ref.mainline, ref.task);
-	return mutateFrontMatter(root, entryFile(issuesDir(root), id, "issue"), issueSchema, (i) => {
-		i.status = "planned";
-		i.plannedIn = taskRef;
-	}, expectedVersion);
-}
-function closeIssue(root, id, resolution, expectedVersion) {
-	if (!resolution) throw new WriteError(`closing ${id} needs what closed it, e.g. --by "mainflow@3fdd5ac" or --by "不再需要"`);
-	return mutateFrontMatter(root, entryFile(issuesDir(root), id, "issue"), issueSchema, (i) => {
-		i.status = "closed";
-		i.resolution = resolution;
-		i.closedAt ??= today();
-	}, expectedVersion);
-}
-function reopenIssue(root, id, expectedVersion) {
-	return mutateFrontMatter(root, entryFile(issuesDir(root), id, "issue"), issueSchema, (i) => {
-		i.status = "open";
-		delete i.plannedIn;
-		delete i.resolution;
-		delete i.closedAt;
-	}, expectedVersion);
-}
-/** Archive or unarchive an issue; the status stays as it is, so a closed issue is visible until archived. */
-function setIssueArchived(root, id, archived, expectedVersion) {
-	return mutateFrontMatter(root, entryFile(issuesDir(root), id, "issue"), issueSchema, (i) => {
-		if (archived) i.archivedAt ??= today();
-		else delete i.archivedAt;
-	}, expectedVersion);
-}
-function createFinding(root, input) {
-	requireSlug(input.slug);
-	if (input.origin) requireExisting(root, input.origin);
-	return withLock(root, () => {
-		const dir = findingsDir(root);
-		mkdirSync(dir, { recursive: true });
-		const id = nextId("f", idsIn(dir));
-		const finding = validate(findingSchema, {
-			id,
-			title: input.title,
-			status: "valid",
-			created: today(),
-			...input.origin ? { origin: input.origin } : {},
-			...input.labels?.length ? { labels: input.labels } : {}
-		}, "finding");
-		const file = join(dir, `${id}-${input.slug}.md`);
-		writeAtomic(file, frontMatterText(finding, FINDING_BODY));
-		return {
-			id,
-			file
-		};
-	});
-}
-function setFindingStatus(root, id, status, expectedVersion) {
-	const value = requireOneOf(status, FINDING_STATUS, "finding status");
-	return mutateFrontMatter(root, entryFile(findingsDir(root), id, "finding"), findingSchema, (f) => {
-		f.status = value;
-		if (value === "obsolete") f.closedAt ??= today();
-		else delete f.closedAt;
-	}, expectedVersion);
-}
-/** Archive or unarchive a finding; the status stays as it is, so an obsolete finding is visible until archived. */
-function setFindingArchived(root, id, archived, expectedVersion) {
-	return mutateFrontMatter(root, entryFile(findingsDir(root), id, "finding"), findingSchema, (f) => {
-		if (archived) f.archivedAt ??= today();
-		else delete f.archivedAt;
-	}, expectedVersion);
-}
-/** Append one external operation to ops/{YYYY-MM}.log; the log is never rewritten. */
-function appendOps(root, input) {
-	if (input.ref) requireExisting(root, input.ref);
-	const entry = validate(opsEntrySchema, {
-		...input,
-		at: input.at ?? nowMinute()
-	}, "ops entry");
-	for (const field of [
-		"target",
-		"operation",
-		"result"
-	]) if (entry[field].includes(" | ")) throw new WriteError(`${field} cannot contain " | ", the ops log's separator`);
-	return withLock(root, () => {
-		mkdirSync(opsDir(root), { recursive: true });
-		appendFileSync(join(opsDir(root), `${entry.at.slice(0, 7)}.log`), `${formatOpsEntry(entry)}\n`);
-		return entry;
-	});
-}
-/** Where the hub's interface shows a reference; null for kinds it has no page or panel for. */
-function pathOf(ref, target) {
-	const [m, child] = ref.split("/");
-	switch (target.kind) {
-		case "mainline": return `/mainlines/${m}`;
-		case "task": return `/mainlines/${m}/tasks/${child}`;
-		case "decision": return `/mainlines/${m}/decisions/${child}`;
-		case "issue": return `/issues?peek=${ref}`;
-		case "finding": return `/findings?peek=${ref}`;
-		default: return null;
-	}
-}
-const sessionPath = (id) => `/sessions/${id}`;
-/** Fenced blocks, inline code, markdown links and bare URLs: text inside them is left as written. */
-const PROTECTED = /(```[\s\S]*?(?:```|$)|`[^`\n]*`|\[[^\]\n]*\]\([^)\n]*\)|https?:\/\/\S+)/;
-/** A file under a mainline directory, or a reference to a mainline, task, decision, issue or finding. */
-const MENTION = /\.mainflow\/mainlines\/(m\d{3})-[\w-]+\/([^\s`'")\]]+\.\w+)|(?<![\w/#.[-])(m\d{3}(?:\/[td]\d{3})?|[if]\d{3})(?![\w\]])/g;
-/** Links for the references and mainline files the text mentions; references the hub does not have stay as text. */
-function linkMentions(text, context) {
-	const index = refIndex(context.hub);
-	return text.split(PROTECTED).map((part, i) => i % 2 === 1 ? part : part.replace(MENTION, (all, m, file, ref) => {
-		if (m && file) return index.has(m) ? `[${m}/${file}](${context.link(`/mainlines/${m}/files/${file}`)})` : all;
-		const target = ref ? index.get(ref) : void 0;
-		const path = ref && target ? pathOf(ref, target) : null;
-		return path ? `[${ref}](${context.link(path)})` : all;
-	})).join("");
-}
-/** `▸ m001 title › t001 title › a001 do` for the given ids, each linked; titles come from the hub and the session. */
-function headerLineFor(ids, context) {
-	const index = refIndex(context.hub);
-	const parts = [];
-	if (ids.mainline) {
-		parts.push(`[${ids.mainline}](${context.link(`/mainlines/${ids.mainline}`)}) ${index.get(ids.mainline)?.title ?? ""}`.trimEnd());
-		if (ids.task) {
-			const ref = `${ids.mainline}/${ids.task}`;
-			parts.push(`[${ids.task}](${context.link(`/mainlines/${ids.mainline}/tasks/${ids.task}`)}) ${index.get(ref)?.title ?? ""}`.trimEnd());
-		}
-	}
-	const action = context.session?.actions.find((a) => a.id === ids.action);
-	parts.push(context.session ? `[${ids.action}](${context.link(sessionPath(context.session.id))}) ${action?.do ?? ""}`.trimEnd() : ids.action);
-	return `▸ ${parts.join(" › ")}`;
-}
-/** The ids of the session's action in progress; null when there is none. */
-function currentIds(session) {
-	const action = session?.actions.find((a) => a.status === "doing");
-	if (!action) return null;
-	const served = action.serves.map((s) => parseRef(s)).find((r) => r !== null);
-	if (served && "mainline" in served) return {
-		mainline: served.mainline,
-		task: "task" in served ? served.task : void 0,
-		action: action.id
-	};
-	return { action: action.id };
-}
-/** The current action line for a bare marker; null when the session has no action in progress. */
-function currentActionLine(context) {
-	const ids = currentIds(context.session);
-	return ids ? headerLineFor(ids, context) : null;
-}
-/** The header line the model writes at the end of a turn, e.g. `▸ m001/t001 · a001`; null without an action in progress. */
-function headerLine(session) {
-	const ids = currentIds(session);
-	if (!ids) return null;
-	const where = ids.mainline ? ids.task ? `${ids.mainline}/${ids.task}` : ids.mainline : null;
-	return `▸ ${where ? `${where} · ` : ""}${ids.action}`;
-}
-/** The ids in a header line the model wrote, or null for a bare marker or a line that does not parse. */
-const WRITTEN = new RegExp(`^\\s*▸\\s+(?:(m\\d{3})(?:\\/(t\\d{3}))?\\s*·\\s*)?(a\\d{3})\\s*$`);
-function parseHeader(line) {
-	const m = WRITTEN.exec(line);
-	return m ? {
-		mainline: m[1],
-		task: m[2],
-		action: m[3]
-	} : null;
-}
-/** A line that is the header: the marker alone, or the marker followed by the ids the model copied. */
-const HEADER = new RegExp(`^[ \\t]*▸(?:[ \\t].*)?$`);
-/** The last non-empty line, if it is the header line. */
-const lastHeader = (text) => {
-	const last = text.trimEnd().split("\n").at(-1) ?? "";
-	return HEADER.test(last) ? last : null;
-};
-/** Whether a message ends with the header line, as the turn's last message should. */
-const endsWithMarker = (text) => lastHeader(text) !== null;
-/**
-* The text to display for a piece of a reply: mentions linked, and a trailing header line replaced with the
-* mainline › task › action it names, titles and links included. A bare marker names the session's action in
-* progress and is dropped without one. Returns the input unchanged when there is nothing to do.
-*/
-function decorateReply(text, context) {
-	const header = lastHeader(text);
-	if (header === null) return linkMentions(text, context);
-	const body = linkMentions(text.trimEnd().slice(0, -header.length).trimEnd(), context);
-	const written = parseHeader(header);
-	const line = written ? headerLineFor(written, context) : header.trim() === "▸" ? currentActionLine(context) : linkMentions(header.trim(), context);
-	return line ? `${body}\n\n${line}\n` : `${body}\n`;
-}
-/** Cheap test for text that decorateReply could change, so a display hook can skip loading the hub. */
-const mayDecorate = (text) => /m\d{3}|[if]\d{3}|\.mainflow\/mainlines/.test(text) || endsWithMarker(text);
-//#endregion
-//#region ../core/dist/grants.js
-/** Mainline statuses whose grants apply. */
-const GRANTING_STATUS = ["active", "planning"];
-/**
-* The grants in effect for a session. Reading a mainline that is missing or invalid throws, so a caller that
-* must fail closed catches it and asks.
-*/
-function grantScope(root, session) {
-	if (!session) return {
-		ok: false,
-		reason: "這場會話沒有 mainflow 紀錄"
-	};
-	const doing = session.actions.filter((a) => a.status === "doing");
-	if (doing.length === 0) return {
-		ok: false,
-		reason: `${session.id} 沒有進行中的行動`
-	};
-	if (doing.length > 1) return {
-		ok: false,
-		reason: `${session.id} 同時有 ${doing.length} 個進行中的行動（${doing.map((a) => a.id).join("、")}），分不出授權範圍`
-	};
-	const action = doing[0];
-	const mainlineOf = (ref) => {
-		const parsed = parseRef(ref);
-		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 項目或解決條件`
-	};
-	const grants = [];
-	const served = {};
-	const closed = [];
-	for (const id of mainlines) {
-		const mainline = readFrontMatter(mainlineFile(root, id), mainlineSchema).data;
-		if (!GRANTING_STATUS.includes(mainline.status)) {
-			closed.push(`${id} 是 ${mainline.status}`);
-			continue;
-		}
-		served[id] = action.serves.find((ref) => mainlineOf(ref) === id);
-		for (const grant of mainline.grants ?? []) grants.push({
-			mainline: id,
-			grant,
-			ref: `${id}#${grant.id}`
-		});
-	}
-	if (Object.keys(served).length === 0) return {
-		ok: false,
-		reason: `${action.id} 服務的主脈絡已不在進行中（${closed.join("、")}），授權不再生效`
-	};
-	return {
-		ok: true,
-		scope: {
-			action,
-			grants,
-			served
-		}
-	};
-}
-/** Every request must be covered by some grant in scope; the first one that is not is named in the reason. */
-function matchGrants(scope, requests) {
-	const matches = [];
-	for (const request of requests) {
-		const grant = scope.grants.find((g) => {
-			const parsed = parseGrantTarget(g.grant.action, g.grant.target);
-			return parsed.ok && grantCovers(parsed.target, request);
-		});
-		if (!grant) return {
-			ok: false,
-			reason: `${Object.keys(scope.served).join("、")} 沒有涵蓋 ${describeRequest(request)} 的授權`
-		};
-		matches.push({
-			request,
-			grant
-		});
-	}
-	return {
-		ok: true,
-		matches
-	};
-}
-/**
-* One line per grant in effect for the session, for the briefing and the per-turn reminder, with the fixed form
-* the hook allows for it; empty when the session has none or they cannot be read, since a briefing must not fail
-* on them.
-*/
-function grantLines(root, session) {
-	try {
-		const result = grantScope(root, session);
-		if (!result.ok) return [];
-		return result.scope.grants.map((g) => {
-			const parsed = parseGrantTarget(g.grant.action, g.grant.target);
-			const form = parsed.ok ? grantForm(parsed.target) : void 0;
-			return `- ${g.ref} ${g.grant.action} ${g.grant.target}${form ? `：${form}` : ""}`;
-		});
-	} catch {
-		return [];
-	}
-}
-//#endregion
-//#region ../core/dist/sessions.js
-const sessionsDir = (root) => join(root, DATA_DIR, "local", "sessions");
-const sessionFile = (root, id) => join(sessionsDir(root), `${id}.yaml`);
-/** Read every session under `.mainflow/local/sessions/`; sessions are local and never version-controlled. */
-function loadSessions(root) {
-	const dir = sessionsDir(root);
-	const sessions = [];
-	const problems = [];
-	let names = [];
-	try {
-		names = readdirSync(dir).filter((n) => n.endsWith(".yaml")).sort();
-	} catch {
-		return {
-			sessions,
-			problems
-		};
-	}
-	for (const name of names) {
-		const file = join(dir, name);
-		let data;
-		try {
-			data = parse$1(readText(file) ?? "");
-		} catch (error) {
-			problems.push({
-				file: relative(root, file),
-				field: "",
-				message: `cannot parse YAML: ${error.message}`
-			});
-			continue;
-		}
-		const result = sessionSchema.safeParse(data);
-		if (result.success) sessions.push(result.data);
-		else for (const i of result.error.issues) problems.push({
-			file: relative(root, file),
-			field: i.path.join("."),
-			message: i.message
-		});
-	}
-	return {
-		sessions,
-		problems
-	};
-}
-function readSession(root, id) {
-	const file = sessionFile(root, id);
-	return existsSync(file) ? readYaml(file, sessionSchema).data : null;
-}
-function requireSession(root, id) {
-	const file = sessionFile(root, id);
-	if (!existsSync(file)) throw new WriteError(`session ${id} not found; start one with "mainflow session start"`);
-	return file;
-}
-/** Split `claude-code-1a2b3c4d#a003` into its session and action ids. */
-function splitActionRef(ref) {
-	const hash = ref.lastIndexOf("#");
-	const action = ref.slice(hash + 1);
-	if (hash <= 0 || !/^a\d{3}$/.test(action)) throw new WriteError(`expected an action reference like claude-code-1a2b3c4d#a003, got "${ref}"`);
-	return {
-		session: ref.slice(0, hash),
-		action
-	};
-}
-/** The note a handoff leaves on the dropped action, naming where the work went. */
-const handedOffNote = (to) => `handed off to ${to}`;
-const HANDED_OFF = /(?:^|; )handed off to ([a-z0-9][a-z0-9-]*#a\d{3})$/;
-/**
-* Find the action a reference names. A handoff drops the action and names its new place in the note, so the
-* reference is followed there: a wait on the old reference keeps working after the work moved to another session.
-*/
-function resolveAction(root, ref) {
-	const seen = /* @__PURE__ */ new Set();
-	let current = ref;
-	for (;;) {
-		const parsed = parseActionRef(current);
-		if (!parsed) return {
-			ref: current,
-			missing: `"${current}" is not an action reference like claude-code-1a2b3c4d#a003`
-		};
-		let session;
-		try {
-			session = readSession(root, parsed.session);
-		} catch (error) {
-			return {
-				ref: current,
-				missing: error.message
-			};
-		}
-		if (!session) return {
-			ref: current,
-			missing: `session ${parsed.session} not found`
-		};
-		const action = session.actions.find((a) => a.id === parsed.action);
-		if (!action) return {
-			ref: current,
-			missing: `action ${current} not found`
-		};
-		const next = action.status === "dropped" ? HANDED_OFF.exec(action.note ?? "")?.[1] : void 0;
-		if (!next || seen.has(next)) return {
-			ref: current,
-			session,
-			action
-		};
-		seen.add(current);
-		current = next;
-	}
-}
-/**
-* 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 (!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. 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.
-*/
-function takeUnfinished(root, from, to, existing) {
-	const previousFile = requireSession(root, from);
-	const previous = readYaml(previousFile, sessionSchema).data;
-	const ids = [...existing];
-	const carried = [];
-	const at = nowMinute();
-	const left = previous.actions.map((a) => {
-		if (!isCarried$1(a)) return a;
-		const id = nextId("a", ids);
-		ids.push(id);
-		carried.push({
-			...a,
-			id
-		});
-		const handedOff = handedOffNote(`${to}#${id}`);
-		const { blockedBy: _moved, ...rest } = a;
-		return {
-			...rest,
-			status: "dropped",
-			note: a.note ? `${a.note}; ${handedOff}` : handedOff,
-			doneAt: at
-		};
-	});
-	writeAtomic(previousFile, toYaml(validate(sessionSchema, {
-		...previous,
-		status: "handed-off",
-		actions: left
-	}, previousFile)));
-	return carried;
-}
-/**
-* Start a session. Taking over from another session moves its unfinished actions into this one and marks
-* the other session handed-off, so the queue continues where it stopped.
-*/
-function startSession(root, input) {
-	const id = input.id ?? `${input.agent}-${randomBytes(4).toString("hex")}`;
-	if (!SESSION_ID.test(id)) throw new WriteError(`session id "${id}" must be lowercase letters, digits and hyphens`);
-	return withLock(root, () => {
-		const file = sessionFile(root, id);
-		if (existsSync(file)) throw new WriteError(`session ${id} already exists`);
-		if (input.delegatedFrom) requireSession(root, input.delegatedFrom);
-		const carried = input.handoffFrom ? takeUnfinished(root, input.handoffFrom, id, []) : [];
-		const session = validate(sessionSchema, {
-			id,
-			agent: input.agent,
-			status: "active",
-			started: nowMinute(),
-			delegatedFrom: input.delegatedFrom ?? null,
-			handoffFrom: input.handoffFrom ?? null,
-			cwd: input.cwd,
-			actions: carried
-		}, file);
-		mkdirSync(sessionsDir(root), { recursive: true });
-		writeAtomic(file, toYaml(session));
-		return session;
-	});
-}
-/**
-* Start the session unless it already exists. An existing paused or ended session becomes active again, and
-* an archived one comes back into view, since resumed work should not stay hidden.
-*/
-function ensureSession(root, input) {
-	const existing = readSession(root, input.id);
-	if (!existing) return {
-		session: startSession(root, input),
-		created: true
-	};
-	if (existing.status === "active" && !existing.archivedAt) return {
-		session: existing,
-		created: false
-	};
-	return {
-		session: mutateYaml(root, requireSession(root, input.id), sessionSchema, (s) => {
-			s.status = "active";
-			delete s.archivedAt;
-		}),
-		created: false
-	};
-}
-/**
-* Take over another session's unfinished actions into a session that already exists, such as one a host hook
-* created when the conversation opened. The receiving session must have nothing unfinished of its own, so the
-* carried queue is not mixed into work already under way; its finished actions stay and the carried ones are
-* numbered after them.
-*/
-function handoffSession(root, id, from) {
-	if (id === from) throw new WriteError(`session ${id} cannot take over from itself`);
-	return withLock(root, () => {
-		const file = requireSession(root, id);
-		const session = readYaml(file, sessionSchema).data;
-		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(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,
-			status: "active",
-			handoffFrom: from,
-			actions: [...session.actions, ...carried]
-		}, file);
-		writeAtomic(file, toYaml(next));
-		return next;
-	});
-}
-/** Where a session's transcript is on disk: a platform records an absolute path, a hub may record one relative to its root. */
-function transcriptPath(root, transcript) {
-	return isAbsolute(transcript) ? transcript : join(root, transcript);
-}
-function setSessionInfo(root, id, info) {
-	return mutateYaml(root, requireSession(root, id), sessionSchema, (s) => {
-		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) => {
-		s.status = value;
-	});
-}
-/**
-* Settle a session when its turn ends. A session that tracked no action, and whose subagents tracked none, leaves
-* no record, since nothing in it points at the hub's work. Then every active main session with no action left to
-* do and no subagent still running ends, the others as well as this one: another session may have finished its
-* last action, or it was closed before its own turn could settle it. The next prompt or action brings it back.
-*/
-function settleSession(root, id) {
-	return withLock(root, () => {
-		const { sessions } = loadSessions(root);
-		const subagents = (parent) => sessions.filter((s) => s.delegatedFrom === parent).flatMap((s) => [s, ...subagents(s.id)]);
-		const family = sessions.some((s) => s.id === id) ? [sessions.find((s) => s.id === id), ...subagents(id)] : [];
-		const removed = family.length > 0 && family.every((s) => s.actions.length === 0);
-		if (removed) for (const s of family) rmSync(sessionFile(root, s.id), { force: true });
-		let result = removed ? "removed" : "kept";
-		for (const s of sessions) {
-			if (s.status !== "active" || s.delegatedFrom || removed && s.id === id) continue;
-			if (!s.actions.every((a) => a.status === "done" || a.status === "dropped") || subagents(s.id).some((x) => x.status === "active")) continue;
-			if (s.id === id && s.actions.length === 0) continue;
-			writeAtomic(sessionFile(root, s.id), toYaml(validate(sessionSchema, {
-				...s,
-				status: "ended"
-			}, sessionFile(root, s.id))));
-			if (s.id === id) result = "ended";
-		}
-		return result;
-	});
-}
-/** Archive or unarchive a session; the status stays as it is, so an ended session is visible until archived. */
-function setSessionArchived(root, id, archived) {
-	return mutateYaml(root, requireSession(root, id), sessionSchema, (s) => {
-		if (archived) s.archivedAt ??= today();
-		else delete s.archivedAt;
-	});
-}
-function place(actions, action, before) {
-	if (!before) {
-		actions.push(action);
-		return;
-	}
-	const index = actions.findIndex((a) => a.id === before);
-	if (index < 0) throw new WriteError(`--before ${before} is not an action in this session`);
-	actions.splice(index, 0, action);
-}
-function addAction(root, sessionId, input) {
-	requireServes(root, input.serves);
-	let created = "";
-	mutateYaml(root, requireSession(root, sessionId), sessionSchema, (s) => {
-		created = nextId("a", s.actions.map((a) => a.id));
-		place(s.actions, {
-			id: created,
-			do: input.do,
-			status: "todo",
-			serves: input.serves
-		}, input.before);
-		if (s.status === "ended") s.status = "active";
-	});
-	return `${sessionId}#${created}`;
-}
-/**
-* What a blocked action waits for must be checkable: an action it names has to exist and, followed through
-* handoffs, cannot be the action itself, and an `until` has to be one of the condition forms. An old reference
-* to work that has since been handed off to this very action would otherwise wait forever.
-*/
-function requireBlock(root, ref, block) {
-	const targets = [waitingForAction(block.waitingFor), block.until === void 0 ? void 0 : untilTarget(block.until)];
-	for (const target of targets) {
-		if (!target) continue;
-		const found = resolveAction(root, target);
-		if ("missing" in found) throw new WriteError(`${found.missing}; --waiting-for and --until action-done take an existing action like claude-code-1a2b3c4d#a003`);
-		if (found.ref === ref) throw new WriteError(`action ${ref} cannot wait for itself${target === ref ? "" : ` (${target} was handed off to it)`}`);
-	}
-}
-/** The action an `until` waits for; throws when the condition matches none of the forms. */
-function untilTarget(until) {
-	const parsed = parseUntil(until);
-	if (!parsed) throw new WriteError(`--until takes a condition like commit:{branch}:{text}, action-done:{sessionId}#a{NNN} or file:{relative path}, got "${until}"`);
-	return parsed.kind === "action-done" ? `${parsed.session}#${parsed.action}` : void 0;
-}
-function updateAction(root, ref, patch) {
-	const { session, action } = splitActionRef(ref);
-	const status = patch.status === void 0 ? void 0 : requireOneOf(patch.status, WORK_STATUS, "action status");
-	if (patch.serves) requireServes(root, patch.serves);
-	if (patch.before === action) throw new WriteError(`action ${action} cannot be placed before itself`);
-	if (status === "blocked" && !patch.blockedBy?.reason) throw new WriteError(`blocking ${ref} needs a reason, e.g. --reason "等 schema 定案" --waiting-for claude-code-1a2b3c4d#a003 --until action-done:claude-code-1a2b3c4d#a003`);
-	if (patch.blockedBy) requireBlock(root, `${session}#${action}`, patch.blockedBy);
-	let updated;
-	mutateYaml(root, requireSession(root, session), sessionSchema, (s) => {
-		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 = {
-			...current,
-			...status && { status },
-			...patch.do && { do: patch.do },
-			...patch.serves && { serves: patch.serves },
-			...patch.note && { note: patch.note }
-		};
-		if (patch.blockedBy) {
-			if (next.status !== "blocked") throw new WriteError(`--reason, --waiting-for and --until go with --status blocked; ${ref} is ${next.status}`);
-			next.blockedBy = patch.blockedBy;
-		}
-		if (next.status !== "blocked") delete next.blockedBy;
-		if (status === "doing" && current.status !== "doing") {
-			next.startedAt = nowMinute();
-			delete next.doneAt;
-		}
-		if ((status === "done" || status === "dropped") && current.status !== status) next.doneAt = nowMinute();
-		if (status === "todo") {
-			delete next.startedAt;
-			delete next.doneAt;
-		}
-		updated = next;
-		if (patch.before) place(s.actions, next, patch.before);
-		else s.actions.splice(index, 0, next);
-	});
-	return updated;
-}
-//#endregion
-//#region ../core/dist/briefing.js
-function describe(root, ref) {
-	const parsed = parseRef(ref);
-	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;
-		return {
-			ref,
-			text: item.text,
-			checked: item.done,
-			where: `${mainline.id} ${mainline.title} › ${task.id} ${task.title}`
-		};
-	} catch {
-		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 = [];
-	const doing = session.actions.filter((a) => a.status === "doing");
-	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 或 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。`);
-	return warnings;
-}
-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;
-	const parts = block ? [
-		block.reason,
-		...block.waitingFor ? [`等 ${block.waitingFor}`] : [],
-		...block.until ? [`條件 ${block.until}`] : []
-	] : [];
-	return `${a.id} ${a.do}${parts.length > 0 ? `（${parts.join("；")}）` : ""}`;
-}
-/** Mainlines a session could be pushing forward. */
-const openMainlines = (root) => loadHub(root).mainlines.filter((m) => !m.archivedAt && (m.status === "active" || m.status === "planning"));
-/** How recently a session's transcript must have been written for the session to count as possibly still running. */
-const RUNNING_WINDOW_MS = 9e5;
-/** Whether the session's transcript was written within the running window; false when no transcript is recorded or readable. */
-function mayBeRunning(root, session) {
-	if (!session.transcript) return false;
-	try {
-		return Date.now() - statSync(transcriptPath(root, session.transcript)).mtimeMs < RUNNING_WINDOW_MS;
-	} catch {
-		return false;
-	}
-}
-/** The session and every session in its delegation tree: the sessions that delegated to it, and theirs, and all their subagents. */
-function family(sessions, id) {
-	const byId = new Map(sessions.map((s) => [s.id, s]));
-	const chain = /* @__PURE__ */ new Set([id]);
-	let top = id;
-	for (let up = byId.get(id)?.delegatedFrom; up && byId.has(up) && !chain.has(up); up = byId.get(up)?.delegatedFrom) {
-		chain.add(up);
-		top = up;
-	}
-	const members = /* @__PURE__ */ new Set([top]);
-	for (let grew = true; grew;) {
-		grew = false;
-		for (const s of sessions) if (s.delegatedFrom && members.has(s.delegatedFrom) && !members.has(s.id)) {
-			members.add(s.id);
-			grew = true;
-		}
-	}
-	return members.add(id);
-}
-/** The actions in this session that a blocked action elsewhere waits for, named by `waitingFor` or by an `until` of kind action-done. */
-function waitedFor(root, blocked) {
-	const until = blocked.blockedBy?.until ? parseUntil(blocked.blockedBy.until) : null;
-	const refs = [waitingForAction(blocked.blockedBy?.waitingFor), until?.kind === "action-done" ? `${until.session}#${until.action}` : void 0];
-	return [...new Set(refs.filter((r) => r !== void 0).map((r) => resolveAction(root, r).ref))];
-}
-/**
-* One line for each blocked action in another session that waits for an action of this one, followed through
-* handoffs, so the session being waited for sees it without the other side having to send a message. An action
-* already done or dropped has nothing left to deliver, so a wait on it is not shown.
-*/
-function waiterLines(root, session) {
-	const lines = [];
-	for (const other of loadSessions(root).sessions) {
-		if (other.id === session.id || other.archivedAt || other.status === "handed-off") continue;
-		for (const blocked of other.actions.filter((a) => a.status === "blocked")) for (const ref of waitedFor(root, blocked)) {
-			const mine = ref.startsWith(`${session.id}#`) ? session.actions.find((a) => `${session.id}#${a.id}` === ref) : void 0;
-			if (!mine || mine.status === "done" || mine.status === "dropped") continue;
-			const until = blocked.blockedBy?.until ? `。條件：${blocked.blockedBy.until}` : "";
-			lines.push(`有會話在等你：${other.id}#${blocked.id} 等 ${mine.id} ${mine.do}（${blocked.blockedBy.reason}）${until}`);
-		}
-	}
-	return lines;
-}
-/**
-* 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) {
-	const { sessions } = loadSessions(root);
-	const action = sessions.find((s) => s.id === sessionId)?.actions.find((a) => a.id === actionId);
-	if (!action || action.serves.length === 0) return [];
-	const related = family(sessions, sessionId);
-	const lines = [];
-	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 = sharedServes(root, action.serves, theirs.serves);
-			if (shared.length > 0) lines.push(`⚠ ${other.id}#${theirs.id}（15 分鐘內有活動）也在做 ${shared.join("、")}，先協調再開始`);
-		}
-	}
-	return lines;
-}
-/**
-* Lines naming the other top-level sessions that still hold unfinished actions, with the command that takes them
-* 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(isCarried));
-	if (others.length === 0) return [];
-	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 項目或解決條件";
-/**
-* 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;
-	const lines = [`[mainflow] 這場會話的 id 是 ${session.id}${options.envNote ? `（${options.envNote}）` : ""}。`];
-	const doing = current(session);
-	const upcoming = session.actions.filter((a) => a.status === "todo").slice(0, 3);
-	if (session.actions.length === 0) {
-		const active = openMainlines(root);
-		lines.push("這場會話還沒有行動。");
-		if (active.length > 0) {
-			lines.push("進行中的主脈絡：");
-			for (const m of active) lines.push(`- ${m.id} ${m.title}`);
-			lines.push(`要推進其中一個時，先用 ${cli} status 與它的任務 checklist 決定要做什麼，再列出行動。`);
-		}
-	} else {
-		lines.push(doing ? `目前行動：${doing.id} ${doing.do}` : "目前沒有進行中的行動。");
-		if (doing) lines.push(`服務：${servedLine(root, doing)}`);
-		const grants = grantLines(root, session);
-		if (grants.length > 0) lines.push("目前行動服務的主脈絡預先授權了這些動作：", ...grants);
-		if (upcoming.length > 0) lines.push(`接下來：${upcoming.map((a) => `${a.id} ${a.do}`).join("、")}`);
-		const blocked = session.actions.filter((a) => a.status === "blocked");
-		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>。主脈絡還沒拆任務時（查核與規劃階段），--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.
-* 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);
-	const open = session.actions.filter(isOpen);
-	const blocked = session.actions.filter((a) => a.status === "blocked");
-	const head = doing ? `[mainflow] 目前行動 ${doing.id} ${doing.do}，服務 ${doing.serves.join("、") || "（未指定）"}。這一輪的工作若不屬於它，先調整佇列再做。` : open.length > 0 ? `[mainflow] ${session.id} 目前沒有進行中的行動。` : blocked.length > 0 ? `[mainflow] ${session.id} 的行動在等外部條件：${blocked.map(waitingLine).join("；")}。有條件（until）的可以在背景執行 ${options.cli} wait <a編號> 等它成立。條件出現後用 ${options.cli} action set <a編號> --status doing 繼續；要先做別的事，用 ${options.cli} action add 列出行動。` : `[mainflow] ${session.id} 的行動都已結束。繼續工作前先用 ${options.cli} action add 列出下一個行動。`;
-	const header = headerLine(session);
-	const marker = header ? [`- 這一輪最後一則回覆的最後一行寫「${header}」，回覆範例等其他內容都放在它前面。有顯示 hook 時，它會換成標題與連結。`] : [];
-	const grants = grantLines(root, session);
-	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,
-		...waiting,
-		...granted,
-		...marker,
-		...warned
-	].join("\n");
-}
-//#endregion
-//#region ../core/dist/waiting.js
-/** Separates commits in the git log output (%x1e); commit messages do not use this control character. */
-const RECORD = "";
-/** Whether git finds a repository at the hub root; false as well when git itself cannot run. */
-function inGitRepository(root) {
-	try {
-		execFileSync("git", ["rev-parse", "--git-dir"], {
-			cwd: root,
-			stdio: "ignore"
-		});
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** Whether a commit on the branch has the text in its message; git runs at the hub root, so the branch is the hub repository's. */
-function commitState(root, branch, text) {
-	let log;
-	try {
-		log = execFileSync("git", [
-			"log",
-			"--format=%h %s%n%b%x1e",
-			branch,
-			"--"
-		], {
-			cwd: root,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			maxBuffer: 268435456
-		});
-	} catch {
-		if (!inGitRepository(root)) return {
-			met: false,
-			unreachable: true,
-			detail: `the hub root ${root} is not in a git repository, so no commit can appear there`
-		};
-		return {
-			met: false,
-			detail: `branch ${branch} is not in the repository at the hub root yet`
-		};
-	}
-	for (const record of log.split(RECORD)) {
-		const entry = record.replace(/^\n/, "");
-		const space = entry.indexOf(" ");
-		const message = entry.slice(space + 1);
-		if (space > 0 && message.includes(text)) return {
-			met: true,
-			detail: `commit ${entry.slice(0, space)} on ${branch} contains "${text}": ${message.split("\n")[0]}`
-		};
-	}
-	return {
-		met: false,
-		detail: `no commit on ${branch} contains "${text}"`
-	};
-}
-function actionState(root, ref) {
-	const found = resolveAction(root, ref);
-	if ("missing" in found) return {
-		met: false,
-		detail: found.missing
-	};
-	const via = found.ref === ref ? "" : ` (handed off to ${found.ref})`;
-	if (found.action.status === "done") return {
-		met: true,
-		detail: `${ref}${via} is done`
-	};
-	if (found.action.status === "dropped") return {
-		met: false,
-		unreachable: true,
-		detail: `${ref}${via} was dropped without a handoff, so it will never be done`
-	};
-	return {
-		met: false,
-		detail: `${ref}${via} is ${found.action.status}`
-	};
-}
-/** Check a wait condition once. */
-function untilState(root, until) {
-	switch (until.kind) {
-		case "commit": return commitState(root, until.branch, until.text);
-		case "action-done": return actionState(root, `${until.session}#${until.action}`);
-		case "file": return existsSync(resolve(root, until.path)) ? {
-			met: true,
-			detail: `${until.path} exists`
-		} : {
-			met: false,
-			detail: `${until.path} does not exist yet`
-		};
-	}
-}
-//#endregion
-//#region ../core/dist/write.js
-function checkTaskLinks(root, mainline, task) {
-	if (task.repo && !(task.repo in readConfig(root).repos)) throw new WriteError(`repo "${task.repo}" is not listed in .mainflow/config.yaml; add it under repos first`);
-	if (task.parent) {
-		if (task.parent === task.id) throw new WriteError(`task ${task.id} cannot be its own parent`);
-		taskDir(root, mainline, task.parent);
-	}
-}
-function initHub(root, hub) {
-	const dataDir = join(root, DATA_DIR);
-	if (existsSync(join(dataDir, "config.yaml"))) throw new WriteError(`${dataDir} already holds a hub`);
-	const config = validate(configSchema, {
-		hub,
-		formatVersion: 2,
-		repos: {}
-	}, "config.yaml");
-	mkdirSync(join(dataDir, "mainlines"), { recursive: true });
-	writeFileSync(join(dataDir, "config.yaml"), toYaml(config));
-	writeFileSync(join(dataDir, ".gitignore"), "local/\n**/scratch/\n!ops/*.log\n");
-	return dataDir;
-}
-/** Register a repository the hub's tasks may point at; `path` is relative to the hub root. */
-function addRepo(root, name, path) {
-	requireSlug(name);
-	const target = resolve(root, path);
-	if (!existsSync(target) || !statSync(target).isDirectory()) throw new WriteError(`repo path ${path} does not exist from the hub root (${target})`);
-	mutateYaml(root, join(root, DATA_DIR, "config.yaml"), configSchema, (c) => {
-		if (c.repos[name] !== void 0 && c.repos[name] !== path) throw new WriteError(`repo "${name}" is already registered as ${c.repos[name]}`);
-		c.repos[name] = path;
-	});
-	return name;
-}
-/**
-* Register another hub whose documents this hub's references may point at, as `{name}:m001`. `path` is
-* relative to this hub's root and must hold that hub, registered under its own name, so a reference reads
-* the same in every hub that mentions it.
-*/
-function addHub(root, name, path) {
-	requireSlug(name);
-	if (RESERVED_HUB_NAMES.includes(name)) throw new WriteError(`${RESERVED_HUB_NAMES.join(" and ")} are reserved and cannot name a hub`);
-	const target = resolve(root, path);
-	if (name === readConfig(root).hub) throw new WriteError(`"${name}" is this hub's own name; references without a prefix already point here`);
-	if (!existsSync(join(target, ".mainflow", "config.yaml"))) throw new WriteError(`no hub at ${path} from the hub root (${target})`);
-	const other = readConfig(target).hub;
-	if (other !== name) throw new WriteError(`${path} holds hub "${other}"; register it as "${other}"`);
-	mutateYaml(root, join(root, DATA_DIR, "config.yaml"), configSchema, (c) => {
-		const hubs = c.hubs ??= {};
-		if (hubs[name] !== void 0 && hubs[name] !== path) throw new WriteError(`hub "${name}" is already registered as ${hubs[name]}`);
-		hubs[name] = path;
-	});
-	return name;
-}
-/** Stamp closedAt when a status closes the entity and clear it when the entity reopens. */
-function stampClosed(doc, closed, at) {
-	if (closed) doc.closedAt ??= at;
-	else delete doc.closedAt;
-}
-const closes = (kind, status) => CLOSED_STATUS[kind].includes(status);
-function createMainline(root, input) {
-	requireSlug(input.slug);
-	return withLock(root, () => {
-		const id = nextId("m", idsIn(mainlinesDir(root)));
-		const dir = join(mainlinesDir(root), `${id}-${input.slug}`);
-		const mainline = validate(mainlineSchema, {
-			id,
-			title: input.title,
-			status: "planning",
-			created: today(),
-			criteria: []
-		}, MAINLINE_FILE);
-		mkdirSync(join(dir, "tasks"), { recursive: true });
-		writeAtomic(join(dir, MAINLINE_FILE), frontMatterText(mainline, MAINLINE_BODY));
-		return {
-			id,
-			dir
-		};
-	});
-}
-/** Decisions of a mainline still waiting for a ruling, by id. */
-function proposedDecisions(root, id) {
-	return listFiles(join(mainlineDir(root, id), "decisions")).filter((file) => file.endsWith(".md")).map((file) => splitFrontMatter(readText(file) ?? "").data).filter((d) => d?.status === "proposed").map((d) => d.id ?? "?");
-}
-/**
-* Marking a mainline done is a claim that its criteria hold and nothing is left to decide, so it is
-* refused while a criterion is still open or a decision is still proposed. The message names each one and
-* the ways to settle it; dropping the mainline instead is not checked.
-*/
-function requireDone(root, id, m) {
-	const open = m.criteria.filter((c) => !c.done && !c.dropped).map((c) => `${id}#${c.id}`);
-	const proposed = proposedDecisions(root, id).map((d) => `${id}/${d}`);
-	if (!open.length && !proposed.length) return;
-	throw new WriteError(`${id} cannot be marked done: ${[open.length ? `unmet criteria ${open.join(", ")} (check each with evidence, e.g. criterion check ${open[0]} --evidence <commit>, or reword or drop it in ${MAINLINE_FILE})` : "", proposed.length ? `proposed decisions ${proposed.join(", ")} (decision accept or decision supersede first)` : ""].filter(Boolean).join("; ")}`);
-}
-/** Move a mainline to another status; done is refused while criteria are open or decisions are proposed. */
-function setMainlineStatus(root, id, status, expectedVersion) {
-	requireRef(id, "mainline");
-	const next = requireOneOf(status, MAINLINE_STATUS, "mainline status");
-	return mutateFrontMatter(root, mainlineFile(root, id), mainlineSchema, (m) => {
-		if (next === "done" && m.status !== "done") requireDone(root, id, m);
-		m.status = next;
-		stampClosed(m, closes("mainline", next), today());
-	}, expectedVersion);
-}
-/** Rename a mainline. References use its ID, so they keep resolving and show the new title. */
-function setMainlineTitle(root, id, title, expectedVersion) {
-	requireRef(id, "mainline");
-	const next = title.replace(/\s+/g, " ").trim();
-	if (!next) throw new WriteError(`${id} needs a title, e.g. "mainflow 改發布到 npm 公開套件"`);
-	return mutateFrontMatter(root, mainlineFile(root, id), mainlineSchema, (m) => {
-		m.title = next;
-	}, expectedVersion);
-}
-function setArchived(root, id, archived, expectedVersion) {
-	requireRef(id, "mainline");
-	return mutateFrontMatter(root, mainlineFile(root, id), mainlineSchema, (m) => {
-		if (archived) m.archivedAt ??= today();
-		else delete m.archivedAt;
-	}, expectedVersion);
-}
-function setCriterion(root, refInput, done, evidence, expectedVersion) {
-	const ref = requireRef(refInput, "criterion");
-	if (done && !evidence) throw new WriteError(`marking ${refInput} as met needs evidence, e.g. --evidence mainflow@25e4165`);
-	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, `${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. */
-function setCriterionText(root, refInput, patch, expectedVersion) {
-	const ref = requireRef(refInput, "criterion");
-	if (patch.text === void 0 && patch.doneWhen === void 0) throw new WriteError(`${refInput} needs --text or --done-when, e.g. --text "CLI can create mainlines"`);
-	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`);
-		if (patch.text !== void 0) criterion.text = patch.text;
-		if (patch.doneWhen !== void 0) criterion.doneWhen = patch.doneWhen;
-	}, expectedVersion);
-}
-/**
-* 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();
-	} else {
-		delete item.evidence;
-		delete item.doneAt;
-	}
-}
-/** Tasks are written after what already exists has been checked, so a mainline without a full 現況查核 gets none. */
-function requireSurvey(root, mainline) {
-	const gaps = surveyGaps(splitFrontMatter(readText(mainlineFile(root, mainline)) ?? "").body);
-	if (gaps.length === 0) return;
-	throw new WriteError([
-		`${mainline} needs a filled "## ${SURVEY_SECTION}" before its tasks are created:`,
-		...gaps.map((g) => `- ${g}`),
-		"Write one line per source in mainline.md:",
-		SURVEY_TEMPLATE
-	].join("\n"));
-}
-function createTask(root, mainline, input) {
-	requireRef(mainline, "mainline");
-	requireSlug(input.slug);
-	const kind = requireOneOf(input.kind ?? "phase", ["phase", "branch"], "task kind");
-	return withLock(root, () => {
-		requireSurvey(root, mainline);
-		const tasksDir = join(mainlineDir(root, mainline), "tasks");
-		const id = nextId("t", idsIn(tasksDir));
-		const task = validate(taskSchema, {
-			id,
-			title: input.title,
-			kind,
-			status: "todo",
-			created: today(),
-			checklist: [],
-			...input.parent ? { parent: input.parent } : {},
-			...input.repo ? { repo: input.repo } : {}
-		}, TASK_FILE);
-		checkTaskLinks(root, mainline, task);
-		const dir = join(tasksDir, `${id}-${input.slug}`);
-		mkdirSync(dir, { recursive: true });
-		writeAtomic(join(dir, TASK_FILE), frontMatterText(task, TASK_BODY));
-		return {
-			ref: `${mainline}/${id}`,
-			dir
-		};
-	});
-}
-function updateTask(root, refInput, patch, expectedVersion) {
-	const ref = requireRef(refInput, "task");
-	const status = patch.status === void 0 ? void 0 : requireOneOf(patch.status, WORK_STATUS, "task status");
-	const merge = patch.merge === void 0 ? void 0 : requireOneOf(patch.merge, MERGE_STATES, "merge state");
-	if (status === "blocked" && !patch.blockedBy?.reason) throw new WriteError(`blocking ${refInput} needs a reason, e.g. --reason "等使用者提供 API key" --waiting-for 使用者`);
-	return mutateFrontMatter(root, taskFile(root, ref.mainline, ref.task), taskSchema, (t) => {
-		if (status !== void 0) {
-			t.status = status;
-			if (status === "doing") t.startedAt ??= today();
-			stampClosed(t, closes("task", status), today());
-			if (status !== "blocked") delete t.blockedBy;
-		}
-		if (patch.repo !== void 0) {
-			if (patch.repo) t.repo = patch.repo;
-			else delete t.repo;
-		}
-		if (patch.blockedBy !== void 0) t.blockedBy = patch.blockedBy;
-		if (patch.branch !== void 0) t.branch = patch.branch;
-		if (patch.worktree !== void 0) t.worktree = patch.worktree;
-		if (patch.base !== void 0) t.base = patch.base;
-		if (merge !== void 0) t.merge = merge;
-		checkTaskLinks(root, ref.mainline, t);
-	}, expectedVersion);
-}
-function setChecklistItem(root, refInput, done, evidence, expectedVersion) {
-	const ref = requireRef(refInput, "checklistItem");
-	if (done && !evidence) throw new WriteError(`checking ${refInput} needs evidence, e.g. --evidence mainflow@25e4165`);
-	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, `${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. */
-function dropChecklistItem(root, refInput, input = {}, 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.done) throw new WriteError(`${refInput} is checked; uncheck it before dropping it`);
-		item.dropped = true;
-		if (input.supersededBy) item.supersededBy = input.supersededBy;
-		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);
-	const status = requireOneOf(input.status ?? "accepted", ["proposed", "accepted"], "new decision status");
-	const by = input.by === void 0 ? void 0 : requireOneOf(input.by, DECIDERS, "decided by");
-	const basis = input.basis === void 0 ? void 0 : requireOneOf(input.basis, DECISION_BASES, "decision basis");
-	for (const ref of input.affects ?? []) requireAffected(root, mainline, ref);
-	return withLock(root, () => {
-		const dir = join(mainlineDir(root, mainline), "decisions");
-		mkdirSync(dir, { recursive: true });
-		const id = nextId("d", idsIn(dir));
-		const at = nowMinute();
-		const decision = validate(decisionSchema, {
-			id,
-			title: input.title,
-			created: at,
-			status,
-			...status === "accepted" ? { decidedAt: at } : {},
-			...by ? { by } : {},
-			...basis ? { basis } : {},
-			...input.affects?.length ? { affects: input.affects } : {}
-		}, "decision");
-		const file = join(dir, `${id}-${input.slug}.md`);
-		writeAtomic(file, frontMatterText(decision, DECISION_BODY));
-		return {
-			ref: `${mainline}/${id}`,
-			file
-		};
-	});
-}
-/** A decision affects tasks or checklist items of its own mainline, and they must exist. */
-function requireAffected(root, mainline, input) {
-	const ref = parseRefIn(input);
-	if (!ref || ref.mainline !== mainline) throw new WriteError(`--affects takes tasks or checklist items of ${mainline}, like ${mainline}/t001 or ${mainline}/t001#c002; got "${input}"`);
-	taskDir(root, ref.mainline, ref.task);
-}
-const parseRefIn = (input) => {
-	const task = /^(m\d{3})\/(t\d{3})(?:#c\d{3})?$/.exec(input);
-	return task ? {
-		mainline: task[1],
-		task: task[2]
-	} : null;
-};
-/** Settle a proposed decision: record who decided, how and when; the items it affects stop waiting for it. */
-function acceptDecision(root, refInput, settlement = {}, expectedVersion) {
-	const ref = requireRef(refInput, "decision");
-	const decider = settlement.by === void 0 ? void 0 : requireOneOf(settlement.by, DECIDERS, "decided by");
-	const basis = settlement.basis === void 0 ? void 0 : requireOneOf(settlement.basis, DECISION_BASES, "decision basis");
-	return mutateFrontMatter(root, decisionFile(root, ref.mainline, ref.decision), decisionSchema, (d) => {
-		if (d.status !== "proposed") throw new WriteError(`${refInput} is ${d.status}; only a proposed decision can be accepted`);
-		d.status = "accepted";
-		d.decidedAt = nowMinute();
-		if (decider) d.by = decider;
-		if (basis) d.basis = basis;
-	}, expectedVersion);
-}
-function supersedeDecision(root, refInput, by, expectedVersion) {
-	const ref = requireRef(refInput, "decision");
-	const successor = requireRef(by.includes("/") ? by : `${ref.mainline}/${by}`, "decision");
-	if (successor.mainline !== ref.mainline) throw new WriteError(`a decision can only be superseded within its own mainline (${ref.mainline})`);
-	if (successor.decision === ref.decision) throw new WriteError(`decision ${refInput} cannot supersede itself`);
-	decisionFile(root, successor.mainline, successor.decision);
-	return mutateFrontMatter(root, decisionFile(root, ref.mainline, ref.decision), decisionSchema, (d) => {
-		d.status = "superseded";
-		d.supersededBy = successor.decision;
-		stampClosed(d, true, nowMinute());
-	}, expectedVersion);
-}
-//#endregion
-//#region ../core/dist/archive.js
-/** The entities that carry `archivedAt`; tasks and decisions follow their mainline instead. */
-const ARCHIVE_KINDS = [
-	"mainline",
-	"issue",
-	"finding",
-	"session"
-];
-const ARCHIVERS = {
-	mainline: setArchived,
-	issue: setIssueArchived,
-	finding: setFindingArchived,
-	session: setSessionArchived
-};
-/**
-* Archive or unarchive several entities of one kind. Each file is written on its own: one that fails, such
-* as an ID that no longer exists, is reported and the others still change, because a selection in the
-* interface can go stale while it is open.
-*/
-function setArchivedMany(root, kind, ids, archived) {
-	const archiver = ARCHIVERS[kind];
-	if (!archiver) throw new WriteError(`kind must be one of: ${ARCHIVE_KINDS.join(", ")}`);
-	const result = {
-		done: [],
-		failed: []
-	};
-	for (const id of new Set(ids)) try {
-		archiver(root, id, archived);
-		result.done.push(id);
-	} catch (error) {
-		result.failed.push({
-			id,
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
-	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]);
-const rename = (o, from, to) => {
-	if (from in o) {
-		if (o[from] !== null && o[from] !== void 0) o[to] = o[from];
-		delete o[from];
-	}
-};
-const isClosed = (kind, status) => CLOSED_STATUS[kind].includes(status);
-/** Drop the file's own H1, which format 2 replaces with the title in the front matter. */
-const withoutTitle = (markdown) => markdown.replace(/^\s*# [^\n]*\n/, "").replace(/^\n+/, "");
-/**
-* Fold format 1's notes.md into the task body. Sections the task body also has keep their place; any
-* other section, and text before the first section, moves under 紀錄 one heading level deeper.
-*/
-function foldNotes(body, notes) {
-	const lines = withoutTitle(notes).split("\n");
-	const sections = [{
-		heading: null,
-		lines: []
-	}];
-	for (const line of lines) {
-		const h2 = /^## (.+)$/.exec(line);
-		if (h2) sections.push({
-			heading: h2[1].trim(),
-			lines: []
-		});
-		else sections.at(-1).lines.push(line);
-	}
-	const extra = [];
-	for (const section of sections) {
-		const text = section.lines.join("\n").trim();
-		if (section.heading && TASK_SECTIONS.includes(section.heading)) {
-			if (!text) continue;
-			const current = sectionText(body, section.heading) ?? "";
-			body = withSection(body, section.heading, current ? `${current}\n\n${text}` : text);
-		} else if (section.heading) extra.push(`### ${section.heading}`, "", text.replace(/^(#{3,5}) /gm, "#$1 "), "");
-		else if (text) extra.push(text, "");
-	}
-	if (extra.length) {
-		const current = sectionText(body, "紀錄") ?? "";
-		body = withSection(body, "紀錄", [current, extra.join("\n").trim()].filter(Boolean).join("\n\n"));
-	}
-	return body;
-}
-/** Criteria and checklist items: format 2 omits nulls and names a met criterion done. */
-function migrateListItem(item) {
-	rename(item, "met", "done");
-	dropNull(item, "evidence", "doneAt");
-	return item;
-}
-const openItem = (item) => !item.done && !item.dropped;
-/** Convert a format 1 hub to the current format, writing nothing when `dryRun` is set. */
-function migrateHub(root, options = {}) {
-	const dataDir = join(root, DATA_DIR);
-	const configFile = join(dataDir, "config.yaml");
-	if (!existsSync(configFile)) throw new WriteError(`no hub at ${root}; run mainflow init first`);
-	const rel = (path) => relative(root, path);
-	return withLock(root, () => {
-		const config = parse$1(readFileSync(configFile, "utf8"));
-		const from = Number(config.formatVersion);
-		if (from === 2) throw new WriteError(`${rel(configFile)} is already format 2; nothing to migrate`);
-		if (from !== 1) throw new WriteError(`cannot migrate from format ${String(config.formatVersion)}; this CLI migrates format 1 to 2`);
-		const writes = /* @__PURE__ */ new Map();
-		const removes = [];
-		const missing = [];
-		const document = (file, schema, data, body) => {
-			writes.set(file, frontMatterText(validate(schema, data, rel(file)), body));
-		};
-		for (const mainlineDir of subdirs(join(dataDir, "mainlines"))) {
-			const yamlFile = join(mainlineDir, "mainline.yaml");
-			if (!existsSync(yamlFile)) continue;
-			const m = parse$1(readFileSync(yamlFile, "utf8"));
-			dropNull(m, "archivedAt");
-			if (isClosed("mainline", m.status) && m.archivedAt) m.closedAt = m.archivedAt;
-			const criteria = (m.criteria ?? []).map(migrateListItem);
-			m.criteria = criteria;
-			const id = String(m.id);
-			const open = !isClosed("mainline", m.status);
-			if (open) {
-				for (const c of criteria) if (openItem(c) && !c.doneWhen) missing.push(`${id}#${c.id} doneWhen`);
-			}
-			const contextFile = join(mainlineDir, "context.md");
-			const context = existsSync(contextFile) ? withoutTitle(readFileSync(contextFile, "utf8")) : "";
-			document(join(mainlineDir, MAINLINE_FILE), mainlineSchema, m, `\n${context.trimEnd()}\n`);
-			removes.push(yamlFile, ...existsSync(contextFile) ? [contextFile] : []);
-			for (const taskDir of subdirs(join(mainlineDir, "tasks"))) {
-				const taskYaml = join(taskDir, "task.yaml");
-				if (!existsSync(taskYaml)) continue;
-				const t = parse$1(readFileSync(taskYaml, "utf8"));
-				const content = typeof t.content === "string" ? t.content.trim() : "";
-				drop(t, "content");
-				dropNull(t, "parent", "repo");
-				t.created ??= m.created;
-				const checklist = (t.checklist ?? []).map(migrateListItem);
-				t.checklist = checklist;
-				const doneDays = checklist.map((c) => c.doneAt).filter((d) => typeof d === "string").sort();
-				if (isClosed("task", t.status) && doneDays.length) t.closedAt = doneDays.at(-1);
-				let body = content ? withSection(TASK_BODY, "目標", content) : TASK_BODY;
-				const notesFile = join(taskDir, "notes.md");
-				if (existsSync(notesFile)) {
-					body = foldNotes(body, readFileSync(notesFile, "utf8"));
-					removes.push(notesFile);
-				}
-				const taskRef = `${id}/${String(t.id)}`;
-				if (open && !isClosed("task", t.status)) {
-					for (const section of TASK_REQUIRED_SECTIONS) if (!sectionText(body, section)) missing.push(`${taskRef} ${section}`);
-					for (const c of checklist) if (openItem(c) && !c.doneWhen) missing.push(`${taskRef}#${c.id} doneWhen`);
-				}
-				document(join(taskDir, TASK_FILE), taskSchema, t, body);
-				removes.push(taskYaml);
-			}
-			const decisionsDir = join(mainlineDir, "decisions");
-			for (const name of existsSync(decisionsDir) ? readdirSync(decisionsDir).filter((n) => n.endsWith(".md")).sort() : []) {
-				const file = join(decisionsDir, name);
-				const { data, body } = splitFrontMatter(readFileSync(file, "utf8"));
-				const d = data;
-				rename(d, "date", "created");
-				if (d.status !== "proposed") d.decidedAt = d.created;
-				dropNull(d, "supersededBy");
-				rename(d, "blocks", "affects");
-				document(file, decisionSchema, d, body);
-			}
-		}
-		const hubDocs = (dir, migrate, schema) => {
-			for (const name of existsSync(dir) ? readdirSync(dir).filter((n) => n.endsWith(".md")).sort() : []) {
-				const file = join(dir, name);
-				const { data, body } = splitFrontMatter(readFileSync(file, "utf8"));
-				migrate(data);
-				document(file, schema, data, body);
-			}
-		};
-		hubDocs(join(dataDir, "issues"), (i) => rename(i, "closedBy", "resolution"), issueSchema);
-		hubDocs(join(dataDir, "findings"), (f) => {
-			rename(f, "date", "created");
-			rename(f, "tags", "labels");
-		}, findingSchema);
-		config.formatVersion = 2;
-		writes.set(configFile, toYaml(validate(configSchema, config, rel(configFile))));
-		if (!options.dryRun) {
-			for (const [file, text] of writes) writeAtomic(file, text);
-			for (const file of removes) rmSync(file);
-		}
-		return {
-			from,
-			to: 2,
-			written: [...writes.keys()].map(rel),
-			removed: removes.map(rel),
-			missingDefinitions: missing
-		};
-	});
-}
-//#endregion
-//#region src/host.ts
-const DEFAULT_UI_PORT = 4320;
-const hostName = (hub) => `${hub}.mainflow.localhost`;
-function siteBlock(hub, port) {
-	return [
-		`# mainflow hub ${hub}: written by \`mainflow ui\` to match the port it serves on; do not edit.`,
-		`${hostName(hub)} {`,
-		"	tls internal",
-		`\treverse_proxy localhost:${port}`,
-		"}",
-		""
-	].join("\n");
-}
-/** Caddy's sites directory: MAINFLOW_CADDY_SITES, or the Homebrew layout {prefix}/etc/caddy/sites; null without either. */
-function caddySites() {
-	if (process.env.MAINFLOW_CADDY_SITES) return process.env.MAINFLOW_CADDY_SITES;
-	const prefix = spawnSync("brew", ["--prefix"], { encoding: "utf8" });
-	if (prefix.error || prefix.status !== 0) return null;
-	return join(prefix.stdout.trim(), "etc/caddy/sites");
-}
-/** Reload Caddy from the Caddyfile two levels above the sites directory; the error text on failure. */
-function reloadCaddy(sites) {
-	const caddyfile = join(sites, "..", "..", "Caddyfile");
-	const reload = spawnSync("caddy", [
-		"reload",
-		"--config",
-		caddyfile
-	], { encoding: "utf8" });
-	if (reload.error) return reload.error.message;
-	return reload.status === 0 ? null : (reload.stderr || reload.stdout).trim().slice(-300);
-}
-/**
-* Whether Caddy is running, judged by its admin API answering at all. The API refuses requests like
-* Node's fetch with 403 ("client is not allowed to access from origin"), so any response counts; only a
-* refused connection or a timeout means Caddy is down (observed 2026-09-25: checking for 200 reported a
-* running Caddy as stopped). MAINFLOW_CADDY_ADMIN overrides the address.
-*/
-async function caddyRunning() {
-	const admin = process.env.MAINFLOW_CADDY_ADMIN ?? "http://127.0.0.1:2019";
-	try {
-		await fetch(`${admin}/config/`, { signal: AbortSignal.timeout(500) });
-		return true;
-	} catch {
-		return false;
-	}
-}
-const realOf = (path) => existsSync(path) ? realpathSync(path) : resolve(path);
-/**
-* Point {hub}.mainflow.localhost at `port`. The site block is rewritten and Caddy reloaded only when the
-* port differs from what Caddy already has, so an ordinary start leaves Caddy alone. A link owned by a
-* different hub of the same name stops here: overwriting it would silently take that hub's host name.
-*/
-async function syncHost(root, hub, port, options = {}) {
-	const sites = caddySites();
-	if (!sites || !existsSync(sites)) return {
-		url: null,
-		reason: `Caddy's sites directory was not found (${sites ?? "no Homebrew prefix"}); install Caddy and import that directory from the Caddyfile, or set MAINFLOW_CADDY_SITES`
-	};
-	const dir = join(root, DATA_DIR, "local", "caddy");
-	const file = join(dir, `${hub}.caddy`);
-	const link = join(sites, `mainflow-${hub}.caddy`);
-	const linked = lstatSync(link, { throwIfNoEntry: false });
-	if (linked) {
-		const target = linked.isSymbolicLink() ? resolve(dirname(link), readlinkSync(link)) : link;
-		if (existsSync(target) && realOf(target) !== realOf(file)) throw new WriteError(`host name ${hostName(hub)} is already used by another hub (${link} → ${target}); give one of the hubs a different name in its .mainflow/config.yaml`);
-	}
-	const block = siteBlock(hub, port);
-	if ((linked && existsSync(file) ? readFileSync(file, "utf8") : null) !== block) {
-		mkdirSync(dir, { recursive: true });
-		writeFileSync(file, block);
-		if (linked) rmSync(link);
-		symlinkSync(file, link);
-		const failure = (options.reload ?? reloadCaddy)(sites);
-		if (failure) return {
-			url: null,
-			reason: `caddy reload failed: ${failure}`
-		};
-	} else if (!await (options.running ?? caddyRunning)()) return {
-		url: null,
-		reason: "Caddy is not running; start it with `brew services start caddy`"
-	};
-	return { url: `https://${hostName(hub)}` };
-}
-/**
-* Remove {hub}.mainflow.localhost when the hub rooted at `root` is gone, so a dangling link does not stop Caddy
-* from loading every other site. Only a link that points into `root` is removed; the reload failure, if any,
-* is returned for the caller to log.
-*/
-function removeHostLink(root, hub, reload = reloadCaddy) {
-	const sites = caddySites();
-	if (!sites) return null;
-	const link = join(sites, `mainflow-${hub}.caddy`);
-	if (!lstatSync(link, { throwIfNoEntry: false })?.isSymbolicLink()) return null;
-	if (!resolve(dirname(link), readlinkSync(link)).startsWith(resolve(root) + "/")) return null;
-	rmSync(link);
-	return reload(sites);
-}
-/** The macOS app's bundle identifier, from apps/macos/scripts/package.sh. */
-const APP_BUNDLE_ID = "space.carlos.mainflow";
-/** Close the tabs Safari and Chrome opened on this hub's /open route; each browser only when it is running. */
-const closeOpenTabs = (hub) => {
-	const marker = `${hostName(hub)}/open/`;
-	return ["Safari", "Google Chrome"].map((app) => `if application "${app}" is running then
-  tell application "${app}"
-    repeat with w in (every window)
-      close (every tab of w whose URL contains "${marker}")
-    end repeat
-  end tell
-end if`).join("\n");
-};
-/**
-* Show an address of the hub's interface in the macOS app through its mainflow:// scheme (docs/app.md "連結").
-* A link in a reply reaches here through the default browser, so once the app has the address the browser tab
-* it left is closed and the app brought back to the front. Returns false when no app handles the scheme; the
-* caller then leaves the page to the browser. Does nothing and returns false outside macOS.
-*/
-function openInApp(hub, target, closeAfterMs = 150) {
-	if (process.platform !== "darwin") return false;
-	if (spawnSync("open", [`mainflow://${hub}${target}`]).status !== 0) return false;
-	setTimeout(() => {
-		spawnSync("osascript", ["-e", closeOpenTabs(hub)]);
-		spawn("open", ["-b", APP_BUNDLE_ID], {
-			detached: true,
-			stdio: "ignore"
-		}).on("error", () => {}).unref();
-	}, closeAfterMs);
-	return true;
-}
-//#endregion
-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 };