mainflow 0.23.0 → 0.25.0

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

@@ -1,7 +1,7 @@
-import { A as findingSchema, B as taskSchema, C as SURVEY_LINES, D as WORK_STATUS, E as TASK_SECTIONS, F as parseOpsLine, G as describeRequest, I as parseRef, J as grantRepo, K as grantCovers, L as refExample, M as issueSchema, N as mainlineSchema, O as configSchema, P as opsEntrySchema, R as refMainline, S as SLUG, T as TASK_REQUIRED_SECTIONS, V as waitingForRef, Y as parseGrantTarget, _ as MERGE_STATES, a as DECISION_SECTIONS, b as RESERVED_HUB_NAMES, c as FINDING_SECTIONS, f as ISSUE_SECTIONS, g as MAINLINE_STATUS, h as MAINLINE_SECTIONS, i as DECISION_BASES, j as formatOpsEntry, k as decisionSchema, l as FINDING_STATUS, n as CLOSED_STATUS, q as grantForm, r as DECIDERS, s as DEFAULT_CATEGORIES, t as CHECKLIST_REF, w as SURVEY_SECTION, x as SESSION_STATUS, y as REF_EXAMPLES, z as sessionSchema } from "./dist-Dy45myuN.js";
+import { $ as grantRepo, A as configSchema, B as parseUntil, C as SLUG, D as TASK_SECTIONS, E as TASK_REQUIRED_SECTIONS, F as mainlineSchema, G as waitingForAction, H as refMainline, I as opsEntrySchema, K as waitingForRef, L as parseActionRef, M as findingSchema, N as formatOpsEntry, P as issueSchema, Q as grantForm, R as parseOpsLine, S as SESSION_STATUS, T as SURVEY_SECTION, U as sessionSchema, V as refExample, W as taskSchema, X as describeRequest, Z as grantCovers, _ as MERGE_STATES, a as DECISION_SECTIONS, b as RESERVED_HUB_NAMES, c as FINDING_SECTIONS, et as parseGrantTarget, f as ISSUE_SECTIONS, g as MAINLINE_STATUS, h as MAINLINE_SECTIONS, i as DECISION_BASES, j as decisionSchema, k as WORK_STATUS, l as FINDING_STATUS, n as CLOSED_STATUS, r as DECIDERS, s as DEFAULT_CATEGORIES, t as CHECKLIST_REF, w as SURVEY_LINES, x as SESSION_ID, y as REF_EXAMPLES, z as parseRef } from "./dist-DlmecRLf.js";
 import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync, writeSync } from "node:fs";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { spawn, spawnSync } from "node:child_process";
