mainflow 0.41.0-beta.1 → 0.42.0

package/dist/cli.js

@@ -2,10 +2,10 @@
 import { $ as stampMs, G as parseUntil, K as refExample, M as UNTIL_FORMS, W as parseRef, n as CLOSED_STATUS } from "./dist-zSabglPq.js";
 import { At as WriteError, Ct as TASK_FILE, D as loadSessions, Et as findHubRoot, G as applyOperation, K as checkHubName, O as readSession, St as MAINLINE_FILE, X as sectionText, Y as loadHub, at as nowMinute, b as duplicateClaimLines, ct as nodeStorage, d as migrateHub, et as memberOfGroup, f as retroReport, ft as MAX_FILE_BYTES, h as RETRY_RULES, kt as DATA_DIR, m as receiverFromEnv, nt as remoteMembers, p as retroReportFromReceiver, q as HubError, rt as unavailableHubs, u as groupPlan, v as initHub, wt as requireSlug, x as sessionBriefing, y as untilState } from "./host-BAMZmRy8.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { C as ServerError, D as syncSettings, E as hubName, O as SETTINGS_FILE, S as ServerApi, T as earlierToken, _ as readDaemon, a as remoteMode, b as readRemote, c as planAnnounce, d as toolCallOf, f as startDaemon, g as probeDaemon, h as callDaemon, i as queuedCount, j as syncPaths, l as planFetch, m as DaemonUnavailable, n as hubWriter, o as fetchDenial, p as DaemonRunning, r as writtenLines, s as hookAnswer, t as CONFIRM_MS, u as planFlush, v as silentHint, w as ENV, x as oversizedFiles } from "./operation-DlR1P_Pt.js";
+import { C as ServerError, D as syncSettings, E as hubName, O as SETTINGS_FILE, S as ServerApi, T as earlierToken, _ as readDaemon, a as remoteMode, b as readRemote, c as planAnnounce, d as toolCallOf, f as startDaemon, g as probeDaemon, h as callDaemon, i as queuedCount, j as syncPaths, l as planFetch, m as DaemonUnavailable, n as hubWriter, o as fetchDenial, p as DaemonRunning, r as writtenLines, s as hookAnswer, t as CONFIRM_MS, u as planFlush, v as silentHint, w as ENV, x as oversizedFiles } from "./operation-2wx2ex6x.js";
 import { COMMAND_SPECS, OPTIONS } from "./facts.js";
 import { hookFallback, parsePayload, runHook } from "./hooks.js";
-import { f as CLI_VERSION, i as launchUi, l as startUiInBackground, r as exitCodeFor, u as watchHubGone } from "./launch-CMeKJsNd.js";
+import { f as CLI_VERSION, i as launchUi, l as startUiInBackground, r as exitCodeFor, u as watchHubGone } from "./launch-DosYhbwc.js";
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";

package/dist/hooks.js

@@ -1,6 +1,6 @@
 import { P as configSchema, W as parseRef, Y as taskSchema, rt as describeRequest } from "./dist-zSabglPq.js";
 import { A as grantScope, D as loadSessions, Dt as worktreesOf, Et as findHubRoot, F as mayDecorate, M as decorateReply, N as endsWithMarker, O as readSession, P as headerLine, S as turnReminder, Tt as currentBranch, Y as loadHub, bt as formatMismatch, ct as nodeStorage, i as hostName, it as taskFile, j as matchGrants, kt as DATA_DIR, ot as readFrontMatter, q as HubError, st as readYaml, x as sessionBriefing, xt as hubFormatVersion } from "./host-BAMZmRy8.js";
-import { n as hubWriter, r as writtenLines } from "./operation-DlR1P_Pt.js";
+import { n as hubWriter, r as writtenLines } from "./operation-2wx2ex6x.js";
 import { SCENARIO_LINES, SCENARIO_SKIP_KINDS } from "./facts.js";
 import { resolveFixed, scanCommand, scopedCwd } from "./grant-commands.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";

package/dist/{launch-CMeKJsNd.js → launch-DosYhbwc.js}

