mainflow 0.44.0-alpha.3 → 0.44.0-alpha.4

package/dist/{host-CsZY5trM.js → host-CfBcUcg2.js}

@@ -1033,7 +1033,13 @@ const CONFIG_FILE = "config.yaml";
 const ISSUES_DIR = "issues";
 const FINDINGS_DIR = "findings";
 const GROUPS_DIR = "groups";
+/** The sessions settling a turn reads: those still running, paused, or ended while kept for their family (ENDED_SESSIONS_DIR). */
 const SESSIONS_DIR = "local/sessions";
+/**
+* The sessions that ended or were handed off, moved out of SESSIONS_DIR so the work a turn's end does follows the
+* sessions still under way, not every session the hub ever had. A session comes back to SESSIONS_DIR when it is resumed.
+*/
+const ENDED_SESSIONS_DIR = `${SESSIONS_DIR}/ended`;
 /** 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";
@@ -1079,7 +1085,16 @@ function decisionFileIn(hub, mainline, decision) {
 	if (!file) throw new WriteError(`decision ${mainline}/${decision} not found`);
 	return file;
 }
+/** Where the session `id` is kept while it is under way; one that ended may be in endedSessionFileIn instead. */
 const sessionFileIn = (id) => `${SESSIONS_DIR}/${id}.yaml`;