+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
@@ -637,6 +637,7 @@ function loadHub(root, options = {}) {
 		mainlines.push({
 			...mainline,
 			dir: rel(mainlineDir),
+			artifacts: listFiles(join(mainlineDir, "artifacts")).map(rel),
 			views: listFiles(join(mainlineDir, "views")).map(rel),
 			decisions,
 			tasks
@@ -1387,6 +1388,50 @@ function splitActionRef(ref) {
 		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 must exist, so a session never points at work that is not in a mainline. Its
 * mainline must still be open: follow-up work on an ended one either reopens it with a criterion or task for the
@@ -1422,7 +1467,7 @@ function takeUnfinished(root, from, to, existing) {
 			...a,
 			id
 		});
-		const handedOff = `handed off to ${to}#${id}`;
+		const handedOff = handedOffNote(`${to}#${id}`);
 		return {
 			...a,
 			status: "dropped",
@@ -1443,7 +1488,7 @@ function takeUnfinished(root, from, to, existing) {
 */
 function startSession(root, input) {
 	const id = input.id ?? `${input.agent}-${randomBytes(4).toString("hex")}`;
-	if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) throw new WriteError(`session id "${id}" must be lowercase letters, digits and hyphens`);
+	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`);
@@ -1585,16 +1630,40 @@ function addAction(root, sessionId, input) {
 	});
 	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 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 },
@@ -1602,6 +1671,11 @@ function updateAction(root, ref, patch) {
 			...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;
@@ -1653,8 +1727,16 @@ function queueWarnings(root, session, cli) {
 }
 const current = (session) => session.actions.find((a) => a.status === "doing");
 const isOpen = (a) => a.status === "todo" || a.status === "doing";
-/** A blocked action and what it waits for; the note is where `action set --note` records the wait. */
-const waitingLine = (a) => `${a.id} ${a.do}${a.note ? `（${a.note}）` : ""}`;
+/** 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. */
@@ -1668,6 +1750,69 @@ function mayBeRunning(root, session) {
 		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 an item
+* this action also serves. 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 = theirs.serves.filter((ref) => action.serves.includes(ref));
+			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.
@@ -1704,6 +1849,7 @@ function sessionBriefing(root, session, options) {
 		const blocked = session.actions.filter((a) => a.status === "blocked");
 		if (blocked.length > 0) lines.push(`等外部條件：${blocked.map(waitingLine).join("；")}`);
 	}
+	lines.push(...waiterLines(root, session));
 	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}`));
@@ -1716,18 +1862,115 @@ function turnReminder(root, session, options) {
 	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("；")}。條件出現後用 ${options.cli} action set <a編號> --status doing 繼續；要先做別的事，用 ${options.cli} action add 列出行動。` : `[mainflow] ${session.id} 的行動都已結束。繼續工作前先用 ${options.cli} action add 列出下一個行動。`;
+	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 granted = grants.length > 0 ? ["- 目前行動服務的主脈絡預先授權了這些動作：", ...grants.map((g) => `  ${g}`)] : [];
 	return [
 		head,
-		...grants.length > 0 ? ["- 目前行動服務的主脈絡預先授權了這些動作：", ...grants.map((g) => `  ${g}`)] : [],
+		...waiterLines(root, session).map((w) => `- ${w}`),
+		...granted,
 		...marker,
 		...queueWarnings(root, session, options.cli).map((w) => `- ${w}`)
 	].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`);
@@ -2354,4 +2597,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { reopenIssue as $, addAction as A, transcriptPath as B, setCriterionText as C, updateTask as D, supersedeDecision as E, setSessionArchived as F, endsWithMarker as G, grantScope as H, setSessionInfo as I, appendOps as J, headerLine as K, setSessionStatus as L, handoffSession as M, loadSessions as N, sessionBriefing as O, readSession as P, planIssue as Q, settleSession as R, setCriterion as S, setMainlineTitle as T, matchGrants as U, updateAction as V, decorateReply as W, createFinding as X, closeIssue as Y, createIssue as Z, createTask as _, worktreesOf as _t, openInApp as a, dependencyGraph as at, setArchived as b, syncHost as c, refIndex as ct, setArchivedMany as d, ConflictError as dt, setFindingArchived as et, acceptDecision as f, WriteError as ft, createMainline as g, findHubRoot as gt, createDecision as h, currentBranch as ht, hostName as i, loadHub as it, ensureSession as j, turnReminder as k, migrateHub as l, MAINLINE_FILE as lt, addRepo as m, DATA_DIR as mt, DEFAULT_UI_PORT as n, setIssueArchived as nt, removeHostLink as o, mainlineEdges as ot, addHub as p, readYaml as pt, mayDecorate as q, caddySites as r, HubError as rt, siteBlock as s, linksInto as st, APP_BUNDLE_ID as t, setFindingStatus as tt, ARCHIVE_KINDS as u, TASK_FILE as ut, dropChecklistItem as v, setMainlineStatus as w, setChecklistItem as x, initHub as y, startSession as z };
+export { createIssue as $, sessionBriefing as A, settleSession as B, setCriterionText as C, updateTask as D, supersedeDecision as E, loadSessions as F, matchGrants as G, transcriptPath as H, readSession as I, headerLine as J, decorateReply as K, setSessionArchived as L, addAction as M, ensureSession as N, untilState as O, handoffSession as P, createFinding as Q, setSessionInfo as R, setCriterion as S, setMainlineTitle as T, updateAction as U, startSession as V, grantScope as W, appendOps as X, mayDecorate as Y, closeIssue as Z, createTask as _, currentBranch as _t, openInApp as a, HubError as at, setArchived as b, syncHost as c, mainlineEdges as ct, setArchivedMany as d, MAINLINE_FILE as dt, planIssue as et, acceptDecision as f, TASK_FILE as ft, createMainline as g, DATA_DIR as gt, createDecision as h, readYaml as ht, hostName as i, setIssueArchived as it, turnReminder as j, duplicateClaimLines as k, migrateHub as l, linksInto as lt, addRepo as m, WriteError as mt, DEFAULT_UI_PORT as n, setFindingArchived as nt, removeHostLink as o, loadHub as ot, addHub as p, ConflictError as pt, endsWithMarker as q, caddySites as r, setFindingStatus as rt, siteBlock as s, dependencyGraph as st, APP_BUNDLE_ID as t, reopenIssue as tt, ARCHIVE_KINDS as u, refIndex as ut, dropChecklistItem as v, findHubRoot as vt, setMainlineStatus as w, setChecklistItem as x, initHub as y, worktreesOf as yt, setSessionStatus as z };

package/dist/host.js

@@ -1,2 +1,2 @@
-import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-DkaCYnnc.js";
+import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-Dr0bCHd8.js";
 export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeHostLink, siteBlock, syncHost };

package/dist/{index-CV30LkNZ.d.ts → index-D4IIwDGE.d.ts}

@@ -23,5 +23,22 @@ interface SurveyLine {
   /** Text a checked line must contain, e.g. the environment a spike ran in. */
   requires?: string;
 }
+/**
+ * A condition a program can check, written `{kind}:{argument}`. `commit` holds once a commit message on the
+ * branch contains the text, `action-done` once the action is done, `file` once the path exists under the hub
+ * root. Git branch names cannot contain a colon, so the text after the branch may.
+ */
+type Until = {
+  kind: 'commit';
+  branch: string;
+  text: string;
+} | {
+  kind: 'action-done';
+  session: string;
+  action: string;
+} | {
+  kind: 'file';
+  path: string;
+};
 //#endregion
-export { SurveyLine as a, SLUG as i, FORMAT_VERSION as n, ID_PATTERNS as r, CHECKLIST_REF as t };
+export { SurveyLine as a, SLUG as i, FORMAT_VERSION as n, Until as o, ID_PATTERNS as r, CHECKLIST_REF as t };

package/dist/{launch-DOX1TTGx.js → launch-lnD-Z3hb.js}

@@ -1,4 +1,4 @@
-import { c as syncHost, ft as WriteError, i as hostName, mt as DATA_DIR, n as DEFAULT_UI_PORT, o as removeHostLink } from "./host-DkaCYnnc.js";
+import { c as syncHost, gt as DATA_DIR, i as hostName, mt as WriteError, n as DEFAULT_UI_PORT, o as removeHostLink } from "./host-Dr0bCHd8.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
@@ -176,7 +176,7 @@ async function launchUi(root, hub, configured, options) {
 	}
 	let server;
 	if (!reuse) {
-		const { serveUi } = await import("./ui-Do7fLlUC.js");
+		const { serveUi } = await import("./ui-Cz8suWal.js");
 		server = await serveUi(root, choice.port);
 		writeUiRecord(root, {
 			port: choice.port,

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as portCandidates, c as watchHubGone, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-DOX1TTGx.js";
+import { a as portCandidates, c as watchHubGone, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-lnD-Z3hb.js";
 export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readUiRecord, startUiInBackground, watchHubGone };

package/dist/{ui-Do7fLlUC.js → ui-Cz8suWal.js}

@@ -1,6 +1,6 @@
-import { B as transcriptPath, D as updateTask, F as setSessionArchived, N as loadSessions, P as readSession, S as setCriterion, T as setMainlineTitle, a as openInApp, at as dependencyGraph, b as setArchived, ct as refIndex, d as setArchivedMany, dt as ConflictError, et as setFindingArchived, ft as WriteError, it as loadHub, mt as DATA_DIR, nt as setIssueArchived, ot as mainlineEdges, st as linksInto, u as ARCHIVE_KINDS, w as setMainlineStatus, x as setChecklistItem } from "./host-DkaCYnnc.js";
+import { D as updateTask, F as loadSessions, H as transcriptPath, I as readSession, L as setSessionArchived, S as setCriterion, T as setMainlineTitle, a as openInApp, b as setArchived, ct as mainlineEdges, d as setArchivedMany, gt as DATA_DIR, it as setIssueArchived, lt as linksInto, mt as WriteError, nt as setFindingArchived, ot as loadHub, pt as ConflictError, st as dependencyGraph, u as ARCHIVE_KINDS, ut as refIndex, w as setMainlineStatus, x as setChecklistItem } from "./host-Dr0bCHd8.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { l as CLI_VERSION } from "./launch-DOX1TTGx.js";
+import { l as CLI_VERSION } from "./launch-lnD-Z3hb.js";
 import { createRequire } from "node:module";
 import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, watch } from "node:fs";
 import { basename, dirname, extname, join, normalize, relative, sep } from "node:path";