mainflow 0.35.0 → 0.37.0

package/dist/{host-bnHYIwuY.js → host-lY8ytTbw.js}

@@ -1,4 +1,4 @@
-import { $ as OFFSET, A as SURVEY_SECTION, B as issueSchema, C as REF_EXAMPLES, D as SESSION_STATUS, E as SESSION_ID, F as configSchema, G as parseRef, H as opsEntrySchema, I as decisionSchema, J as refMainline, K as parseUntil, L as findingSchema, M as TASK_SECTIONS, O as SLUG, P as WORK_STATUS, Q as waitingForRef, R as formatOpsEntry, S as PRIORITIES, T as SERVES_REF, U as parseActionRef, V as mainlineSchema, W as parseOpsLine, X as taskSchema, Y as sessionSchema, Z as waitingForAction, a as DECISION_SECTIONS, at as grantCovers, b as MAINLINE_STATUS, ct as parseGrantTarget, et as stampMs, f as GROUP_SECTIONS, h as ISSUE_SECTIONS, i as DECISION_BASES, it as describeRequest, j as TASK_REQUIRED_SECTIONS, k as SURVEY_LINES, l as FINDING_SECTIONS, n as CLOSED_STATUS, ot as grantForm, p as GROUP_STATUS, q as refExample, r as DECIDERS, s as DEFAULT_CATEGORIES, st as grantRepo, u as FINDING_STATUS, v as MAINLINE_ROLES, w as RESERVED_HUB_NAMES, x as MERGE_STATES, y as MAINLINE_SECTIONS, z as groupSchema } from "./dist-BdvWGTsb.js";
+import { $ as OFFSET, A as SURVEY_SECTION, B as issueSchema, C as REF_EXAMPLES, D as SESSION_STATUS, E as SESSION_ID, F as configSchema, G as parseRef, H as opsEntrySchema, I as decisionSchema, J as refMainline, K as parseUntil, L as findingSchema, M as TASK_SECTIONS, N as UNTIL_FORMS, O as SLUG, P as WORK_STATUS, Q as waitingForRef, R as formatOpsEntry, S as PRIORITIES, T as SERVES_REF, U as parseActionRef, V as mainlineSchema, W as parseOpsLine, X as taskSchema, Y as sessionSchema, Z as waitingForAction, a as DECISION_SECTIONS, at as grantCovers, b as MAINLINE_STATUS, ct as parseGrantTarget, et as stampMs, f as GROUP_SECTIONS, h as ISSUE_SECTIONS, i as DECISION_BASES, it as describeRequest, j as TASK_REQUIRED_SECTIONS, k as SURVEY_LINES, l as FINDING_SECTIONS, n as CLOSED_STATUS, ot as grantForm, p as GROUP_STATUS, q as refExample, r as DECIDERS, s as DEFAULT_CATEGORIES, st as grantRepo, u as FINDING_STATUS, v as MAINLINE_ROLES, w as RESERVED_HUB_NAMES, x as MERGE_STATES, y as MAINLINE_SECTIONS, z as groupSchema } from "./dist-ud09dzZo.js";
 import { a as LABEL_ROLES, i as FINDING_SEVERITIES, n as FINDING_CLASSES, r as FINDING_FIELDS, t as FINDINGS_FENCE } from "./retro-formats-ECy0gGOL.js";
 import { createHash } from "node:crypto";
 import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -137,6 +137,91 @@ const offlineIds = {
 	next: (request) => fresh(request, true)
 };
 //#endregion