+/** Where the session `id` is kept once it ended or was handed off. */
+const endedSessionFileIn = (id) => `${ENDED_SESSIONS_DIR}/${id}.yaml`;
+/** The session a file in either session directory holds, by its path relative to the data directory; null for any other path. */
+function sessionIdOfPath(path) {
+	const parts = path.split("/");
+	const name = parts[0] === "local" && parts[1] === "sessions" ? parts.length === 3 ? parts[2] : parts.length === 4 && parts[2] === "ended" ? parts[3] : void 0 : void 0;
+	return name?.endsWith(".yaml") && name.length > 5 ? name.slice(0, -5) : null;
+}
 function groupFileIn(hub, id) {
 	const file = entryFileIn(hub, GROUPS_DIR, id);
 	if (!file) throw new WriteError(`group ${id} not found`);
@@ -3258,18 +3273,27 @@ function removeFile(hub, input) {
 }
 //#endregion
 //#region ../core/dist/ops/sessions.js
-/** Read every session; one that does not parse or validate is reported as a problem and skipped. */
-function readSessionsIn(hub) {
-	const sessions = [];
-	const problems = [];
-	for (const { name } of hub.list(SESSIONS_DIR).filter((e) => e.name.endsWith(".yaml"))) {
-		const path = `${SESSIONS_DIR}/${name}`;
+/** The statuses of a session that is done with; such a session is kept in ENDED_SESSIONS_DIR (belongsInEnded). */
+const FINISHED = ["ended", "handed-off"];
+/** Read the sessions in `dir`, those named in `skip` aside; one that does not parse or validate is reported as a problem and skipped. */
+function readSessionDirIn(hub, dir, out, skip = () => false) {
+	const names = hub.list(dir).filter((e) => !e.dir && e.name.endsWith(".yaml")).map((e) => e.name);
+	for (const name of names) {
+		const path = `${dir}/${name}`;
 		const file = `${DATA_DIR}/${path}`;
+		if (skip(name)) {
+			out.problems.push({
+				file,
+				field: "",
+				message: `the session is in ${DATA_DIR}/${SESSIONS_DIR}/ as well, which is the copy read; remove the copy that is out of date`
+			});
+			continue;
+		}
 		let data;
 		try {
 			data = parse$1(hub.read(path) ?? "");
 		} catch (error) {
-			problems.push({
+			out.problems.push({
 				file,
 				field: "",
 				message: `cannot parse YAML: ${error.message}`
@@ -3277,27 +3301,124 @@ function readSessionsIn(hub) {
 			continue;
 		}
 		const result = sessionSchema.safeParse(data);
-		if (result.success) sessions.push(result.data);
-		else for (const i of result.error.issues) problems.push({
+		if (!result.success) {
+			for (const i of result.error.issues) out.problems.push({
+				file,
+				field: i.path.join("."),
+				message: i.message
+			});
+			continue;
+		}
+		if (dir === ENDED_SESSIONS_DIR && !FINISHED.includes(result.data.status)) out.problems.push({
 			file,
-			field: i.path.join("."),
-			message: i.message
+			field: "status",
+			message: `${result.data.status}, but ${DATA_DIR}/${ENDED_SESSIONS_DIR}/ keeps only sessions that ended or were handed off; run "mainflow migrate" to move it back to ${DATA_DIR}/${SESSIONS_DIR}/`
 		});
+		out.sessions.push(result.data);
 	}
-	return {
-		sessions,
-		problems
+	return names;
+}
+/**
+* Read every session: those in local/sessions/ and, unless `ended` is false, those in local/sessions/ended/ too. One
+* that does not parse or validate is reported as a problem and skipped; so is a session in both directories, whose copy
+* in local/sessions/ is read. Settling a turn needs only the first directory; listing, checking and looking back over
+* past work need both.
+*/
+function readSessionsIn(hub, options = {}) {
+	const out = {
+		sessions: [],
+		problems: []
 	};
+	const names = new Set(readSessionDirIn(hub, SESSIONS_DIR, out));
+	if (options.ended !== false) readSessionDirIn(hub, ENDED_SESSIONS_DIR, out, (name) => names.has(name));
+	return out;
+}
+/** Where the session `id` is kept: local/sessions/ while under way, local/sessions/ended/ once ended; null for a session neither holds. */
+function sessionPathIn(hub, id) {
+	for (const path of [sessionFileIn(id), endedSessionFileIn(id)]) if (hub.read(path) !== null) return path;
+	return null;
 }
 function readSessionIn(hub, id) {
-	const path = sessionFileIn(id);
-	return hub.read(path) === null ? null : readYamlIn(hub, path, sessionSchema);
+	const path = sessionPathIn(hub, id);
+	return path === null ? null : readYamlIn(hub, path, sessionSchema);
 }
 function requireSession(hub, id) {
-	const path = sessionFileIn(id);
-	if (hub.read(path) === null) throw new WriteError(`session ${id} not found; start one with "mainflow session start"`);
+	const path = sessionPathIn(hub, id);
+	if (path === null) throw new WriteError(`session ${id} not found; start one with "mainflow session start"`);
 	return path;
 }
+function sessionLookup(hub, known = []) {
+	const cache = new Map(known.map((s) => [s.id, s]));
+	const lookup = (id) => {
+		if (!cache.has(id)) {
+			let found = null;
+			try {
+				found = readSessionIn(hub, id);
+			} catch {}
+			cache.set(id, found);
+		}
+		return cache.get(id);
+	};
+	return Object.assign(lookup, { set: (session) => void cache.set(session.id, session) });
+}
+/**
+* Whether a session belongs in local/sessions/ended/: it ended or was handed off, and each session it was delegated
+* from, up to the main session, tracked an action. Settling a session reads the subagents under it in local/sessions/
+* only (settleSession), and a subagent left there is one that may still decide it: a session whose family tracked no
+* action is removed with the family. A subagent moves out only once every session above it tracked an action, and no
+* write takes an action away, so none of them can be removed any more and the subagent, which no longer runs, changes
+* nothing settling decides. A subagent whose parent is missing or does not read stays, since nothing tells.
+*/
+function belongsInEnded(session, lookup) {
+	if (!FINISHED.includes(session.status)) return false;
+	const seen = /* @__PURE__ */ new Set([session.id]);
+	for (let parent = session.delegatedFrom; parent && !seen.has(parent);) {
+		seen.add(parent);
+		const above = lookup(parent);
+		if (!above || above.actions.length === 0) return false;
+		parent = above.delegatedFrom;
+	}
+	return true;
+}
+/** The path the session belongs at (belongsInEnded). */
+const placeOf = (session, lookup) => belongsInEnded(session, lookup) ? endedSessionFileIn(session.id) : sessionFileIn(session.id);
+/**
+* Where the session at `from` goes when it belongs at `to`: `from` itself when another file is at `to` already, as when
+* an older mainflow started the session again in local/sessions/ while it was in local/sessions/ended/. Writing there
+* would replace that copy, and the record it holds, so the session stays and the write says so; check lists both copies.
+*/
+function destination(draft, id, from, to) {
+	if (to === from || draft.read(to) === null) return to;
+	const message = `${DATA_DIR}/${to} holds session ${id} too, so ${DATA_DIR}/${from} stays where it is rather than replace it; keep the copy that is up to date and remove the other`;
+	if (!draft.notices.some((n) => n.path === from && n.message === message)) draft.notice(from, message);
+	return from;
+}
+/** Move the file at `from` to `to`, unchanged; nothing when they are the same or another file is at `to` (destination). */
+function moveFile(draft, id, from, to) {
+	if (destination(draft, id, from, to) === from) return;
+	draft.write(to, draft.read(from));
+	draft.remove(from);
+}
+/**
+* Write `next`, the session read as `current` from `from`, to the directory it belongs in now (belongsInEnded), keeping
+* the fields its file has beyond the schema; a session that moves is removed from `from`. One whose place another file
+* holds is written at `from` (destination).
+*/
+function writeSession(draft, from, current, next, lookup = sessionLookup(draft)) {
+	const to = destination(draft, next.id, from, placeOf(next, lookup));
+	draft.write(to, toYaml(yamlKeeping(draft, from, current, next)));
+	if (to !== from) draft.remove(from);
+	lookup.set(next);
+	return next;
+}
+/** Mutate, validate and write a session, which moves to the directory its new status puts it in (writeSession). */
+function editSession(draft, id, mutate, lookup) {
+	const from = requireSession(draft, id);
+	const current = readYamlIn(draft, from, sessionSchema);
+	const next = structuredClone(current);
+	mutate(next);
+	return writeSession(draft, from, current, validate(sessionSchema, next, draft.where(from)), lookup);
+}
 /** Split `claude-code-1a2b3c4d#a003` into its session and action ids. */
 function splitActionRef(ref) {
 	const hash = ref.lastIndexOf("#");
@@ -3412,11 +3533,11 @@ function takeUnfinished(draft, ctx, from, to, existing, at) {
 			doneAt: at
 		};
 	});
-	draft.write(previousFile, toYaml(yamlKeeping(draft, previousFile, previous, validate(sessionSchema, {
+	writeSession(draft, previousFile, previous, validate(sessionSchema, {
 		...previous,
 		status: "handed-off",
 		actions: left
-	}, draft.where(previousFile)))));
+	}, draft.where(previousFile)));
 	return carried;
 }
 /**
@@ -3429,7 +3550,7 @@ function startSession(hub, input, ctx) {
 	const { minute } = stamps(ctx);
 	const draft = new Draft(hub);
 	const file = sessionFileIn(id);
-	if (draft.read(file) !== null) throw new WriteError(`session ${id} already exists`);
+	if (sessionPathIn(draft, id) !== null) throw new WriteError(`session ${id} already exists`);
 	if (input.delegatedFrom) requireSession(draft, input.delegatedFrom);
 	const carried = input.handoffFrom ? takeUnfinished(draft, ctx, input.handoffFrom, id, [], minute) : [];
 	const session = validate(sessionSchema, {
@@ -3446,8 +3567,8 @@ function startSession(hub, input, ctx) {
 	return draft.result(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.
+* Start the session unless it already exists. An existing paused or ended session becomes active again, back in
+* local/sessions/, and an archived one comes back into view, since resumed work should not stay hidden.
 */
 function ensureSession(hub, input, ctx) {
 	const existing = readSessionIn(hub, input.id);
@@ -3466,7 +3587,7 @@ function ensureSession(hub, input, ctx) {
 		session: existing,
 		created: false
 	});
-	const session = editYaml(draft, requireSession(draft, input.id), sessionSchema, (s) => {
+	const session = editSession(draft, input.id, (s) => {
 		s.status = "active";
 		delete s.archivedAt;
 	});
@@ -3499,8 +3620,7 @@ function handoffSession(hub, input, ctx) {
 		handoffFrom: from,
 		actions: [...session.actions, ...carried]
 	}, draft.where(file));
-	draft.write(file, toYaml(yamlKeeping(draft, file, session, next)));
-	return draft.result(next);
+	return draft.result(writeSession(draft, file, session, next));
 }
 function setSessionInfo(hub, input) {
 	const draft = new Draft(hub);
@@ -3527,7 +3647,7 @@ function setCheckReported(hub, input) {
 function setSessionStatus(hub, input) {
 	const value = requireOneOf(input.status, SESSION_STATUS, "session status");
 	const draft = new Draft(hub);
-	return draft.result(editYaml(draft, requireSession(draft, input.id), sessionSchema, (s) => {
+	return draft.result(editSession(draft, input.id, (s) => {
 		s.status = value;
 	}));
 }
@@ -3536,28 +3656,99 @@ function setSessionStatus(hub, input) {
 * 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.
+*
+* Only the sessions in local/sessions/ are read, and the session itself wherever it is. An ended session moves to
+* local/sessions/ended/, with the finished subagents under it and under this session that belong there now
+* (belongsInEnded); a subagent already there cannot change what settling decides, so it is not read.
 */
 function settleSession(hub, input) {
 	const { id } = input;
 	const draft = new Draft(hub);
-	const { sessions } = readSessionsIn(draft);
-	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 { sessions } = readSessionsIn(draft, { ended: false });
+	const lookup = sessionLookup(draft, sessions);
+	/** Whether `session` was delegated from `parent`, directly or through other subagents. */
+	const isUnder = (session, parent) => {
+		const seen = /* @__PURE__ */ new Set([session.id]);
+		for (let above = session.delegatedFrom; above && !seen.has(above); above = lookup(above)?.delegatedFrom ?? null) {
+			if (above === parent) return true;
+			seen.add(above);
+		}
+		return false;
+	};
+	const subagents = (parent) => sessions.filter((s) => isUnder(s, parent));
+	const self = lookup(id);
+	const family = self ? [self, ...subagents(id)] : [];
 	const removed = family.length > 0 && family.every((s) => s.actions.length === 0);
-	if (removed) for (const s of family) draft.remove(sessionFileIn(s.id));
+	if (removed) for (const s of family) draft.remove(sessionPathIn(draft, s.id));
 	let result = removed ? "removed" : "kept";
+	const ended = [];
 	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;
-		draft.write(sessionFileIn(s.id), toYaml(yamlKeeping(draft, sessionFileIn(s.id), s, validate(sessionSchema, {
+		writeSession(draft, sessionFileIn(s.id), s, validate(sessionSchema, {
 			...s,
 			status: "ended"
-		}, draft.where(sessionFileIn(s.id))))));
+		}, draft.where(sessionFileIn(s.id))), lookup);
+		ended.push(s.id);
 		if (s.id === id) result = "ended";
 	}
+	const roots = [...self && !removed ? [id] : [], ...ended];
+	for (const s of sessions) {
+		if (roots.includes(s.id) || !roots.some((root) => isUnder(s, root)) || draft.read(sessionFileIn(s.id)) === null) continue;
+		moveFile(draft, s.id, sessionFileIn(s.id), placeOf(lookup(s.id), lookup));
+	}
+	if (self && !removed && sessionPathIn(draft, id) === sessionFileIn(id)) moveFile(draft, id, sessionFileIn(id), placeOf(lookup(id), lookup));
 	return draft.result(result);
 }
+/**
+* Move every session file to the directory it belongs in (belongsInEnded), as `mainflow migrate` does for a hub that
+* kept every session in local/sessions/: at most `limit` files, and never more than RELOCATE_BATCH, so a large hub moves
+* in several writes; `more` says another file is to move after them. `dryRun` moves none and lists them all. A file that
+* does not read, or that both directories hold, stays where it is; check reports it. Running it again once nothing is
+* left to move changes nothing.
+*/
+function relocateSessions$1(hub, input = {}) {
+	const draft = new Draft(hub);
+	const asked = typeof input.limit === "number" && Number.isFinite(input.limit) ? Math.floor(input.limit) : 500;
+	const limit = input.dryRun ? Infinity : Math.min(Math.max(1, asked), 500);
+	const lookup = sessionLookup(draft);
+	const value = {
+		ended: [],
+		resumed: [],
+		more: false
+	};
+	const names = (dir) => draft.list(dir).filter((e) => !e.dir && e.name.endsWith(".yaml")).map((e) => e.name.slice(0, -5));
+	const active = names(SESSIONS_DIR);
+	const ended = new Set(names(ENDED_SESSIONS_DIR));
+	const moves = [];
+	/** Plan the move of the file at `from`, if it is elsewhere than it belongs; false, with `more`, at a move past the limit. */
+	const consider = (id, from, list) => {
+		let session;
+		try {
+			session = readYamlIn(draft, from, sessionSchema);
+		} catch {
+			return true;
+		}
+		if (session.id !== id) return true;
+		lookup.set(session);
+		const to = placeOf(session, lookup);
+		if (to === from) return true;
+		if (moves.length >= limit) {
+			value.more = true;
+			return false;
+		}
+		moves.push([from, to]);
+		list.push(id);
+		return true;
+	};
+	for (const id of active) if (!ended.has(id) && !consider(id, sessionFileIn(id), value.ended)) break;
+	if (!value.more) {
+		for (const id of ended) if (!active.includes(id) && !consider(id, endedSessionFileIn(id), value.resumed)) break;
+	}
+	if (!input.dryRun) for (const [from, to] of moves) moveFile(draft, sessionIdOfPath(from), from, to);
+	return draft.result(value);
+}
 /** Archive or unarchive a session; the status stays as it is, so an ended session is visible until archived. */
 function setSessionArchived(hub, input, ctx) {
 	const { day } = stamps(ctx);
@@ -3581,7 +3772,7 @@ function addAction(hub, input, ctx) {
 	requireServes(hub, input.serves);
 	const draft = new Draft(hub);
 	let created = "";
-	editYaml(draft, requireSession(draft, input.session), sessionSchema, (s) => {
+	editSession(draft, input.session, (s) => {
 		created = draft.number(ctx, {
 			prefix: "a",
 			taken: s.actions.map((a) => a.id),
@@ -3933,8 +4124,9 @@ function migrateHub$1(hub) {
 /**
 * The operations by name, for a server that receives them from elsewhere. The names are the protocol's
 * (OPERATION_NAMES in protocol.ts): the table must hold every one of them and nothing else. `migrate` and `init`
-* are absent: migration rewrites the whole hub in one go and a new hub starts on the caller's machine, so neither
-* is sent as an operation.
+* are absent: migrating the data format rewrites the whole hub in one go and a new hub starts on the caller's machine,
+* so neither is sent as an operation. Moving the session files to where they belong, which `migrate` also does, is
+* one (`session.relocate`), sent again until nothing is left to move.
 */
 const OPERATIONS = {
 	"repo.add": addRepo,
@@ -3976,6 +4168,7 @@ const OPERATIONS = {
 	"session.checked": setCheckReported,
 	"session.set": setSessionStatus,
 	"session.settle": settleSession,
+	"session.relocate": relocateSessions$1,
 	"session.archive": setSessionArchived,
 	"action.add": addAction,
 	"action.set": updateAction,
@@ -4015,18 +4208,20 @@ function partsOf(path, dir) {
 	if (parts.some((part) => part === "" || part === "." || part === ".." || part === ".git")) return null;
 	return (dir ? parts : parts.slice(0, -1)).some((part) => OWN_DIRS.has(part)) ? null : parts;
 }
-/** Whether the file at `path` is synced: not in a directory never synced, not in local/ but local/sessions/, and not a transient name. */
+/** The directories of local/ whose files are synced: the sessions under way, and those that ended. */
+const SESSION_DIRS = [SESSIONS_DIR, ENDED_SESSIONS_DIR];
+/** Whether the file at `path` is synced: not in a directory never synced, not in local/ but the session directories, and not a transient name. */
 function syncedPath(path) {
 	const parts = partsOf(path, false);
 	if (parts === null) return false;
-	if (parts[0] === "local" && !(parts[1] === "sessions" && parts.length === 3)) return false;
+	if (parts[0] === "local" && !SESSION_DIRS.includes(parts.slice(0, -1).join("/"))) return false;
 	return !TRANSIENT.some((pattern) => pattern.test(parts.at(-1)));
 }
-/** Whether the directory at `path` may hold synced files, so a scan walks into it: local/ itself and local/sessions/ but nothing else in local/. */
+/** Whether the directory at `path` may hold synced files, so a scan walks into it: local/ itself and the session directories but nothing else in local/. */
 function mayHoldSynced(path) {
 	if (path === "") return true;
 	if (partsOf(path, true) === null) return false;
-	return path === "local" || !path.startsWith("local/") || path === "local/sessions";
+	return path === "local" || !path.startsWith("local/") || SESSION_DIRS.includes(path);
 }
 /** Whether the directory at `path` is synced: one that may hold synced files, apart from .mainflow/ and local/, which every machine has of its own. */
 const syncedDir = (path) => path !== "" && path !== "local" && mayHoldSynced(path);
@@ -4103,7 +4298,8 @@ const ENTRY = /^([mtdifw]\d{3})(-.+)$/;
 /** The scope of a file in the data directory, from its path: the mainline and task directories above it, or its session. */
 function scopeOfPath(path) {
 	const [top, second, third, fourth] = path.split("/");
-	if (top === "local" && second === "sessions" && third?.endsWith(".yaml") && fourth === void 0) return { session: third.slice(0, -5) };
+	const session = sessionIdOfPath(path);
+	if (session !== null) return { session };
 	if (top === "groups" && second && third === void 0) {
 		const group = ENTRY.exec(second)?.[1];
 		return group ? { group } : {};
@@ -4726,9 +4922,12 @@ function grantLines(dirs, session) {
 }
 //#endregion
 //#region ../core/dist/sessions.js
-/** Read every session under `.mainflow/local/sessions/`; sessions are local and never version-controlled. */
-function loadSessions(dirs) {
-	return readSessionsIn(nodeStorage(dirs));
+/**
+* Read every session under `.mainflow/local/sessions/`, and under `.mainflow/local/sessions/ended/` unless `ended` is
+* false, as for what only sessions under way matter to; sessions are local and never version-controlled.
+*/
+function loadSessions(dirs, options = {}) {
+	return readSessionsIn(nodeStorage(dirs), options);
 }
 function readSession(dirs, id) {
 	return readSessionIn(nodeStorage(dirs), id);
@@ -5078,7 +5277,7 @@ function duplicateClaimLines(dirs, sessionId, actionId) {
 * over into this one. Subagent sessions are left out: their work returns to the session that delegated it.
 */
 function handoffLines(dirs, session, cli) {
-	const others = loadSessions(dirs).sessions.filter((s) => s.id !== session.id && !s.delegatedFrom && !s.archivedAt && (s.status === "active" || s.status === "paused") && s.actions.some(isCarried));
+	const others = loadSessions(dirs, { ended: false }).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(dirs, s) ? "（15 分鐘內還有寫入對話紀錄，可能還在執行，不要接手）" : ""}：${s.actions.filter(isCarried).map((a) => `${a.id} ${a.do}（${a.status}，服務 ${a.serves.join("、") || "未指定"}）`).join("；")}`)];
 }
@@ -9170,6 +9369,31 @@ function migrateHub(dirs, options = {}) {
 		} : result;
 	}).value;
 }
+/**
+* Move the session files of a hub on disk to the directory each belongs in: those that ended to local/sessions/ended/,
+* any resumed one back. The files do not depend on the data format, so this runs on a hub of any format; with `dryRun`
+* it only lists the moves.
+*/
+function relocateSessions(dirs, options = {}) {
+	const storage = nodeStorage(dirs);
+	if (storage.read("config.yaml") === null) throw new WriteError(`no hub at ${dirs.root}; run mainflow init first`);
+	if (options.dryRun) return applyOp(storage, (hub) => ({
+		...relocateSessions$1(hub, { dryRun: true }),
+		changes: []
+	})).value;
+	const moved = {
+		ended: [],
+		resumed: [],
+		more: false
+	};
+	for (let more = true; more;) {
+		const batch = applyOp(storage, (hub) => relocateSessions$1(hub, { limit: 500 })).value;
+		moved.ended.push(...batch.ended);
+		moved.resumed.push(...batch.resumed);
+		more = batch.more;
+	}
+	return moved;
+}
 //#endregion
 //#region ../core/dist/migrate-data.js
 /** What the original data directory is renamed to, inside the hub repository, once the hub reads from its new place. */
@@ -9701,4 +9925,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { applyOperation as $, dataFile as $t, unhandledNotices as A, textBytes as At, attributeTrace as B, hubHoldingFile as Bt, duplicateClaimLines as C, ROUTES as Ct, markNoticesHandled as D, exceedsFileLimit as Dt, HANDLED_FILE as E, comparePaths as Et, matchGrants as F, MAINLINE_FILE as Ft, renumberFiles as G, registerHub as Gt, transcriptTitle as H, listHubs as Ht, decorateReply as I, SESSIONS_DIR as It, scopeOfPath as J, resolveHub as Jt, renumberPath as K, registeredName as Kt, endsWithMarker as L, TASK_FILE as Lt, readSession as M, hubFormatVersion as Mt, transcriptPath as N, hubRequirements as Nt, parseWarn as O, readsAsText as Ot, grantScope as P, versionMismatch as Pt, syncedPath as Q, currentBranch as Qt, headerLine as R, requireSlug as Rt, untilState as S, MAX_FILE_BYTES as St, turnReminder as T, VERSION_HEADER as Tt, applyOffline as U, notRegisteredMessage as Ut, traceTranscript as V, inRepositoryHubAt as Vt, renumberRequest as W, readRegistry as Wt, mayHoldSynced as X, userDataDir as Xt, hubDigest as Y, unregisterHub as Yt, syncedDir as Z, nodeStorage as Zt, receiverFromEnv as _, readYaml as _t, openInApp as a, DATA_DIR as an, loadMainlines as at, setArchivedMany as b, MAX_BLOB_BYTES as bt, siteBlock as c, splitFrontMatter as cn, mainlineEdges as ct, groupPlan as d, refIndex as dt, gitCheckout as en, checkHubName as et, listProgress as f, remoteMembers as ft, retroReportFromReceiver as g, readFrontMatter as gt, retroReport as h, nowMinute as ht, hostName as i, ConflictError as in, loadHub as it, loadSessions as j, formatMismatch as jt, readNotices as k, requestTime as kt, syncHost as l, linksInto as lt, migrateHub as m, taskFile as mt, DEFAULT_UI_PORT as n, realPath as nn, isOpenMainline as nt, removeDanglingLinks as o, WriteError as on, sectionText as ot, migrateHubData as p, unavailableHubs as pt, renumberText as q, registryFile as qt, caddySites as r, worktreesOf as rn, loadConfig as rt, removeHostLink as s, contentHash as sn, dependencyGraph as st, APP_BUNDLE_ID as t, hubPath as tn, HubError as tt, sessionView as u, memberOfGroup as ut, RETRY_RULES as v, ACCESS_HEADERS as vt, sessionBriefing as w, SOCKET_MAX_AGE_CLOSE as wt, initHub as x, MAX_CHANGE_PAGE as xt, ARCHIVE_KINDS as y, BLOB_HASH as yt, mayDecorate as z, hubAtRoot as zt };
+export { syncedPath as $, unregisterHub as $t, readNotices as A, requestTime as At, mayDecorate as B, endedSessionFileIn as Bt, untilState as C, MAX_FILE_BYTES as Ct, HANDLED_FILE as D, comparePaths as Dt, turnReminder as E, VERSION_HEADER as Et, grantScope as F, versionMismatch as Ft, renumberRequest as G, inRepositoryHubAt as Gt, traceTranscript as H, sessionFileIn as Ht, matchGrants as I, ENDED_SESSIONS_DIR as It, renumberText as J, readRegistry as Jt, renumberFiles as K, listHubs as Kt, decorateReply as L, MAINLINE_FILE as Lt, loadSessions as M, formatMismatch as Mt, readSession as N, hubFormatVersion as Nt, markNoticesHandled as O, exceedsFileLimit as Ot, transcriptPath as P, hubRequirements as Pt, syncedDir as Q, resolveHub as Qt, endsWithMarker as R, SESSIONS_DIR as Rt, initHub as S, MAX_CHANGE_PAGE as St, sessionBriefing as T, SOCKET_MAX_AGE_CLOSE as Tt, transcriptTitle as U, hubAtRoot as Ut, attributeTrace as V, requireSlug as Vt, applyOffline as W, hubHoldingFile as Wt, hubDigest as X, registeredName as Xt, scopeOfPath as Y, registerHub as Yt, mayHoldSynced as Z, registryFile as Zt, retroReportFromReceiver as _, readFrontMatter as _t, openInApp as a, hubPath as an, loadHub as at, ARCHIVE_KINDS as b, BLOB_HASH as bt, siteBlock as c, ConflictError as cn, dependencyGraph as ct, groupPlan as d, contentHash as dn, memberOfGroup as dt, userDataDir as en, applyOperation as et, listProgress as f, splitFrontMatter as fn, refIndex as ft, retroReport as g, nowMinute as gt, relocateSessions as h, taskFile as ht, hostName as i, gitCheckout as in, loadConfig as it, unhandledNotices as j, textBytes as jt, parseWarn as k, readsAsText as kt, syncHost as l, DATA_DIR as ln, mainlineEdges as lt, migrateHub as m, unavailableHubs as mt, DEFAULT_UI_PORT as n, currentBranch as nn, HubError as nt, removeDanglingLinks as o, realPath as on, loadMainlines as ot, migrateHubData as p, remoteMembers as pt, renumberPath as q, notRegisteredMessage as qt, caddySites as r, dataFile as rn, isOpenMainline as rt, removeHostLink as s, worktreesOf as sn, sectionText as st, APP_BUNDLE_ID as t, nodeStorage as tn, checkHubName as tt, sessionView as u, WriteError as un, linksInto as ut, receiverFromEnv as v, readYaml as vt, duplicateClaimLines as w, ROUTES as wt, setArchivedMany as x, MAX_BLOB_BYTES as xt, RETRY_RULES as y, ACCESS_HEADERS as yt, headerLine as z, TASK_FILE as zt };

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { o as HubDirs } from "./index-jq7lN8V8.js";
+import { o as HubDirs } from "./index-lsW80LDU.js";
 //#region src/host.d.ts
 export declare const DEFAULT_UI_PORT = 4320;
 export declare const hostName: (hub: string) => string;

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-CsZY5trM.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-CfBcUcg2.js";
 export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeDanglingLinks, removeHostLink, siteBlock, syncHost };

package/dist/{index-jq7lN8V8.d.ts → index-lsW80LDU.d.ts}

@@ -414,8 +414,8 @@ interface SessionInput {
  */
 declare function startSession(hub: HubReader, input: SessionInput, ctx: OpContext): OpResult<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.
+ * Start the session unless it already exists. An existing paused or ended session becomes active again, back in
+ * local/sessions/, and an archived one comes back into view, since resumed work should not stay hidden.
  */
 declare function ensureSession(hub: HubReader, input: SessionInput, ctx: OpContext): OpResult<{
   session: Session;
@@ -457,10 +457,31 @@ type Settled = 'removed' | 'ended' | 'kept';
  * 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.
+ *
+ * Only the sessions in local/sessions/ are read, and the session itself wherever it is. An ended session moves to
+ * local/sessions/ended/, with the finished subagents under it and under this session that belong there now
+ * (belongsInEnded); a subagent already there cannot change what settling decides, so it is not read.
  */
 declare function settleSession(hub: HubReader, input: {
   id: string;
 }): OpResult<Settled>;
+/** What relocating the session files moved: the sessions moved to local/sessions/ended/, those moved back, and whether more are left. */
+interface Relocated {
+  ended: string[];
+  resumed: string[];
+  more: boolean;
+}
+/**
+ * Move every session file to the directory it belongs in (belongsInEnded), as `mainflow migrate` does for a hub that
+ * kept every session in local/sessions/: at most `limit` files, and never more than RELOCATE_BATCH, so a large hub moves
+ * in several writes; `more` says another file is to move after them. `dryRun` moves none and lists them all. A file that
+ * does not read, or that both directories hold, stays where it is; check reports it. Running it again once nothing is
+ * left to move changes nothing.
+ */
+declare function relocateSessions(hub: HubReader, input?: {
+  dryRun?: boolean;
+  limit?: number;
+}): OpResult<Relocated>;
 /** Archive or unarchive a session; the status stays as it is, so an ended session is visible until archived. */
 declare function setSessionArchived(hub: HubReader, input: {
   id: string;
@@ -495,15 +516,16 @@ declare function updateAction(hub: HubReader, input: {
  * (`item check` and `item uncheck` send `item.check`, with done true or false). The operations no command sends
  * are listed in COMMANDLESS_OPERATIONS with who sends them.
  */
-declare const OPERATION_NAMES: readonly ['repo.add', 'hub.add', 'mainline.new', 'mainline.set', 'mainline.title', 'mainline.archive', 'criterion.add', 'criterion.check', 'criterion.set', 'task.new', 'task.set', 'item.add', 'item.check', 'item.drop', 'item.undrop', 'decision.new', 'decision.accept', 'decision.supersede', 'issue.new', 'issue.set', 'issue.plan', 'issue.close', 'issue.reopen', 'issue.archive', 'finding.new', 'finding.set', 'finding.archive', 'group.new', 'group.set', 'ops.add', 'section.append', 'session.start', 'session.ensure', 'session.handoff', 'session.info', 'session.reminder', 'session.checked', 'session.set', 'session.settle', 'session.archive', 'action.add', 'action.set', 'file.remove'];
+declare const OPERATION_NAMES: readonly ['repo.add', 'hub.add', 'mainline.new', 'mainline.set', 'mainline.title', 'mainline.archive', 'criterion.add', 'criterion.check', 'criterion.set', 'task.new', 'task.set', 'item.add', 'item.check', 'item.drop', 'item.undrop', 'decision.new', 'decision.accept', 'decision.supersede', 'issue.new', 'issue.set', 'issue.plan', 'issue.close', 'issue.reopen', 'issue.archive', 'finding.new', 'finding.set', 'finding.archive', 'group.new', 'group.set', 'ops.add', 'section.append', 'session.start', 'session.ensure', 'session.handoff', 'session.info', 'session.reminder', 'session.checked', 'session.set', 'session.settle', 'session.relocate', 'session.archive', 'action.add', 'action.set', 'file.remove'];
 type OperationName = (typeof OPERATION_NAMES)[number];
 //#endregion
 //#region ../core/dist/ops/operations.d.ts
 /**
  * The operations by name, for a server that receives them from elsewhere. The names are the protocol's
  * (OPERATION_NAMES in protocol.ts): the table must hold every one of them and nothing else. `migrate` and `init`
- * are absent: migration rewrites the whole hub in one go and a new hub starts on the caller's machine, so neither
- * is sent as an operation.
+ * are absent: migrating the data format rewrites the whole hub in one go and a new hub starts on the caller's machine,
+ * so neither is sent as an operation. Moving the session files to where they belong, which `migrate` also does, is
+ * one (`session.relocate`), sent again until nothing is left to move.
  */
 declare const OPERATIONS: {
   readonly 'repo.add': typeof addRepo;
@@ -545,6 +567,7 @@ declare const OPERATIONS: {
   readonly 'session.checked': typeof setCheckReported;
   readonly 'session.set': typeof setSessionStatus;
   readonly 'session.settle': typeof settleSession;
+  readonly 'session.relocate': typeof relocateSessions;
   readonly 'session.archive': typeof setSessionArchived;
   readonly 'action.add': typeof addAction;
   readonly 'action.set': typeof updateAction;

package/dist/launch.d.ts

@@ -1,4 +1,4 @@
-import { o as HubDirs } from "./index-jq7lN8V8.js";
+import { o as HubDirs } from "./index-lsW80LDU.js";
 import { HostOptions } from "./host.js";
 import { ServerType } from "@hono/node-server";
 //#region src/launch.d.ts

package/dist/launch.js

@@ -1,4 +1,4 @@
-import { i as hostName, l as syncHost, n as DEFAULT_UI_PORT, on as WriteError, s as removeHostLink } from "./host-CsZY5trM.js";
+import { i as hostName, l as syncHost, n as DEFAULT_UI_PORT, s as removeHostLink, un as WriteError } from "./host-CfBcUcg2.js";
 import { t as CLI_VERSION } from "./version-Dvv4jwF1.js";
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
@@ -273,7 +273,7 @@ async function launchUi(dirs, hub, configured, options) {
 		}
 		let server;
 		if (!reuse) {
-			const { serveUi } = await import("./ui-Bv29R0WG.js");
+			const { serveUi } = await import("./ui-CnNAOM_Y.js");
 			server = await serveUi(dirs, choice.port);
 			writeUiRecord(dirs, {
 				port: choice.port,

package/dist/{operation-BroV98VB.d.ts → operation-BTQm13OQ.d.ts}

@@ -1,4 +1,4 @@
-import { a as Renumbering, i as Notice, n as OperationValue, r as OperationName, t as OperationInput } from "./index-jq7lN8V8.js";
+import { a as Renumbering, i as Notice, n as OperationValue, r as OperationName, t as OperationInput } from "./index-lsW80LDU.js";
 //#region src/remote/operation.d.ts
 /** What a write reports: the operation's value, and what its caller tells the user about it. */
 interface Written<N extends OperationName = OperationName> {

package/dist/{operation-MKNwQkAY.js → operation-BmNzQC-L.js}

@@ -1,4 +1,4 @@
-import { $ as applyOperation, At as textBytes, Ct as ROUTES, Dt as exceedsFileLimit, Et as comparePaths, G as renumberFiles, J as scopeOfPath, K as renumberPath, Kt as registeredName, Nt as hubRequirements, Ot as readsAsText, Pt as versionMismatch, Q as syncedPath, St as MAX_FILE_BYTES, Tt as VERSION_HEADER, U as applyOffline, W as renumberRequest, X as mayHoldSynced, Y as hubDigest, Z as syncedDir, Zt as nodeStorage, bt as MAX_BLOB_BYTES, cn as splitFrontMatter, ht as nowMinute, in as ConflictError, kt as requestTime, on as WriteError, q as renumberText, sn as contentHash, vt as ACCESS_HEADERS, wt as SOCKET_MAX_AGE_CLOSE, yt as BLOB_HASH } from "./host-CsZY5trM.js";
+import { $ as syncedPath, At as requestTime, Ct as MAX_FILE_BYTES, Dt as comparePaths, Et as VERSION_HEADER, Ft as versionMismatch, G as renumberRequest, J as renumberText, K as renumberFiles, Ot as exceedsFileLimit, Pt as hubRequirements, Q as syncedDir, Tt as SOCKET_MAX_AGE_CLOSE, W as applyOffline, X as hubDigest, Xt as registeredName, Y as scopeOfPath, Z as mayHoldSynced, bt as BLOB_HASH, cn as ConflictError, dn as contentHash, et as applyOperation, fn as splitFrontMatter, gt as nowMinute, jt as textBytes, kt as readsAsText, q as renumberPath, tn as nodeStorage, un as WriteError, wt as ROUTES, xt as MAX_BLOB_BYTES, yt as ACCESS_HEADERS } from "./host-CfBcUcg2.js";
 import { t as CLI_VERSION } from "./version-Dvv4jwF1.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, rmdirSync, statSync, watch, writeFileSync } from "node:fs";