@@ -276,7 +276,7 @@ async function launchUi(root, hub, configured, options) {
 		}
 		let server;
 		if (!reuse) {
-			const { serveUi } = await import("./ui-9uuI4Jif.js");
+			const { serveUi } = await import("./ui-D1dg19Jw.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-CMeKJsNd.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-DosYhbwc.js";
 export { PORT_SPAN, choosePort, exitCodeFor, launchUi, networkProbe, portCandidates, readUiRecord, realRoot, startUiInBackground, watchHubGone, withUiLock };

package/dist/{operation-DlR1P_Pt.js → operation-2wx2ex6x.js}

@@ -1,6 +1,6 @@
 import { At as WriteError, B as renumberRequest, G as applyOperation, H as renumberPath, Mt as splitFrontMatter, Ot as ConflictError, U as renumberText, V as renumberFiles, W as scopeOfPath, _t as readsAsText, at as nowMinute, ct as nodeStorage, dt as MAX_BLOB_BYTES, ft as MAX_FILE_BYTES, gt as exceedsFileLimit, ht as comparePaths, jt as contentHash, kt as DATA_DIR, lt as ACCESS_HEADERS, mt as SOCKET_MAX_AGE_CLOSE, pt as ROUTES, ut as BLOB_HASH, vt as requestTime, yt as textBytes, z as applyOffline } from "./host-BAMZmRy8.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 { 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";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
@@ -900,7 +900,8 @@ const requestIdOf = (entry) => entry.kind === "blob" && entry.retry ? `${entry.i
 const waiting = (entry) => entry.refused === void 0;
 /** A new entry's id. */
 const entryId = () => randomBytes(8).toString("hex");
-const entryPaths = (entry) => entry.kind === "op" ? Object.keys(entry.written) : [entry.path];
+/** The files an entry writes; none for a directory's removal. */
+const entryPaths = (entry) => entry.kind === "op" ? Object.keys(entry.written) : entry.kind === "rmdir" ? [] : [entry.path];
 /** A local minute without an offset, the `now` of protocol 1 */
 const LOCAL_MINUTE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/;
 /** Protocols whose write requests read the same as the current one's: protocol 3 changed only how a snapshot is taken. */
@@ -954,6 +955,11 @@ function writeJson(file, value) {
 	renameSync(temp, file);
 }
 const readKnown = (root) => readJson(syncPaths(root).known, {}).files ?? {};
+/** The directories known.json names; none from a client before it kept them. */
+const readKnownDirs = (root) => {
+	const dirs = readJson(syncPaths(root).known, {}).dirs;
+	return Array.isArray(dirs) ? dirs.filter((dir) => typeof dir === "string") : [];
+};
 /** What known.json writes before a binary file's sha256, apart from a text's content hash. */
 const BLOB_PREFIX = "blob:";
 /** The text of the version known.json names by `hash`; undefined when it was not kept, as by a sync client before known/. */
@@ -970,8 +976,9 @@ function readKnownText(root, hash) {
 * there yet; the texts of versions it no longer names are removed. A version whose text the client does not have keeps
 * the text known/ holds, if any. The new texts go first, then known.json, then the removals, so a client killed at any
 * step leaves a known.json whose every text is in known/. A binary file is given as its sha256 with BLOB_PREFIX, and no text.
+* `dirs` are the directories it names.
 */
-function writeKnown(root, files) {
+function writeKnown(root, files, dirs = []) {
 	const dir = syncPaths(root).knownTexts;
 	mkdirSync(dir, { recursive: true });
 	const named = new Set(Object.values(files).map((file) => file.hash));
@@ -982,7 +989,10 @@ function writeKnown(root, files) {
 		renameSync(join(dir, `${hash}.tmp`), join(dir, hash));
 		held.add(hash);
 	}
-	const known = { files: Object.fromEntries(Object.entries(files).map(([path, file]) => [path, file.hash])) };
+	const known = {
+		files: Object.fromEntries(Object.entries(files).map(([path, file]) => [path, file.hash])),
+		...dirs.length > 0 ? { dirs } : {}
+	};
 	writeJson(syncPaths(root).known, known);
 	for (const name of held) if (!named.has(name)) rmSync(join(dir, name), { force: true });
 }
@@ -1510,7 +1520,7 @@ function heldBase(entry) {
 */
 function textAt(entry, path) {
 	if (entry.kind === "op") return entry.written[path];
-	if (entry.path !== path || entry.kind === "blob") return void 0;
+	if (entry.path !== path || entry.kind === "blob" || entry.kind === "rmdir") return void 0;
 	if (entry.kind === "remove") return null;
 	return entry.text;
 }
@@ -1670,6 +1680,15 @@ var SyncClient = class extends EventEmitter {
 	unheld = /* @__PURE__ */ new Set();
 	/** The hub's seq of each path's version in `cloud`: a version from the server with a seq no higher is not newer */
 	fileSeq = /* @__PURE__ */ new Map();
+	/** The hub's seq of each directory as the server last named it, held or removed, as fileSeq is of a file */
+	dirSeq = /* @__PURE__ */ new Map();
+	/**
+	* The directories the server held that the client had here, as known.json keeps them: one gone here is sent as removed
+	* (queueRemovedDirs), and one a snapshot names is made here only when it is not among them
+	*/
+	syncedDirs = /* @__PURE__ */ new Set();
+	/** The check for directories gone here that is to run a moment from now (checkDirs) */
+	dirCheck = null;
 	/** The hub's seq up to which the client has taken in every change: the last snapshot and the broadcasts after it */
 	hubSeq = -1;
 	/** The seqs of the broadcasts on the current connection above hubSeq with a change between that never arrived */
@@ -1777,6 +1796,13 @@ var SyncClient = class extends EventEmitter {
 		return this.scope.synced(path);
 	}
 	/**
+	* Whether the directory at `path` is synced: one that may hold synced files and that the hub's .gitignore files leave
+	* in, apart from local/ itself, which every machine has of its own (src/paths.ts).
+	*/
+	syncsDir(path) {
+		return path !== "" && path !== "local" && this.scope.walks(path);
+	}
+	/**
 	* Whether the hub's .gitignore files changed since the last snapshot was asked for: a file they let in since may be on
 	* the server although the client took nothing of it in.
 	*/
@@ -1859,6 +1885,7 @@ var SyncClient = class extends EventEmitter {
 	async restoreKnown() {
 		this.copied = !existsSync(this.paths.known);
 		this.blobsCompared = !this.copied && !existsSync(this.paths.copyBlobs);
+		for (const dir of readKnownDirs(this.root)) this.syncedDirs.add(dir);
 		for (const [path, hash] of Object.entries(readKnown(this.root))) {
 			if (hash.startsWith("blob:")) {
 				const disk = {
@@ -2113,7 +2140,9 @@ var SyncClient = class extends EventEmitter {
 			this.track(this.resync());
 			return;
 		}
-		for (const event of message.files) this.receive(event, seq);
+		for (const event of message.files) if (event.kind === "dir") this.receiveDir(event.path, seq, true);
+		else if (event.kind === "dirRemoved") this.receiveDirRemoved(event.path, seq);
+		else this.receive(event, seq);
 		if (this.ahead.size > 0 && this.synced && this.resyncing === null) {
 			this.log(`missed the hub's changes ${this.hubSeq + 1} to ${Math.min(...this.ahead) - 1}; reloading the snapshot`);
 			this.track(this.resync());
@@ -2135,10 +2164,6 @@ var SyncClient = class extends EventEmitter {
 	* as a listed text does in a snapshot.
 	*/
 	receive(event, seq) {
-		if (event.kind === "dir") {
-			if ((event.path.split("/")[0] !== "local" || event.path === "local/sessions") && !this.scope.ignored(event.path, true)) this.track(mkdir(join(this.paths.data, event.path), { recursive: true }));
-			return;
-		}
 		if (!this.syncs(event.path)) return;
 		const file = event.kind === "file" ? event.text : event.kind === "blob" ? {
 			kind: "blob",
@@ -2180,6 +2205,58 @@ var SyncClient = class extends EventEmitter {
 		const mainline = MAINLINE_FILE.exec(event.path)?.[1];
 		if (mainline !== void 0 && this.remote.size > 0) this.fetchOpened(mainline);
 	}
+	/**
+	* A directory the server holds as of the hub's `seq`, from a broadcast (`live`) or a snapshot. One the client had here
+	* and that is gone now, named by a snapshot, was removed here: it is not made again, and its removal is queued
+	* (queueRemovedDirs). Any other is made here and known from then on; a broadcast's always is, an operation having just
+	* made it. A directory the client does not sync, and a version no newer than the one the client holds, as a snapshot's
+	* after the broadcast of its removal, are left alone.
+	*/
+	receiveDir(path, seq, live) {
+		if (!this.syncsDir(path) || seq <= (this.dirSeq.get(path) ?? -1)) return;
+		this.dirSeq.set(path, seq);
+		const dir = join(this.paths.data, path);
+		if (!live && this.syncedDirs.has(path) && !existsSync(dir)) {
+			this.trace(`dir ${path} seq ${seq}: removed here`);
+			return;
+		}
+		this.knowDir(path);
+		this.track(mkdir(dir, { recursive: true }));
+	}
+	/**
+	* The server removed the directory at `path` as of the hub's `seq`, as a broadcast tells, or a snapshot that no longer
+	* names it: removed here too when nothing is in it, under the write lock, so no mainflow write puts a file in it
+	* meanwhile. One that holds anything, as a file written here not sent yet, stays; the file's write makes it on the
+	* server again.
+	*/
+	receiveDirRemoved(path, seq) {
+		if (!this.syncsDir(path) || seq <= (this.dirSeq.get(path) ?? -1)) return;
+		this.dirSeq.set(path, seq);
+		this.forgetDir(path);
+		this.trace(`dir ${path} removed seq ${seq}`);
+		this.track(this.whenFree(() => this.locked(() => this.removeEmptyDir(path))).catch((error) => this.log(`${path}/: ${error.message}`)));
+	}
+	/** Remove the directory at `path` when nothing is in it; one gone already, or holding anything, stays as it is. True when it went. */
+	removeEmptyDir(path) {
+		try {
+			rmdirSync(join(this.paths.data, path));
+			return true;
+		} catch (error) {
+			const code = error.code;
+			if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST" && code !== "ENOTDIR") throw error;
+			return false;
+		}
+	}
+	/** The server holds the directory at `path`, and the client has it here: known from now on. */
+	knowDir(path) {
+		if (this.syncedDirs.has(path)) return;
+		this.syncedDirs.add(path);
+		this.saveKnown();
+	}
+	/** The server no longer holds the directory at `path`. */
+	forgetDir(path) {
+		if (this.syncedDirs.delete(path)) this.saveKnown();
+	}
 	/** Whether the client holds `path` as of the hub's `seq` or later. */
 	reached(path, seq) {
 		return this.hubSeq >= seq || (this.fileSeq.get(path) ?? -1) >= seq;
@@ -2247,6 +2324,7 @@ var SyncClient = class extends EventEmitter {
 						this.log(`the sync server's snapshot stays without the hub's changes ${missing}; taking it as complete`);
 						this.ahead.clear();
 						for (const [path, seq] of this.fileSeq) if (seq > this.hubSeq) this.fileSeq.delete(path);
+						for (const [path, seq] of this.dirSeq) if (seq > this.hubSeq) this.dirSeq.delete(path);
 						stalled = 0;
 						this.resyncAgain = true;
 						continue;
@@ -2362,6 +2440,7 @@ var SyncClient = class extends EventEmitter {
 		if (seq < before) {
 			this.log(`the sync server's seq went back from ${before} to ${seq}; taking its snapshot as it is`);
 			this.fileSeq.clear();
+			this.dirSeq.clear();
 			this.hubSeq = -1;
 			this.ahead.clear();
 		}
@@ -2372,8 +2451,16 @@ var SyncClient = class extends EventEmitter {
 		this.snapshotAnswers.clear();
 		const fromCopy = this.copied && !this.synced;
 		const blobsFromCopy = withBlobs && !this.blobsCompared;
+		/** The directories the snapshot names: every one the server holds */
+		const dirs = /* @__PURE__ */ new Set();
 		for (const part of parts) for (const event of part.files) {
-			if (event.kind !== "dir" && !this.syncs(event.path)) continue;
+			if (event.kind === "dir") {
+				named.add(event.path);
+				dirs.add(event.path);
+				this.receiveDir(event.path, part.seq, false);
+				continue;
+			}
+			if (!this.syncs(event.path)) continue;
 			if (event.kind === "listed") {
 				named.add(event.path);
 				if (this.mayStay(event.path, held)) this.keepRemote(event.path, event.hash, part.seq);
@@ -2441,6 +2528,7 @@ var SyncClient = class extends EventEmitter {
 				path
 			}, seq);
 		}
+		for (const path of this.syncedDirs) if (!dirs.has(path)) this.receiveDirRemoved(path, seq);
 		this.scopeTaken = asked;
 		this.log(`took the snapshot at seq ${seq} in ${parts.length} batch${parts.length === 1 ? "" : "es"}: ${sent} files sent, ${present.size - sent} already held here${this.remote.size > 0 ? `, ${this.remote.size} only on the server` : ""}`);
 		this.takenUpTo(seq);
@@ -2456,6 +2544,7 @@ var SyncClient = class extends EventEmitter {
 		for (const path of await this.walk()) this.schedule(path);
 		for (const path of this.stalledDownloads) this.schedule(path);
 		this.stalledDownloads.clear();
+		await this.queueRemovedDirs();
 	}
 	/**
 	* Ask the server whether it keeps binary files (blobSupport), once per connection, before its snapshot. A probe that
@@ -2618,7 +2707,7 @@ var SyncClient = class extends EventEmitter {
 			if (expected?.blob && expected.hash === disk.hash) this.expected.delete(path);
 			if (isBlob(this.cloud.get(path))) this.cloud.delete(path);
 		}
-		if (forgotten.size > 0) await this.whenFree(() => underLock(this.root, () => writeKnown(this.root, this.knownFiles())));
+		if (forgotten.size > 0) await this.whenFree(() => underLock(this.root, () => writeKnown(this.root, this.knownFiles(), this.knownDirs())));
 		return forgotten;
 	}
 	/** The server refused the upload, so it holds what it held: the binary files forgetBinaries forgot are known again. */
@@ -2844,6 +2933,9 @@ var SyncClient = class extends EventEmitter {
 	* now on (I4). A version only written here, still in the outbox, is never confirmed.
 	*/
 	confirm(path, disk) {
+		if (disk !== null) {
+			for (let at = path.lastIndexOf("/"); at > 0; at = path.lastIndexOf("/", at - 1)) if (this.syncsDir(path.slice(0, at))) this.knowDir(path.slice(0, at));
+		}
 		const held = this.confirmed.get(path);
 		if (held === void 0 ? false : held === null ? disk === null : disk !== null && held.hash === disk.hash && (held.text !== void 0 || disk.text === void 0)) return;
 		this.confirmed.set(path, disk);
@@ -3065,7 +3157,7 @@ var SyncClient = class extends EventEmitter {
 			const fetched = [];
 			for (const part of parts) for (const event of part.files) {
 				if (event.kind === "dir") {
-					this.receive(event, part.seq);
+					this.receiveDir(event.path, part.seq, false);
 					continue;
 				}
 				mentioned.add(event.path);
@@ -3843,6 +3935,88 @@ var SyncClient = class extends EventEmitter {
 		this.trace(`removal of ${path} changed before it was queued; reconciling it again`);
 		this.schedule(path);
 	}
+	/**
+	* Queue the removal of each directory the client had here that is gone (syncedDirs), with nothing the client knows of
+	* in it: no file the client left there and has not sent the removal of, no write in the outbox of a file there, which
+	* goes first, and no file the server holds there that is not written here yet, nor one only on the server. The
+	* deepest go first, so the server finds the ones in each removed already; one holding anything holds the ones above it
+	* too. Each is checked again in the hold of the write lock that queues it, so a directory made again meanwhile stays.
+	* Only once a snapshot was taken under the rules as they are, since what the server holds is unknown before.
+	*/
+	async queueRemovedDirs() {
+		if (!this.synced || this.scopeStale || this.closing) return;
+		const exists = (dir) => existsSync(join(this.paths.data, dir));
+		const gone = [...this.syncedDirs].filter((dir) => this.syncsDir(dir) && !exists(dir));
+		if (gone.length === 0) return;
+		gone.sort((a, b) => b.split("/").length - a.split("/").length || comparePaths(a, b));
+		const queued = [];
+		await this.whenFree(() => this.editQueue((entries) => {
+			const files = [
+				...[...this.expected].flatMap(([path, disk]) => disk === null ? [] : [path]),
+				...[...this.cloud].flatMap(([path, file]) => file === null ? [] : [path]),
+				...this.remote.keys(),
+				...this.awaiting,
+				...entries.flatMap(entryPaths)
+			];
+			const held = /* @__PURE__ */ new Set();
+			const hold = (dir) => {
+				for (let at = dir.length; at > 0; at = dir.lastIndexOf("/", at - 1)) held.add(dir.slice(0, at));
+			};
+			for (const path of files) hold(path.slice(0, Math.max(0, path.lastIndexOf("/"))));
+			for (const dir of gone) {
+				if (held.has(dir) || exists(dir)) {
+					hold(dir);
+					continue;
+				}
+				if (entries.some((entry) => entry.kind === "rmdir" && entry.path === dir)) continue;
+				entries.push({
+					kind: "rmdir",
+					path: dir,
+					id: entryId()
+				});
+				queued.push(dir);
+			}
+			return queued.length > 0;
+		}));
+		if (queued.length === 0) return;
+		this.log(`queued rmdir ${queued.join(", ")} (${this.queue.length} waiting)`);
+		if (this.online) this.track(this.flushQueue());
+	}
+	/**
+	* Queue the removal of the directories gone here a moment from now, once for every call in that moment; counted as
+	* work under way meanwhile, so idle() waits for it.
+	*/
+	checkDirs() {
+		if (this.closing || this.dirCheck) return;
+		this.dirCheck = this.track(sleep$1(SETTLE_MS).then(() => {
+			this.dirCheck = null;
+			return this.queueRemovedDirs();
+		}).catch((error) => this.log(`directories: ${error.message}`)));
+	}
+	/**
+	* What the server answered to the removal of a directory: removed, or not there, it is known no more. Kept, as when
+	* another environment has just put a file in it, it is made here again, as the server holds it, so it is not sent
+	* again; the file comes as the server's broadcast. Refused, as by a server from before dir.remove (`unknown-operation`),
+	* it is known no more either: the next snapshot makes it here again, as before, rather than it being sent again and again.
+	*/
+	async settleRmdir(entry, answer) {
+		const { path } = entry;
+		const response = answer;
+		this.trace(`response ${path}/ ${response.ok ? response.value : `${response.reason}: ${response.message}`}`);
+		if (!response.ok) {
+			this.forgetDir(path);
+			this.dirSeq.delete(path);
+			this.info(path, `the directory was removed here and the sync server did not remove it (${response.message}); it comes back with the next snapshot`);
+			return;
+		}
+		if (response.value === "kept") {
+			for (const notice of response.notices) this.info(notice.path, `${notice.message} (removed here; the directory is back)`);
+			await this.whenFree(() => this.locked(() => mkdirSync(join(this.paths.data, path), { recursive: true })));
+			return;
+		}
+		this.forgetDir(path);
+		if (response.files.length > 0) await this.delivery(path, response.seq);
+	}
 	async settleRemove(entry, response) {
 		const { path } = entry;
 		if (!response.ok) return this.refuse(entry, [{
@@ -3920,7 +4094,7 @@ var SyncClient = class extends EventEmitter {
 			hash: entry.hash,
 			blob: true
 		});
-		else this.expected.set(entry.path, null);
+		else if (entry.kind === "remove") this.expected.set(entry.path, null);
 	}
 	/**
 	* Hold the write lock for `fn`; work stop() abandoned gets an error ('abandoned after stop') instead, so it leaves
@@ -4379,7 +4553,7 @@ var SyncClient = class extends EventEmitter {
 			if (at < 0) return false;
 			entries.splice(at, 1);
 			for (const later of entries.slice(at)) {
-				if (later.kind === "op" || later.path !== entry.path || later.sent !== void 0 || later.base !== entry.hash) continue;
+				if (later.kind === "op" || later.kind === "rmdir" || later.path !== entry.path || later.sent !== void 0 || later.base !== entry.hash) continue;
 				if (later.kind === "remove" && entry.base === null) continue;
 				later.base = entry.base;
 			}
@@ -4422,6 +4596,7 @@ var SyncClient = class extends EventEmitter {
 		this.renumbering.delete(entry.id);
 		if (renumbered) this.log(`renumbered ${renumbered.map((r) => `${r.from} → ${r.to}`).join(", ")}`);
 		for (const path of entryPaths(entry)) this.schedule(path);
+		if (entry.kind !== "rmdir") this.checkDirs();
 		this.emit("settled", entry.id);
 	}
 	/**
@@ -4494,7 +4669,7 @@ var SyncClient = class extends EventEmitter {
 		}
 		if (!response.ok && response.reason === "uncertain") {
 			const paths = entryPaths(entry);
-			this.problem({
+			if (entry.kind !== "rmdir") this.problem({
 				kind: "uncertain",
 				path: paths[0] ?? "",
 				message: `${request.op} of ${paths.join(", ")} was sent before without an answer, and the sync server no longer keeps its answers from then (${response.message}); it is sent again as a new request and may apply twice, so check the result for a duplicate`
@@ -4505,8 +4680,8 @@ var SyncClient = class extends EventEmitter {
 	}
 	/**
 	* The request an outbox entry sends, made when it is first sent, from the entry alone: an operation on the current
-	* protocol, a deletion with the time it is first sent, an Edit's replacement to be made again on the server's latest
-	* version, an edit as patchRequest makes it. Null for an edit that cannot be sent: its base is a write the server
+	* protocol, a deletion with the time it is first sent, a directory's removal, an Edit's replacement to be made again on
+	* the server's latest version, an edit as patchRequest makes it. Null for an edit that cannot be sent: its base is a write the server
 	* refused or did not take as it was, so its base never became known, or moving it onto the server's merge overlaps.
 	* Every write ahead of it was answered, so a base still unknown never will be.
 	*/
@@ -4529,6 +4704,11 @@ var SyncClient = class extends EventEmitter {
 			size: entry.size,
 			base: entry.base
 		};
+		if (entry.kind === "rmdir") return {
+			protocol: 3,
+			op: "dir.remove",
+			path: entry.path
+		};
 		if (entry.replace) return {
 			protocol: 3,
 			op: "text.replace",
@@ -4675,6 +4855,7 @@ var SyncClient = class extends EventEmitter {
 				last: entry.replaced
 			}, request.text);
 			else if (entry.kind === "blob") await this.settleBlob(entry, response);
+			else if (entry.kind === "rmdir") await this.settleRmdir(entry, response);
 			return true;
 		} finally {
 			for (const path of paths) {
@@ -4827,6 +5008,26 @@ var SyncClient = class extends EventEmitter {
 				text
 			});
 		}
+		for (const path of [...seen.keys(), ...binary.map(([path]) => path)]) this.pruneMoved(path, renumberPath(path, renumbered));
+	}
+	/**
+	* Remove the directories above `from` that its move to `to` emptied, the deepest first, up to the first one that still
+	* holds anything or is above `to` as well. One the server holds goes on the server too, as any directory gone here
+	* (queueRemovedDirs). It does not take the write lock: its caller holds it.
+	*/
+	pruneMoved(from, to) {
+		if (from === to) return;
+		for (let at = from.lastIndexOf("/"); at > 0; at = from.lastIndexOf("/", at - 1)) {
+			const dir = from.slice(0, at);
+			if (to.startsWith(`${dir}/`)) return;
+			try {
+				if (!this.removeEmptyDir(dir)) return;
+			} catch (error) {
+				this.log(`${dir}/: could not remove it after renumbering: ${error.message}`);
+				return;
+			}
+			this.trace(`dir ${dir} emptied by renumbering, removed here`);
+		}
 	}
 	commit(storage, changes) {
 		for (const change of changes) if (change.kind === "write") storage.write(change.path, change.text);
@@ -5159,7 +5360,8 @@ var SyncClient = class extends EventEmitter {
 	}
 	/**
 	* Compare every synced file's size, modification time and inode with the last scan and reconcile what changed,
-	* plus every file expected on disk that is gone. A file modified in the last moment may still be being written,
+	* plus every file expected on disk that is gone, and queue the removal of the directories gone here
+	* (queueRemovedDirs). A file modified in the last moment may still be being written,
 	* so it waits for the next scan unless `immediate`. `baseline` only records what is there. An immediate scan waits for
 	* the reconciles it started unless `settle` is false, for a caller that waits for them itself (flushTool).
 	*/
@@ -5180,6 +5382,7 @@ var SyncClient = class extends EventEmitter {
 			this.signatures.delete(path);
 			this.schedule(path);
 		}
+		await this.queueRemovedDirs();
 		if (settle) await Promise.allSettled(this.chains.values());
 	}
 	/**
@@ -5197,6 +5400,7 @@ var SyncClient = class extends EventEmitter {
 				}, SETTLE_MS));
 				return;
 			}
+			if (this.syncedDirs.has(path)) this.checkDirs();
 			const rules = path === ".gitignore" || path.endsWith(`/.gitignore`);
 			if (!rules && !this.syncs(path)) return;
 			this.trace(`watched ${path}`);
@@ -5296,13 +5500,18 @@ var SyncClient = class extends EventEmitter {
 		for (const [path, disk] of this.confirmed) if (disk) files[path] = disk.blob ? { hash: `${BLOB_PREFIX}${disk.hash}` } : disk;
 		return files;
 	}
+	/** The directories known.json names (syncedDirs), in path order. */
+	knownDirs() {
+		return [...this.syncedDirs].sort(comparePaths);
+	}
 	saveKnownNow(final = false) {
 		if (this.abandoned && !final) return;
 		clearTimeout(this.knownTimer);
 		this.knownTimer = void 0;
 		const files = this.knownFiles();
+		const dirs = this.knownDirs();
 		try {
-			underLock(this.root, () => writeKnown(this.root, files));
+			underLock(this.root, () => writeKnown(this.root, files, dirs));
 		} catch (error) {
 			this.log(`could not save local/sync/known.json: ${error.message}`);
 		}

package/dist/{ui-9uuI4Jif.js → ui-D1dg19Jw.js}

@@ -1,8 +1,8 @@
 import { P as configSchema } from "./dist-zSabglPq.js";
 import { $ as linksInto, At as WriteError, C as HANDLED_FILE, D as loadSessions, E as readNotices$1, I as attributeTrace, J as loadConfig, L as traceTranscript, O as readSession, Ot as ConflictError, Q as mainlineEdges, R as transcriptTitle, T as parseWarn, X as sectionText, Y as loadHub, Z as dependencyGraph, _ as setArchivedMany, a as openInApp, g as ARCHIVE_KINDS, k as transcriptPath, kt as DATA_DIR, nt as remoteMembers, q as HubError, st as readYaml, tt as refIndex, u as groupPlan, w as markNoticesHandled } from "./host-BAMZmRy8.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-DlR1P_Pt.js";
-import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-CMeKJsNd.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-2wx2ex6x.js";
+import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-DosYhbwc.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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mainflow",
-  "version": "0.41.0-beta.1",
+  "version": "0.42.0",
   "description": "本機多 AI 協作的主脈絡任務管理：CLI 與介面",
   "license": "MIT",
   "type": "module",