+//#region ../core/dist/ops/unknown.js
+const isPlain = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const idOf = (value) => isPlain(value) && typeof value.id === "string" ? value.id : void 0;
+/** Keys that would reach the prototype instead of the data when assigned. */
+const UNSAFE_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function diff(raw, parsed) {
+	if (isPlain(raw) && isPlain(parsed)) {
+		const fields = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(raw)) if (!Object.hasOwn(parsed, key)) fields.set(key, {
+			kind: "value",
+			value
+		});
+		else {
+			const inner = diff(value, parsed[key]);
+			if (inner) fields.set(key, inner);
+		}
+		return fields.size > 0 ? {
+			kind: "object",
+			fields
+		} : void 0;
+	}
+	if (Array.isArray(raw) && Array.isArray(parsed)) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const element of raw) {
+			const id = idOf(element);
+			if (id !== void 0) counts.set(id, (counts.get(id) ?? 0) + 1);
+		}
+		const byId = /* @__PURE__ */ new Map();
+		for (const element of raw) {
+			const id = idOf(element);
+			if (id === void 0 || counts.get(id) !== 1) continue;
+			const matches = parsed.filter((p) => idOf(p) === id);
+			if (matches.length !== 1) continue;
+			const inner = diff(element, matches[0]);
+			if (inner) byId.set(id, inner);
+		}
+		return byId.size > 0 ? {
+			kind: "array",
+			byId
+		} : void 0;
+	}
+}
+/** The parts of `raw`, as it was read, that validation left out of `parsed`; undefined when nothing was dropped. */
+function strippedOf(raw, parsed) {
+	return diff(raw, parsed);
+}
+function put(target, stripped) {
+	if (stripped.kind === "object" && isPlain(target)) for (const [key, inner] of stripped.fields) {
+		if (UNSAFE_KEYS.has(key)) {
+			if (inner.kind === "value" && !Object.hasOwn(target, key)) Object.defineProperty(target, key, {
+				value: structuredClone(inner.value),
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			continue;
+		}
+		if (inner.kind === "value") {
+			if (!Object.hasOwn(target, key)) target[key] = structuredClone(inner.value);
+		} else if (Object.hasOwn(target, key)) put(target[key], inner);
+	}
+	else if (stripped.kind === "array" && Array.isArray(target)) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const element of target) {
+			const id = idOf(element);
+			if (id !== void 0) counts.set(id, (counts.get(id) ?? 0) + 1);
+		}
+		for (const element of target) {
+			const id = idOf(element);
+			const inner = id === void 0 || counts.get(id) !== 1 ? void 0 : stripped.byId.get(id);
+			if (inner) put(element, inner);
+		}
+	}
+}
+/** A copy of `next` with the stripped parts put back where the data has no value of its own. */
+function graft(next, stripped) {
+	const copy = structuredClone(next);
+	if (stripped) put(copy, stripped);
+	return copy;
+}
+//#endregion
 //#region ../core/dist/ops/draft.js
 const normalize$1 = (path) => path.split("/").filter(Boolean).join("/");
 const parentOf = (path) => normalize$1(path).split("/").slice(0, -1).join("/");
@@ -263,7 +348,11 @@ function commit(storage, changes) {
 		case "remove": storage.remove(change.path);
 	}
 }
