mainflow 0.44.0-alpha.2 → 0.44.0-alpha.4

package/dist/{host-C74j2Qox.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 } : {};
@@ -4435,6 +4631,17 @@ function pathOf(ref, target) {
 	}
 }
 const sessionPath = (id) => `/sessions/${id}`;
+/** Where a mainline's file shows on the hub's interface, under the mainline's own address. */
+const mainlineFilePath = (mainline, file) => `/mainlines/${mainline}/files/${file}`;
+/** The interface address of every reference the hub has a page or panel for, keyed by the reference. */
+function refPaths(hub) {
+	const paths = {};
+	for (const [ref, target] of refIndex(hub)) {
+		const path = pathOf(ref, target);
+		if (path) paths[ref] = path;
+	}
+	return paths;
+}
 /** Fenced blocks, inline code, markdown links and bare URLs: text inside them is left as written. */
 const PROTECTED = /(```[\s\S]*?(?:```|$)|`[^`\n]*`|\[[^\]\n]*\]\([^)\n]*\)|https?:\/\/\S+)/;
 /** A file under a mainline directory, or a reference to a mainline, task, decision, issue, finding or group. */
@@ -4443,7 +4650,7 @@ const MENTION = /\.mainflow\/(?:[a-z0-9-]+\/)?mainlines\/(m\d{3})-[\w-]+\/([^\s`
 function linkMentions(text, context) {
 	const index = refIndex(context.hub);
 	return text.split(PROTECTED).map((part, i) => i % 2 === 1 ? part : part.replace(MENTION, (all, m, file, ref) => {
-		if (m && file) return index.has(m) ? `[${m}/${file}](${context.link(`/mainlines/${m}/files/${file}`)})` : all;
+		if (m && file) return index.has(m) ? `[${m}/${file}](${context.link(mainlineFilePath(m, file))})` : all;
 		const target = ref ? index.get(ref) : void 0;
 		const path = ref && target ? pathOf(ref, target) : null;
 		return path ? `[${ref}](${context.link(path)})` : all;
@@ -4715,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);
@@ -5067,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("；")}`)];
 }
@@ -5145,9 +5355,10 @@ function sessionBriefing(dirs, session, options) {
 * The reminder for every user turn; null when there is nothing to say, or when it would be the same text as the
 * reminder the model was last given. Records a digest of the whole text in the session file, only when it changes;
 * `saveDigest` records it instead of writing the file here, as a host hook in remote mode sends it to the sync server.
+* `displayMod` leaves out the sentence that asks for the header line, for a host whose mod shows the current action.
 */
 function turnReminder(dirs, session, options) {
-	const text = reminderText(dirs, session, options.cli);
+	const text = reminderText(dirs, session, options.cli, options.displayMod === true);
 	if (text === null) return null;
 	const digest = contentHash(text);
 	if (session.reminderDigest === digest) return null;
@@ -5157,13 +5368,13 @@ function turnReminder(dirs, session, options) {
 	} catch {}
 	return text;
 }
-function reminderText(dirs, session, cli) {
+function reminderText(dirs, session, cli, displayMod) {
 	if (session.actions.length === 0) return openMainlines(dirs).length > 0 ? `[mainflow] ${session.id} 還沒有行動。這一輪要推進主脈絡時，先用 ${cli} action add 列出行動並標為 doing，或用 ${cli} session handoff <會話> 接手上一場沒做完的行動，再開始做。回覆結尾的標頭只看這場會話進行中的行動。` : null;
 	const doing = current(session);
 	const open = session.actions.filter(isOpen);
 	const blocked = session.actions.filter((a) => a.status === "blocked");
 	const head = doing ? `[mainflow] 目前行動 ${doing.id} ${doing.do}，服務 ${doing.serves.join("、") || "（未指定）"}。這一輪的工作若不屬於它，先調整佇列再做。` : open.length > 0 ? `[mainflow] ${session.id} 目前沒有進行中的行動。` : blocked.length > 0 ? `[mainflow] ${session.id} 的行動在等外部條件：${blocked.map(waitingLine).join("；")}。有條件（until）的可以在背景執行 ${cli} wait <a編號> 等它成立。條件出現後用 ${cli} action set <a編號> --status doing 繼續；要先做別的事，用 ${cli} action add 列出行動。` : `[mainflow] ${session.id} 的行動都已結束。繼續工作前先用 ${cli} action add 列出下一個行動。`;
-	const header = headerLine(session);
+	const header = displayMod ? null : headerLine(session);
 	const marker = header ? [`- 這一輪最後一則回覆的最後一行寫「${header}」，回覆範例等其他內容都放在它前面。有顯示 hook 時，它會換成標題與連結。`] : [];
 	const grants = grantLines(dirs, session);
 	const granted = grants.length > 0 ? ["- 目前行動服務的主脈絡與所屬的組預先授權了這些動作：", ...grants.map((g) => `  ${g}`)] : [];
@@ -9158,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. */
@@ -9330,6 +9566,15 @@ function copyData(source, target) {
 	return target;
 }
 //#endregion
+//#region ../core/dist/progress.js
+function listProgress(items) {
+	const counted = items.filter((item) => !item.dropped);
+	return {
+		done: counted.filter((item) => item.done).length,
+		total: counted.length
+	};
+}
+//#endregion
 //#region ../core/dist/group-plan.js
 /** Sessions that can still hold work: not archived, and active or paused. */
 const live = (s) => !s.archivedAt && (s.status === "active" || s.status === "paused");
@@ -9401,6 +9646,87 @@ function groupPlan(hub, sessions, groupId) {
 	};
 }
 //#endregion
+//#region ../core/dist/session-view.js
+const unfinished = (a) => a.status === "todo" || a.status === "doing" || a.status === "blocked";
+/** The mainline and task a served reference points into; criteria of a group name neither. */
+function targetOf(ref) {
+	const parsed = parseRef(ref);
+	if (parsed?.kind === "checklistItem") return {
+		mainline: parsed.mainline,
+		task: parsed.task
+	};
+	if (parsed?.kind === "criterion") return { mainline: parsed.mainline };
+	return null;
+}
+const taskProgress = (m) => {
+	const parts = m.tasks.map((t) => listProgress(t.checklist));
+	return {
+		done: parts.reduce((n, p) => n + p.done, 0),
+		total: parts.reduce((n, p) => n + p.total, 0)
+	};
+};
+function sessionView({ hub, session, url, link, sync }) {
+	const actions = session?.actions ?? [];
+	const lead = actions.find((a) => a.status === "doing") ?? actions.find(unfinished);
+	const doing = actions.find((a) => a.status === "doing");
+	const focusTarget = lead?.serves.map(targetOf).find((t) => t !== null) ?? null;
+	const focusMainline = focusTarget ? hub.mainlines.find((m) => m.id === focusTarget.mainline) : void 0;
+	const serving = new Set((doing?.serves ?? []).flatMap((s) => targetOf(s) ?? []).filter((t) => t.task).map((t) => `${t.mainline}/${t.task}`));
+	const mainlinePath = (id) => `/mainlines/${id}`;
+	return {
+		hub: {
+			name: hub.config.hub,
+			url,
+			open: link("")
+		},
+		refs: refPaths(hub),
+		session: session ? {
+			id: session.id,
+			actions: actions.map((a) => ({
+				id: a.id,
+				do: a.do,
+				status: a.status,
+				serves: a.serves,
+				waiting: a.blockedBy ? {
+					reason: a.blockedBy.reason,
+					waitingFor: a.blockedBy.waitingFor ?? null,
+					until: a.blockedBy.until ?? null
+				} : null
+			})),
+			progress: {
+				done: actions.filter((a) => a.status === "done").length,
+				total: actions.filter((a) => a.status !== "dropped").length
+			}
+		} : null,
+		focus: focusMainline ? {
+			id: focusMainline.id,
+			title: focusMainline.title,
+			status: focusMainline.status,
+			criteria: listProgress(focusMainline.criteria),
+			checklist: taskProgress(focusMainline),
+			link: link(mainlinePath(focusMainline.id))
+		} : null,
+		tasks: (focusMainline?.tasks ?? []).map((t) => ({
+			mainline: focusMainline.id,
+			id: t.id,
+			title: t.title,
+			status: t.status,
+			checklist: listProgress(t.checklist),
+			link: link(`${mainlinePath(focusMainline.id)}/tasks/${t.id}`),
+			serving: serving.has(`${focusMainline.id}/${t.id}`)
+		})),
+		mainlines: hub.mainlines.filter(isOpenMainline).map((m) => ({
+			id: m.id,
+			title: m.title,
+			status: m.status,
+			group: m.group ?? null,
+			checklist: taskProgress(m),
+			link: link(mainlinePath(m.id))
+		})),
+		sync
+	};
+}
+//#endregion
 //#region src/host.ts
 const DEFAULT_UI_PORT = 4320;
 const hostName = (hub) => `${hub}.mainflow.localhost`;
@@ -9599,4 +9925,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { isOpenMainline as $, realPath as $t, transcriptPath as A, hubRequirements as At, applyOffline as B, notRegisteredMessage as Bt, turnReminder as C, comparePaths as Ct, readNotices as D, textBytes as Dt, parseWarn as E, requestTime as Et, headerLine as F, requireSlug as Ft, scopeOfPath as G, resolveHub as Gt, renumberFiles as H, registerHub as Ht, mayDecorate as I, hubAtRoot as It, syncedDir as J, nodeStorage as Jt, hubDigest as K, unregisterHub as Kt, attributeTrace as L, hubHoldingFile as Lt, matchGrants as M, MAINLINE_FILE as Mt, decorateReply as N, SESSIONS_DIR as Nt, loadSessions as O, formatMismatch as Ot, endsWithMarker as P, TASK_FILE as Pt, HubError as Q, hubPath as Qt, traceTranscript as R, inRepositoryHubAt as Rt, sessionBriefing as S, VERSION_HEADER as St, markNoticesHandled as T, readsAsText as Tt, renumberPath as U, registeredName as Ut, renumberRequest as V, readRegistry as Vt, renumberText as W, registryFile as Wt, applyOperation as X, dataFile as Xt, syncedPath as Y, currentBranch as Yt, checkHubName as Z, gitCheckout as Zt, ARCHIVE_KINDS as _, MAX_BLOB_BYTES as _t, openInApp as a, splitFrontMatter as an, mainlineEdges as at, untilState as b, ROUTES as bt, siteBlock as c, refIndex as ct, migrateHubData as d, taskFile as dt, worktreesOf as en, loadConfig as et, migrateHub as f, nowMinute as ft, RETRY_RULES as g, BLOB_HASH as gt, receiverFromEnv as h, ACCESS_HEADERS as ht, hostName as i, contentHash as in, dependencyGraph as it, grantScope as j, versionMismatch as jt, readSession as k, hubFormatVersion as kt, syncHost as l, remoteMembers as lt, retroReportFromReceiver as m, readYaml as mt, DEFAULT_UI_PORT as n, DATA_DIR as nn, loadMainlines as nt, removeDanglingLinks as o, linksInto as ot, retroReport as p, readFrontMatter as pt, mayHoldSynced as q, userDataDir as qt, caddySites as r, WriteError as rn, sectionText as rt, removeHostLink as s, memberOfGroup as st, APP_BUNDLE_ID as t, ConflictError as tn, loadHub as tt, groupPlan as u, unavailableHubs as ut, setArchivedMany as v, MAX_CHANGE_PAGE as vt, HANDLED_FILE as w, exceedsFileLimit as wt, duplicateClaimLines as x, SOCKET_MAX_AGE_CLOSE as xt, initHub as y, MAX_FILE_BYTES as yt, transcriptTitle as z, listHubs 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 };