-/** Run an operation on the hub as it is under the lock and apply its changes before the lock is released. */
+/**
+* Run an operation on the hub as it is under the lock and apply its changes before the lock is released. It does not
+* check the hub's data format: migrate must write a hub of another format, and the sync server's text patches
+* keep every field. The entries for operations (`runOp`, `applyOperation`) check it before they call this.
+*/
 function applyOp(storage, run) {
 	return storage.lock(() => {
 		const result = run(storage);
@@ -288,14 +377,20 @@ function readYamlIn(hub, path, schema) {
 function readFrontMatterIn(hub, path, schema) {
 	return validate(schema, splitFrontMatter(requireText(hub, path)).data, hub.where(path));
 }
+/** `next` with the fields the YAML document at `path` has beyond its schema put back; `current` is that document as validated. */
+function yamlKeeping(hub, path, current, next) {
+	return graft(next, strippedOf(parse$1(requireText(hub, path)), current));
+}
 /** Mutate, validate and stage a YAML document; `expectedVersion` refuses the change when the file moved on. */
 function editYaml(draft, path, schema, mutate, expectedVersion) {
 	const text = requireText(draft, path);
 	checkVersion(draft, path, text, expectedVersion);
-	const data = validate(schema, parse$1(text), draft.where(path));
+	const raw = parse$1(text);
+	const data = validate(schema, raw, draft.where(path));
+	const stripped = strippedOf(raw, data);
 	mutate(data);
 	const next = validate(schema, data, draft.where(path));
-	draft.write(path, toYaml(next));
+	draft.write(path, toYaml(graft(next, stripped)));
 	return next;
 }
 /** Mutate, validate and stage the front matter of a Markdown document; the body is kept unless `mutate` returns a new one. */
@@ -304,9 +399,10 @@ function editFrontMatter(draft, path, schema, mutate, expectedVersion) {
 	checkVersion(draft, path, text, expectedVersion);
 	const { data, body } = splitFrontMatter(text);
 	const current = validate(schema, data, draft.where(path));
+	const stripped = strippedOf(data, current);
 	const nextBody = mutate(current, body) ?? body;
 	const next = validate(schema, current, draft.where(path));
-	draft.write(path, frontMatterText(next, nextBody));
+	draft.write(path, frontMatterText(graft(next, stripped), nextBody));
 	return next;
 }
 //#endregion
@@ -364,6 +460,40 @@ function decisionFileIn(hub, mainline, decision) {
 }
 const sessionFileIn = (id) => `${SESSIONS_DIR}/${id}.yaml`;
 //#endregion
+//#region ../core/dist/ops/format.js
+/** Why a hub whose data format is `found` cannot be written by this CLI; null when it can. */
+function formatMismatch(found) {
+	if (found === 3) return null;
+	return found < 3 ? `data format version ${found} is older than this CLI's (3); run "mainflow migrate --dry-run" to preview the conversion, then "mainflow migrate"` : `data format version ${found} is newer than this CLI supports (3); install the matching mainflow version in this hub`;
+}
+/**
+* The data format config.yaml declares; null when the hub has no config.yaml or it names no number, which loading
+* the config reports. A config.yaml that is not YAML is a WriteError, so the sync server refuses the request
+* instead of failing on it.
+*/
+function hubFormatVersion(hub) {
+	const text = hub.read(CONFIG_FILE);
+	if (text === null) return null;
+	let data;
+	try {
+		data = parse$1(text);
+	} catch (error) {
+		throw new WriteError(`refusing to write: ${hub.where(CONFIG_FILE)} cannot be parsed as YAML: ${error.message}`);
+	}
+	const found = data?.formatVersion;
+	return typeof found === "number" ? found : null;
+}
+/**
+* Refuse a write to a hub whose data format is not the one this CLI writes: rewriting a document would drop what
+* another format keeps there. A hub without config.yaml is not checked, since `init` writes it.
+*/
+function requireWritableFormat(hub) {
+	const found = hubFormatVersion(hub);
+	if (found === null) return;
+	const reason = formatMismatch(found);
+	if (reason) throw new WriteError(`refusing to write: ${reason}`);
+}
+//#endregion
 //#region ../core/dist/ops/protocol.js
 /** `now` of a request: a local minute and its offset from UTC, `Z` for UTC itself. */
 const REQUEST_TIME = new RegExp(`^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2})(${OFFSET})$`);
@@ -584,7 +714,10 @@ const localContext = () => ({ now: nowMinute() });
 /** Run an operation on the hub at `root` under its write lock, apply its changes and return what it reports. */
 function runOp(root, run) {
 	const ctx = localContext();
-	return applyOp(nodeStorage(root), (hub) => run(hub, ctx)).value;
+	return applyOp(nodeStorage(root), (hub) => {
+		requireWritableFormat(hub);
+		return run(hub, ctx);
+	}).value;
 }
 /** Run an operation that must not take the lock, such as one creating the hub the lock would live in. */
 function runUnlocked(root, run) {
@@ -618,6 +751,7 @@ const mainlineDir = (root, id) => onDisk(root, mainlineDirIn(nodeStorage(root),
 const taskDir = (root, mainline, task) => onDisk(root, taskDirIn(nodeStorage(root), mainline, task));
 const mainlineFile = (root, id) => join(mainlineDir(root, id), MAINLINE_FILE);
 const taskFile = (root, mainline, task) => join(taskDir(root, mainline, task), TASK_FILE);
+const readConfig = (root) => readConfigIn(nodeStorage(root));
 //#endregion
 //#region ../core/dist/refs.js
 const itemStatus = (item) => item.done ? "done" : item.dropped ? "dropped" : "open";
@@ -706,6 +840,64 @@ function linksInto(hub, hubName) {
 	for (const g of hub.groups) add(g.id, g.links);
 	return out;
 }
+/**
+* Where a member's `group` value points: `id` is the group's id, and `hub` is the other hub's name, or undefined
+* for a group of the member's own hub (no prefix, or the member's own hub name as prefix).
+*/
+function splitGroup(value, ownHub) {
+	const colon = value.indexOf(":");
+	if (colon < 0) return { id: value };
+	const hub = value.slice(0, colon);
+	const id = value.slice(colon + 1);
+	return hub === ownHub ? { id } : {
+		hub,
+		id
+	};
+}
+/** Whether a member's `group` value names the group `groupId` of its own hub `ownHub`: `w001` or `{ownHub}:w001`. */
+function memberOfGroup(group, groupId, ownHub) {
+	if (group === void 0) return false;
+	const target = splitGroup(group, ownHub);
+	return target.hub === void 0 && target.id === groupId;
+}
+/**
+* The mainlines and issues of the registered hubs whose `group` names one of `hubName`'s groups, by group id. Only
+* the hubs' own documents are read, one level, so a hub that is not on this machine contributes nothing.
+*/
+function remoteMembers(remotes, hubName) {
+	const out = /* @__PURE__ */ new Map();
+	const add = (group, member) => {
+		if (!group) return;
+		const target = splitGroup(group, member.hub);
+		if (target.hub !== hubName) return;
+		out.set(target.id, [...out.get(target.id) ?? [], member]);
+	};
+	for (const r of remotes) {
+		if (!r.hub) continue;
+		for (const m of r.hub.mainlines) add(m.group, {
+			ref: `${r.name}:${m.id}`,
+			hub: r.name,
+			kind: "mainline",
+			title: m.title,
+			status: m.status,
+			role: m.role ?? "impl",
+			archived: Boolean(m.archivedAt),
+			open: !CLOSED_STATUS.mainline.includes(m.status)
+		});
+		for (const i of r.hub.issues) add(i.group, {
+			ref: `${r.name}:${i.id}`,
+			hub: r.name,
+			kind: "issue",
+			title: i.title,
+			status: i.status,
+			archived: Boolean(i.archivedAt),
+			open: i.status !== "closed"
+		});
+	}
+	return out;
+}
+/** The registered hubs that could not be loaded, for a reader that must say its member list may be incomplete. */
+const unavailableHubs = (remotes) => remotes.filter((r) => r.unavailable).map((r) => r.name);
 //#endregion
 //#region ../core/dist/deps.js
 const MET = /* @__PURE__ */ new Set([
@@ -972,7 +1164,8 @@ function loadConfig(root) {
 		message: issue.message
 	})));
 	const config = result.data;
-	if (config.formatVersion !== 3) throw new HubError(config.formatVersion < 3 ? `data format version ${config.formatVersion} is older than this CLI's (3); run "mainflow migrate --dry-run" to preview the conversion, then "mainflow migrate"` : `data format version ${config.formatVersion} is newer than this CLI supports (3); install the matching mainflow version in this hub`, []);
+	const mismatch = formatMismatch(config.formatVersion);
+	if (mismatch) throw new HubError(mismatch, []);
 	return config;
 }
 function loadHub(root, options = {}) {
@@ -1165,8 +1358,7 @@ function loadHub(root, options = {}) {
 	}
 	const findings = hubDocs(join(dataDir, "findings"), findingSchema);
 	const groups = hubDocs(join(dataDir, "groups"), groupSchema);
-	problems.push(...groupProblems(groups, mainlines, hubIssues, unreadable));
-	warnings.push(...groupWarnings(groups, mainlines, hubIssues));
+	problems.push(...groupProblems(config.hub, groups, mainlines, hubIssues, unreadable));
 	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) => {
@@ -1185,6 +1377,12 @@ function loadHub(root, options = {}) {
 		});
 	});
 	const remotes = options.remotes === false ? [] : loadRemotes(root, config, problems, warnings);
+	warnings.push(...groupWarnings(config.hub, groups, mainlines, hubIssues, remotes));
+	for (const doc of [...mainlines, ...hubIssues]) if (doc.group && splitGroup(doc.group, config.hub).hub !== void 0) pending.push({
+		ref: doc.group,
+		file: doc.file,
+		field: "group"
+	});
 	checkReferences({
 		config,
 		mainlines,
@@ -1238,20 +1436,32 @@ function loadHub(root, options = {}) {
 		remotes
 	};
 }
-/** Members name their group; one that names a group this hub does not have is reported on the member. */
-function groupProblems(groups, mainlines, issues, unreadable) {
+/** Members name their group; one that names a group this hub does not have is reported on the member. A group of another hub is checked with the other references. */
+function groupProblems(hubName, groups, mainlines, issues, unreadable) {
 	const known = new Set(groups.map((g) => g.id));
-	return [...mainlines, ...issues].flatMap((doc) => doc.group && !known.has(doc.group) && !unreadable.has(doc.group) ? [{
-		file: doc.file,
-		field: "group",
-		message: `group ${doc.group} does not exist; create it with "mainflow new group <slug> --title <title>" or name an existing one`
-	}] : []);
+	return [...mainlines, ...issues].flatMap((doc) => {
+		if (!doc.group) return [];
+		const { hub, id } = splitGroup(doc.group, hubName);
+		return hub === void 0 && !known.has(id) && !unreadable.has(id) ? [{
+			file: doc.file,
+			field: "group",
+			message: `group ${doc.group} does not exist; create it with "mainflow new group <slug> --title <title>" or name an existing one`
+		}] : [];
+	});
 }
-/** A group marked done while some of its members are still open: a plan to settle, not a broken file. */
-function groupWarnings(groups, mainlines, issues) {
+/**
+* A group marked done while some of its members are still open: a plan to settle, not a broken file. Members in
+* other hubs count too, when those hubs are on this machine.
+*/
+function groupWarnings(hubName, groups, mainlines, issues, remotes) {
+	const remote = remoteMembers(remotes, hubName);
 	return groups.flatMap((g) => {
 		if (g.status !== "done") return [];
-		const open = [...mainlines.filter((m) => m.group === g.id && isOpen$2("mainline", m.status)).map((m) => m.id), ...issues.filter((i) => i.group === g.id && i.status !== "closed").map((i) => i.id)];
+		const open = [
+			...mainlines.filter((m) => memberOfGroup(m.group, g.id, hubName) && isOpen$2("mainline", m.status)).map((m) => m.id),
+			...issues.filter((i) => memberOfGroup(i.group, g.id, hubName) && i.status !== "closed").map((i) => i.id),
+			...(remote.get(g.id) ?? []).filter((m) => m.open).map((m) => m.ref)
+		];
 		return open.length ? [{
 			file: g.file,
 			field: "status",
@@ -1648,12 +1858,18 @@ function requireExisting(hub, ref) {
 /** A priority as a command gives it, checked against P0 to P3. */
 const requirePriority = (value) => requireOneOf(value, PRIORITIES, "priority");
 /**
-* The group a member names, which must exist in this hub. `none` clears the membership; `null` is how a patch says
-* the same, so a command can pass the word and an interface the value.
+* The group a member names: one of this hub, which must exist, or one of another hub (`other-hub:w001`), which
+* only needs that hub registered here; the commands check the group itself when that hub is on this machine.
+* The hub's own name as prefix gives the group without it. `none` clears the membership; `null` is how a patch
+* says the same, so a command can pass the word and an interface the value.
 */
 function requireGroup(hub, value) {
 	const ref = requireRef(value, "group");
-	if (ref.hub !== void 0) throw new WriteError(`a group is one of this hub's, like w001; got "${value}"`);
+	const config = readConfigIn(hub);
+	if (ref.hub !== void 0 && ref.hub !== config.hub) {
+		if (!config.hubs?.[ref.hub]) throw new WriteError(`hub "${ref.hub}" is not registered; run "mainflow hub add ${ref.hub} <path>" first`);
+		return `${ref.hub}:${ref.group}`;
+	}
 	entryFile(hub, GROUPS_DIR, ref.group, "group");
 	return ref.group;
 }
@@ -2509,11 +2725,11 @@ function takeUnfinished(draft, ctx, from, to, existing, at) {
 			doneAt: at
 		};
 	});
-	draft.write(previousFile, toYaml(validate(sessionSchema, {
+	draft.write(previousFile, toYaml(yamlKeeping(draft, previousFile, previous, validate(sessionSchema, {
 		...previous,
 		status: "handed-off",
 		actions: left
-	}, draft.where(previousFile))));
+	}, draft.where(previousFile)))));
 	return carried;
 }
 /**
@@ -2596,7 +2812,7 @@ function handoffSession(hub, input, ctx) {
 		handoffFrom: from,
 		actions: [...session.actions, ...carried]
 	}, draft.where(file));
-	draft.write(file, toYaml(next));
+	draft.write(file, toYaml(yamlKeeping(draft, file, session, next)));
 	return draft.result(next);
 }
 function setSessionInfo(hub, input) {
@@ -2639,10 +2855,10 @@ function settleSession(hub, input) {
 		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;
-		draft.write(sessionFileIn(s.id), toYaml(validate(sessionSchema, {
+		draft.write(sessionFileIn(s.id), toYaml(yamlKeeping(draft, sessionFileIn(s.id), s, validate(sessionSchema, {
 			...s,
 			status: "ended"
-		}, draft.where(sessionFileIn(s.id)))));
+		}, draft.where(sessionFileIn(s.id))))));
 		if (s.id === id) result = "ended";
 	}
 	return draft.result(result);
@@ -2692,6 +2908,7 @@ function addAction(hub, input, ctx) {
 * to work that has since been handed off to this very action would otherwise wait forever.
 */
 function requireBlock(hub, ref, block) {
+	if (block.until !== void 0) requireMainlineTarget(hub, block.until);
 	const targets = [waitingForAction(block.waitingFor), block.until === void 0 ? void 0 : untilTarget(block.until)];
 	for (const target of targets) {
 		if (!target) continue;
@@ -2700,10 +2917,23 @@ function requireBlock(hub, ref, block) {
 		if (found.ref === ref) throw new WriteError(`action ${ref} cannot wait for itself${target === ref ? "" : ` (${target} was handed off to it)`}`);
 	}
 }
+/** A `mainline-done` condition has to name a mainline in this hub, or a hub registered here. */
+function requireMainlineTarget(hub, until) {
+	const parsed = parseUntil(until);
+	if (parsed?.kind !== "mainline-done") return;
+	const ref = parseRef(parsed.mainline);
+	if (ref?.kind !== "mainline") return;
+	const config = readConfigIn(hub);
+	if (ref.hub !== void 0 && ref.hub !== config.hub) {
+		if (!config.hubs?.[ref.hub]) throw new WriteError(`hub "${ref.hub}" is not registered; run "mainflow hub add ${ref.hub} <path>" first`);
+		return;
+	}
+	mainlineDirIn(hub, ref.mainline);
+}
 /** 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}"`);
+	if (!parsed) throw new WriteError(`--until takes a condition like ${UNTIL_FORMS.map((f) => f.format).join(", ")}, got "${until}"`);
 	return parsed.kind === "action-done" ? `${parsed.session}#${parsed.action}` : void 0;
 }
 function updateAction(hub, input, ctx) {
@@ -2980,7 +3210,10 @@ const OPERATIONS = {
 function applyOperation(storage, name, input, ctx) {
 	const operation = OPERATIONS[name];
 	if (!operation) throw new Error(`unknown operation "${String(name)}"`);
-	return applyOp(storage, (hub) => operation(hub, input, ctx));
+	return applyOp(storage, (hub) => {
+		requireWritableFormat(hub);
+		return operation(hub, input, ctx);
+	});
 }
 //#endregion
 //#region ../core/dist/ids/renumber.js
@@ -3917,11 +4150,78 @@ function actionState(root, ref) {
 		detail: `${ref}${via} is ${found.action.status}`
 	};
 }
+/**
+* Whether a mainline is done. It can no longer come true when the mainline was dropped, does not exist, or its
+* hub is not registered here. A registered hub that is missing on this machine or fails to load may return, so
+* that case keeps waiting. A prefix equal to this hub's own name reads the local hub.
+*/
+function mainlineState(root, text) {
+	const ref = parseRef(text);
+	if (ref?.kind !== "mainline") return {
+		met: false,
+		unreachable: true,
+		detail: `"${text}" is not a mainline reference like m001 or other-hub:m001`
+	};
+	let target = root;
+	try {
+		const config = readConfig(root);
+		if (ref.hub !== void 0 && ref.hub !== config.hub) {
+			const path = config.hubs?.[ref.hub];
+			if (path === void 0) return {
+				met: false,
+				unreachable: true,
+				detail: `hub "${ref.hub}" is not registered, so ${text} can never be read; run "mainflow hub add ${ref.hub} <path>"`
+			};
+			target = remoteRoot(root, path);
+			if (!isHubRoot(target)) return {
+				met: false,
+				detail: `hub "${ref.hub}" is not at ${path} on this machine, so ${text} cannot be read yet`
+			};
+		}
+	} catch (error) {
+		return {
+			met: false,
+			detail: `the hub config cannot be read, so ${text} cannot be checked: ${error.message}`
+		};
+	}
+	try {
+		mainlineDir(target, ref.mainline);
+	} catch {
+		return {
+			met: false,
+			unreachable: true,
+			detail: `mainline ${text} does not exist, so it will never be done`
+		};
+	}
+	let status;
+	try {
+		status = readFrontMatter(mainlineFile(target, ref.mainline), mainlineSchema).data.status;
+	} catch (error) {
+		return {
+			met: false,
+			detail: `mainline ${text} cannot be read yet: ${error.message}`
+		};
+	}
+	if (status === "done") return {
+		met: true,
+		detail: `mainline ${text} is done`
+	};
+	if (status === "dropped") return {
+		met: false,
+		unreachable: true,
+		detail: `mainline ${text} was dropped, so it will never be done`
+	};
+	return {
+		met: false,
+		detail: `mainline ${text} is ${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 "mainline-done": return mainlineState(root, until.mainline);
 		case "file": return existsSync(resolve(root, until.path)) ? {
 			met: true,
 			detail: `${until.path} exists`
@@ -7939,4 +8239,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { ACCESS_HEADERS as $, mayDecorate as A, applyOperation as B, readSession as C, decorateReply as D, matchGrants as E, renumberRequest as F, sectionText as G, HubError as H, renumberFiles as I, linksInto as J, dependencyGraph as K, renumberPath as L, traceTranscript as M, transcriptTitle as N, endsWithMarker as O, applyOffline as P, nodeStorage as Q, renumberText as R, loadSessions as S, grantScope as T, loadConfig as U, checkHubName as V, loadHub as W, nowMinute as X, refIndex as Y, readYaml as Z, initHub as _, DATA_DIR as _t, openInApp as a, comparePaths as at, sessionBriefing as b, splitFrontMatter as bt, siteBlock as c, requestTime as ct, retroReport as d, TASK_FILE as dt, BLOB_HASH as et, retroReportFromReceiver as f, requireSlug as ft, setArchivedMany as g, ConflictError as gt, ARCHIVE_KINDS as h, worktreesOf as ht, hostName as i, SOCKET_MAX_AGE_CLOSE as it, attributeTrace as j, headerLine as k, syncHost as l, textBytes as lt, RETRY_RULES as m, findHubRoot as mt, DEFAULT_UI_PORT as n, MAX_FILE_BYTES as nt, removeDanglingLinks as o, exceedsFileLimit as ot, receiverFromEnv as p, currentBranch as pt, mainlineEdges as q, caddySites as r, ROUTES as rt, removeHostLink as s, readsAsText as st, APP_BUNDLE_ID as t, MAX_BLOB_BYTES as tt, migrateHub as u, MAINLINE_FILE as ut, untilState as v, WriteError as vt, transcriptPath as w, turnReminder as x, duplicateClaimLines as y, contentHash as yt, scopeOfPath as z };
+export { nowMinute as $, mayDecorate as A, applyOperation as B, readSession as C, WriteError as Ct, decorateReply as D, matchGrants as E, renumberRequest as F, sectionText as G, HubError as H, renumberFiles as I, linksInto as J, dependencyGraph as K, renumberPath as L, traceTranscript as M, transcriptTitle as N, endsWithMarker as O, applyOffline as P, unavailableHubs as Q, renumberText as R, loadSessions as S, DATA_DIR as St, grantScope as T, splitFrontMatter as Tt, loadConfig as U, checkHubName as V, loadHub as W, refIndex as X, memberOfGroup as Y, remoteMembers as Z, initHub as _, requireSlug as _t, openInApp as a, MAX_FILE_BYTES as at, sessionBriefing as b, worktreesOf as bt, siteBlock as c, comparePaths as ct, retroReport as d, requestTime as dt, readYaml as et, retroReportFromReceiver as f, textBytes as ft, setArchivedMany as g, TASK_FILE as gt, ARCHIVE_KINDS as h, MAINLINE_FILE as ht, hostName as i, MAX_BLOB_BYTES as it, attributeTrace as j, headerLine as k, syncHost as l, exceedsFileLimit as lt, RETRY_RULES as m, hubFormatVersion as mt, DEFAULT_UI_PORT as n, ACCESS_HEADERS as nt, removeDanglingLinks as o, ROUTES as ot, receiverFromEnv as p, formatMismatch as pt, mainlineEdges as q, caddySites as r, BLOB_HASH as rt, removeHostLink as s, SOCKET_MAX_AGE_CLOSE as st, APP_BUNDLE_ID as t, nodeStorage as tt, migrateHub as u, readsAsText as ut, untilState as v, currentBranch as vt, transcriptPath as w, contentHash as wt, turnReminder as x, ConflictError as xt, duplicateClaimLines as y, findHubRoot as yt, scopeOfPath as z };

package/dist/host.js

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

package/dist/{index-DgYB5u1f.d.ts → index-B32s8PHu.d.ts}

@@ -250,7 +250,8 @@ type Task = z.infer<typeof taskSchema>;
 /**
  * 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.
+ * root, `mainline-done` once the mainline (`m{NNN}` or `{hub}:m{NNN}`) is done. Git branch names cannot contain a
+ * colon, so the text after the branch may.
  */
 type Until = {
   kind: 'commit';
@@ -263,6 +264,9 @@ type Until = {
 } | {
   kind: 'file';
   path: string;
+} | {
+  kind: 'mainline-done';
+  mainline: string;
 };
 /**
  * Why a blocked action cannot move, what it waits for, and the condition a program checks to end the wait.

package/dist/{launch-D80CYPcm.js → launch-3HLHjQF0.js}

@@ -1,4 +1,4 @@
-import { _t as DATA_DIR, i as hostName, l as syncHost, n as DEFAULT_UI_PORT, s as removeHostLink, vt as WriteError } from "./host-bnHYIwuY.js";
+import { Ct as WriteError, St as DATA_DIR, i as hostName, l as syncHost, n as DEFAULT_UI_PORT, s as removeHostLink } from "./host-lY8ytTbw.js";
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
@@ -276,7 +276,7 @@ async function launchUi(root, hub, configured, options) {
 		}
 		let server;
 		if (!reuse) {
-			const { serveUi } = await import("./ui-C4h4iLDu.js");
+			const { serveUi } = await import("./ui-AhBsqtZe.js");
 			server = await serveUi(root, choice.port);
 			writeUiRecord(root, {
 				port: choice.port,

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as networkProbe, c as realRoot, d as withUiLock, i as launchUi, l as startUiInBackground, n as choosePort, o as portCandidates, r as exitCodeFor, s as readUiRecord, t as PORT_SPAN, u as watchHubGone } from "./launch-D80CYPcm.js";
+import { a as networkProbe, c as realRoot, d as withUiLock, i as launchUi, l as startUiInBackground, n as choosePort, o as portCandidates, r as exitCodeFor, s as readUiRecord, t as PORT_SPAN, u as watchHubGone } from "./launch-3HLHjQF0.js";
 export { PORT_SPAN, choosePort, exitCodeFor, launchUi, networkProbe, portCandidates, readUiRecord, realRoot, startUiInBackground, watchHubGone, withUiLock };

package/dist/{operation-DVcJgKM9.js → operation-BZ7CHB6J.js}

@@ -1,4 +1,4 @@
-import { $ as ACCESS_HEADERS, B as applyOperation, F as renumberRequest, I as renumberFiles, L as renumberPath, P as applyOffline, Q as nodeStorage, R as renumberText, X as nowMinute, _t as DATA_DIR, at as comparePaths, bt as splitFrontMatter, ct as requestTime, et as BLOB_HASH, gt as ConflictError, it as SOCKET_MAX_AGE_CLOSE, lt as textBytes, nt as MAX_FILE_BYTES, ot as exceedsFileLimit, rt as ROUTES, st as readsAsText, tt as MAX_BLOB_BYTES, vt as WriteError, yt as contentHash, z as scopeOfPath } from "./host-bnHYIwuY.js";
+import { $ as nowMinute, B as applyOperation, Ct as WriteError, F as renumberRequest, I as renumberFiles, L as renumberPath, P as applyOffline, R as renumberText, St as DATA_DIR, Tt as splitFrontMatter, at as MAX_FILE_BYTES, ct as comparePaths, dt as requestTime, ft as textBytes, it as MAX_BLOB_BYTES, lt as exceedsFileLimit, nt as ACCESS_HEADERS, ot as ROUTES, rt as BLOB_HASH, st as SOCKET_MAX_AGE_CLOSE, tt as nodeStorage, ut as readsAsText, wt as contentHash, xt as ConflictError, z as scopeOfPath } from "./host-lY8ytTbw.js";
 import { createHash, randomBytes } from "node:crypto";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";

package/dist/{ui-C4h4iLDu.js → ui-AhBsqtZe.js}

@@ -1,8 +1,8 @@
-import { F as configSchema, f as GROUP_SECTIONS } from "./dist-BdvWGTsb.js";
-import { C as readSession, G as sectionText, H as HubError, J as linksInto, K as dependencyGraph, M as traceTranscript, N as transcriptTitle, S as loadSessions, U as loadConfig, W as loadHub, Y as refIndex, Z as readYaml, _t as DATA_DIR, a as openInApp, g as setArchivedMany, gt as ConflictError, h as ARCHIVE_KINDS, j as attributeTrace, q as mainlineEdges, vt as WriteError, w as transcriptPath } from "./host-bnHYIwuY.js";
+import { F as configSchema, f as GROUP_SECTIONS } from "./dist-ud09dzZo.js";
+import { C as readSession, Ct as WriteError, G as sectionText, H as HubError, J as linksInto, K as dependencyGraph, M as traceTranscript, N as transcriptTitle, S as loadSessions, St as DATA_DIR, U as loadConfig, W as loadHub, X as refIndex, Z as remoteMembers, a as openInApp, et as readYaml, g as setArchivedMany, h as ARCHIVE_KINDS, j as attributeTrace, q as mainlineEdges, w as transcriptPath, xt as ConflictError } from "./host-lY8ytTbw.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { A as isSynced, _ as readDaemon, a as remoteMode, b as readRemote, h as callDaemon, j as syncPaths, k as SYNC_DIR, m as DaemonUnavailable, n as hubWriter, r as writtenLines, y as watchTree } from "./operation-DVcJgKM9.js";
-import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-D80CYPcm.js";
+import { A as isSynced, _ as readDaemon, a as remoteMode, b as readRemote, h as callDaemon, j as syncPaths, k as SYNC_DIR, m as DaemonUnavailable, n as hubWriter, r as writtenLines, y as watchTree } from "./operation-BZ7CHB6J.js";
+import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-3HLHjQF0.js";
 import { createRequire } from "node:module";
 import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, extname, join, normalize, relative, resolve, sep } from "node:path";
@@ -23,7 +23,7 @@ const WRITE_HEADER = "x-mainflow-write";
 /** Every reference with a hub prefix in the documents of `hub`: links, origins and replaced items. */
 function prefixedRefs(hub) {
 	const refs = [];
-	const doc = (d) => refs.push(d.origin, ...(d.links ?? []).map((l) => l.to));
+	const doc = (d) => refs.push(d.origin, d.group, ...(d.links ?? []).map((l) => l.to));
 	for (const m of hub.mainlines) {
 		doc(m);
 		refs.push(...m.criteria.map((c) => c.supersededBy));
@@ -46,7 +46,13 @@ function relationsView(hub) {
 	const targets = {};
 	const graph = dependencyGraph(hub);
 	const depRefs = graph.edges.flatMap((e) => [e.from, e.to]);
-	for (const ref of /* @__PURE__ */ new Set([...prefixedRefs(hub), ...depRefs.filter((r) => r.includes(":"))])) {
+	const groupMembers = remoteMembers(hub.remotes, hub.config.hub);
+	const memberRefs = [...groupMembers.values()].flatMap((list) => list.map((m) => m.ref));
+	for (const ref of /* @__PURE__ */ new Set([
+		...prefixedRefs(hub),
+		...depRefs.filter((r) => r.includes(":")),
+		...memberRefs
+	])) {
 		const colon = ref.indexOf(":");
 		const name = ref.slice(0, colon);
 		const found = name === hub.config.hub ? own.get(ref.slice(colon + 1)) : indexes.get(name)?.get(ref.slice(colon + 1));
@@ -77,6 +83,7 @@ function relationsView(hub) {
 		targets,
 		backlinks,
 		deps: graph.edges,
+		groupMembers: Object.fromEntries(groupMembers),
 		mainlineDeps: mainlineEdges(graph),
 		cycles: graph.cycles
 	};