mainflow 0.44.0-alpha.1 → 0.44.0-alpha.2

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { P as UNTIL_FORMS, X as parseUntil, Y as parseRef, Z as refExample, ct as stampMs, it as untilProblem, n as CLOSED_STATUS } from "./dist-CXrUfRQp.js";
 import { $t as realPath, Bt as notRegisteredMessage, Ft as requireSlug, Gt as resolveHub, Ht as registerHub, It as hubAtRoot, Jt as nodeStorage, Kt as unregisterHub, Lt as hubHoldingFile, Mt as MAINLINE_FILE, O as loadSessions, Pt as TASK_FILE, Q as HubError, S as sessionBriefing, Ut as registeredName, Vt as readRegistry, Wt as registryFile, X as applyOperation, Xt as dataFile, Z as checkHubName, b as untilState, d as migrateHubData, f as migrateHub, ft as nowMinute, g as RETRY_RULES, gt as BLOB_HASH, h as receiverFromEnv, k as readSession, lt as remoteMembers, m as retroReportFromReceiver, nn as DATA_DIR, p as retroReport, qt as userDataDir, rn as WriteError, rt as sectionText, st as memberOfGroup, tt as loadHub, u as groupPlan, ut as unavailableHubs, vt as MAX_CHANGE_PAGE, x as duplicateClaimLines, y as initHub, yt as MAX_FILE_BYTES, zt as listHubs } from "./host-C74j2Qox.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { A as hubName, C as readRemote, D as Unreachable, E as ServerError, F as syncPaths, M as SETTINGS_FILE, O as ENV, T as ServerApi, _ as DaemonUnavailable, a as versionGate, b as readDaemon, c as oversizedFiles, d as planAnnounce, f as planFetch, g as DaemonRunning, h as startDaemon, i as requireWritableVersion, j as syncSettings, k as earlierToken, l as fetchDenial, m as toolCallOf, n as hubWriter, o as queuedCount, p as planFlush, r as writtenLines, s as remoteMode, t as CONFIRM_MS, u as hookAnswer, v as callDaemon, w as HubRewritingError, x as silentHint, y as probeDaemon } from "./operation-BmCeGKHw.js";
+import { A as hubName, C as readRemote, D as Unreachable, E as ServerError, F as syncPaths, M as SETTINGS_FILE, O as ENV, T as ServerApi, _ as DaemonUnavailable, a as versionGate, b as readDaemon, c as oversizedFiles, d as planAnnounce, f as planFetch, g as DaemonRunning, h as startDaemon, i as requireWritableVersion, j as syncSettings, k as earlierToken, l as fetchDenial, m as toolCallOf, n as hubWriter, o as queuedCount, p as planFlush, r as writtenLines, s as remoteMode, t as CONFIRM_MS, u as hookAnswer, v as callDaemon, w as HubRewritingError, x as silentHint, y as probeDaemon } from "./operation-CUeOFEaf.js";
 import { COMMAND_SPECS, OPTIONS } from "./facts.js";
 import { t as CLI_VERSION } from "./version-Dvv4jwF1.js";
 import { hookFallback, parsePayload, runHook } from "./hooks.js";

package/dist/grant-check.js

@@ -1,6 +1,6 @@
 import { D as SESSION_ID, I as configSchema, ft as describeRequest, gt as hasControl, tt as repoPaths } from "./dist-CXrUfRQp.js";
 import { $t as realPath, Gt as resolveHub, Jt as nodeStorage, M as matchGrants, Ot as formatMismatch, Yt as currentBranch, Zt as gitCheckout, j as grantScope, k as readSession, kt as hubFormatVersion, mt as readYaml } from "./host-C74j2Qox.js";
-import { n as hubWriter, r as writtenLines } from "./operation-BmCeGKHw.js";
+import { n as hubWriter, r as writtenLines } from "./operation-CUeOFEaf.js";
 import { OWNER_REPO, githubOrigin, quote, readManifest, resolveFixed, scanCommand, scopedCwd } from "./grant-commands.js";
 import { claudeCodeSessionId, parsePayload } from "./hooks.js";
 import { readFileSync } from "node:fs";

package/dist/hooks.js

@@ -1,6 +1,6 @@
 import { I as configSchema, Y as parseRef, ft as describeRequest, rt as taskSchema, tt as repoPaths } from "./dist-CXrUfRQp.js";
 import { $ as isOpenMainline, $t as realPath, Bt as notRegisteredMessage, C as turnReminder, F as headerLine, Gt as resolveHub, I as mayDecorate, Jt as nodeStorage, Lt as hubHoldingFile, M as matchGrants, N as decorateReply, Nt as SESSIONS_DIR, O as loadSessions, Ot as formatMismatch, P as endsWithMarker, Q as HubError, Qt as hubPath, Rt as inRepositoryHubAt, S as sessionBriefing, Xt as dataFile, Yt as currentBranch, dt as taskFile, en as worktreesOf, i as hostName, j as grantScope, k as readSession, kt as hubFormatVersion, mt as readYaml, nn as DATA_DIR, nt as loadMainlines, pt as readFrontMatter, tt as loadHub } from "./host-C74j2Qox.js";
-import { n as hubWriter, r as writtenLines } from "./operation-BmCeGKHw.js";
+import { n as hubWriter, r as writtenLines } from "./operation-CUeOFEaf.js";
 import { SCENARIO_LINES, SCENARIO_SKIP_KINDS } from "./facts.js";
 import { resolveFixed, scanCommand, scopedCwd } from "./grant-commands.js";
 import { createHash } from "node:crypto";

package/dist/launch.js

@@ -273,7 +273,7 @@ async function launchUi(dirs, hub, configured, options) {
 		}
 		let server;
 		if (!reuse) {
-			const { serveUi } = await import("./ui-8NTeAfC7.js");
+			const { serveUi } = await import("./ui-qqVCewFz.js");
 			server = await serveUi(dirs, choice.port);
 			writeUiRecord(dirs, {
 				port: choice.port,

package/dist/{operation-BmCeGKHw.js → operation-CUeOFEaf.js}

@@ -920,6 +920,11 @@ const readKnownDirs = (hub) => {
 	const dirs = readJson(syncPaths(hub).known, {}).dirs;
 	return Array.isArray(dirs) ? dirs.filter((dir) => typeof dir === "string") : [];
 };
+/** The hub's seq known.json names (KnownFile.seq); undefined when it names none, or none that is a seq. */
+const readKnownSeq = (hub) => {
+	const seq = readJson(syncPaths(hub).known, {}).seq;
+	return Number.isInteger(seq) && seq >= 0 ? seq : void 0;
+};
 /** 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/. */
@@ -936,9 +941,9 @@ function readKnownText(dirs, 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.
+* `dirs` are the directories it names, and `seq` the hub's seq they are as of, written with them (KnownFile.seq).
 */
-function writeKnown(hub, files, dirs = []) {
+function writeKnown(hub, files, dirs = [], seq) {
 	const dir = syncPaths(hub).knownTexts;
 	mkdirSync(dir, { recursive: true });
 	const named = new Set(Object.values(files).map((file) => file.hash));
@@ -951,7 +956,8 @@ function writeKnown(hub, files, dirs = []) {
 	}
 	const known = {
 		files: Object.fromEntries(Object.entries(files).map(([path, file]) => [path, file.hash])),
-		...dirs.length > 0 ? { dirs } : {}
+		...dirs.length > 0 ? { dirs } : {},
+		...seq === void 0 ? {} : { seq }
 	};
 	writeJson(syncPaths(hub).known, known);
 	for (const name of held) if (!named.has(name)) rmSync(join(dir, name), { force: true });
@@ -1656,7 +1662,8 @@ var SyncClient = class extends EventEmitter {
 	* every directory, but for the paths changed after it: a whole snapshot with binary files was taken in this run, and
 	* nothing since made the client unsure of what it holds, as a server that stopped keeping binary files, or a hub
 	* reloaded. Only then is a snapshot asked for what changed since hubSeq (`since`), as a path the answer does not name
-	* holds what the client takes the server to hold. Not kept across runs: known.json names no seq.
+	* holds what the client takes the server to hold. A run after it starts from known.json instead, which names the seq
+	* (knownSeq, resumeSeq).
 	*/
 	holdsHub = false;
 	/**
@@ -1664,6 +1671,20 @@ var SyncClient = class extends EventEmitter {
 	* not leave the client holding the hub (holdsHub), whatever it took in, so the next one is whole.
 	*/
 	reloads = 0;
+	/**
+	* The hub's seq known.json named when this run started (readKnownSeq): the files it names, its directories and
+	* remote.json are the hub as of it, so the run's first snapshot asks for what changed since, as one after a reconnect
+	* does (holdsHub). Undefined once a snapshot was taken, or when known.json names none or the run cannot take it, as
+	* when a text it names is not in known/.
+	*/
+	resumeSeq;
+	/**
+	* For each path, a seq at or before which the hub held another version than the one the client knows of now (in
+	* `cloud`, or `remote`): a broadcast's own seq, or, for a snapshot's, one after the seq of the version before it. A
+	* path whose known.json version lags behind is changed on the server after the seq known.json is written with
+	* (knownSeq), so what changed since names it.
+	*/
+	changedAt = /* @__PURE__ */ new Map();
 	/** The seqs of the broadcasts on the current connection above hubSeq with a change between that never arrived */
 	ahead = /* @__PURE__ */ new Set();
 	waiters = /* @__PURE__ */ new Set();
@@ -1861,6 +1882,7 @@ var SyncClient = class extends EventEmitter {
 	async restoreKnown() {
 		this.copied = !existsSync(this.paths.known);
 		this.blobsCompared = !this.copied && !existsSync(this.paths.copyBlobs);
+		this.resumeSeq = this.blobsCompared ? readKnownSeq(this.dirs) : void 0;
 		for (const dir of readKnownDirs(this.dirs)) this.syncedDirs.add(dir);
 		for (const [path, hash] of Object.entries(readKnown(this.dirs))) {
 			if (hash.startsWith("blob:")) {
@@ -1884,7 +1906,9 @@ var SyncClient = class extends EventEmitter {
 				text,
 				server: text
 			});
+			else if (this.syncs(path)) this.resumeSeq = void 0;
 		}
+		if (this.resumeSeq !== void 0) this.log(`known.json is of the hub's seq ${this.resumeSeq}: the first snapshot asks for what changed since`);
 	}
 	/**
 	* The refusals a run killed before it settled them left in the outbox (src/state.ts): each text not saved yet is saved,
@@ -2118,12 +2142,13 @@ var SyncClient = class extends EventEmitter {
 		if ("reload" in message && message.reload) {
 			this.reloads++;
 			this.holdsHub = false;
+			this.resumeSeq = void 0;
 			this.track(this.resync());
 			return;
 		}
 		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);
+		else this.receive(event, seq, true);
 		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());
@@ -2144,7 +2169,7 @@ var SyncClient = class extends EventEmitter {
 	* that may stay on the server, as a new screenshot of a closed mainline, goes into `remote` instead of being downloaded,
 	* as a listed text does in a snapshot.
 	*/
-	receive(event, seq) {
+	receive(event, seq, live = false) {
 		if (!this.syncs(event.path)) return;
 		const file = event.kind === "file" ? event.text : event.kind === "blob" ? {
 			kind: "blob",
@@ -2157,6 +2182,7 @@ var SyncClient = class extends EventEmitter {
 			this.trace(`older ${event.path} ${label} seq ${seq}, holding seq ${held}`);
 			return;
 		}
+		this.noteChange(event.path, file === null ? null : serverHash(file), live ? seq : held + 1);
 		this.fileSeq.set(event.path, seq);
 		if (this.downloadErrors.has(event.path)) {
 			const before = this.cloud.get(event.path);
@@ -2238,6 +2264,16 @@ var SyncClient = class extends EventEmitter {
 	forgetDir(path) {
 		if (this.syncedDirs.delete(path)) this.saveKnown();
 	}
+	/** The hash the client knows the server's file at `path` by: of its version in `cloud`, or `remote`; null for none. */
+	serverView(path) {
+		const file = this.cloud.get(path);
+		if (file !== void 0 && file !== null) return serverHash(file);
+		return this.remote.get(path) ?? null;
+	}
+	/** The server's file at `path` is to be known by `hash` (null for none), a change of the hub at seq `at` or later (changedAt). */
+	noteChange(path, hash, at) {
+		if (this.serverView(path) !== hash) this.changedAt.set(path, at);
+	}
 	/** 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;
@@ -2381,7 +2417,8 @@ var SyncClient = class extends EventEmitter {
 	* since hubSeq alone (`since`). A server whose change log tells answers with the paths changed (SnapshotDelta): taken
 	* in over what the client holds once they make the hub's digest (changesHold, takeChanges), and else dropped for the
 	* whole snapshot. A server that cannot tell, or one from before it, answers the first batch, and the snapshot goes on
-	* whole as ever.
+	* whole as ever. A run's first snapshot asks the same way from the seq known.json names (resumeSeq), taking known.json,
+	* remote.json and the directories known.json names for what the server held as of it (knownCopy).
 	*/
 	takeSnapshot() {
 		return this.exclusive(() => this.snapshotNow());
@@ -2406,13 +2443,15 @@ var SyncClient = class extends EventEmitter {
 		/** The reload broadcasts that came before this snapshot: one that comes while it runs leaves the next one whole */
 		const reloads = this.reloads;
 		/**
-		* Whether the snapshot may ask for what changed since hubSeq, read once the probe told whether the server keeps
+		* Whether the snapshot may ask for what changed since a seq: hubSeq while the client holds the hub, or the seq
+		* known.json names before the run's first snapshot (resumeSeq). Read once the probe told whether the server keeps
 		* binary files; not once an answer of it failed the digest
 		*/
-		let askChanges = this.holdsHub;
+		let askChanges = this.holdsHub || this.resumeSeq !== void 0;
 		for (;;) {
 			before = this.hubSeq;
-			const base = askChanges && this.blobSupport === true && before >= 0 ? this.serverCopy() : null;
+			const from = !askChanges || this.blobSupport !== true ? null : this.holdsHub ? before >= 0 ? before : null : this.resumeSeq ?? null;
+			const base = from === null ? null : this.holdsHub ? this.serverCopy() : this.knownCopy();
 			({texts: held, blobs: heldBlobs} = await this.holdings());
 			let dropped = false;
 			for (const path of this.remote.keys()) {
@@ -2433,7 +2472,7 @@ var SyncClient = class extends EventEmitter {
 				value: hubDigest(have, dirs),
 				dirs
 			} : void 0;
-			since = base !== null && withBlobs && !dropped ? before : void 0;
+			since = base !== null && from !== null && withBlobs && !dropped ? from : void 0;
 			const taken = await this.api.snapshot(have, {
 				listOnly: this.listOnly(this.copied && !this.synced),
 				blobs: withBlobs,
@@ -2583,6 +2622,8 @@ var SyncClient = class extends EventEmitter {
 		this.takenUpTo(seq);
 		this.synced = true;
 		this.holdsHub = withBlobs && this.reloads === reloads;
+		this.resumeSeq = void 0;
+		this.saveKnown();
 		if (withBlobs && !this.blobsCompared) {
 			this.blobsCompared = true;
 			rmSync(this.paths.copyBlobs, { force: true });
@@ -2597,6 +2638,32 @@ var SyncClient = class extends EventEmitter {
 		await this.queueRemovedDirs();
 	}
 	/**
+	* What the client takes the server to hold as of the seq known.json names, before the run's first snapshot
+	* (resumeSeq): the version known.json names of each file, but one only on the server (remote.json), and the
+	* directories it names; with what a broadcast taken in since the run started holds, which is of a later seq.
+	*/
+	knownCopy() {
+		const files = /* @__PURE__ */ new Map();
+		for (const [path, disk] of this.confirmed) {
+			if (!disk || !this.syncs(path) || this.remote.has(path)) continue;
+			if (disk.blob) files.set(path, {
+				kind: "blob",
+				hash: disk.hash
+			});
+			else if (disk.text !== void 0) files.set(path, disk.text);
+		}
+		for (const [path, file] of this.cloud) {
+			if (!this.syncs(path)) continue;
+			if (file === null) files.delete(path);
+			else files.set(path, file);
+		}
+		return {
+			files,
+			remote: new Map(this.remote),
+			dirs: new Set(this.syncedDirs)
+		};
+	}
+	/**
 	* What the client takes the server to hold, while it holds the hub (holdsHub): the server's version of each file it
 	* took in, a binary file's included, the hash of each file only on the server, and the directories the server holds.
 	* A file here the server never had is not among them, though a snapshot request names it.
@@ -3237,7 +3304,9 @@ var SyncClient = class extends EventEmitter {
 	}
 	/** Note `path` as only on the server, with the hash of the server's text as of `seq`, unless a newer version came. */
 	keepRemote(path, hash, seq) {
-		if (seq <= (this.fileSeq.get(path) ?? -1)) return;
+		const held = this.fileSeq.get(path) ?? -1;
+		if (seq <= held) return;
+		this.noteChange(path, hash, held + 1);
 		this.fileSeq.set(path, seq);
 		this.remote.set(path, hash);
 		this.cloud.delete(path);
@@ -5688,12 +5757,39 @@ var SyncClient = class extends EventEmitter {
 		this.knownTimer = void 0;
 		const files = this.knownFiles();
 		const dirs = this.knownDirs();
+		const seq = this.knownSeq();
+		if (seq !== void 0) this.saveRemoteNow(final);
 		try {
-			underLock(this.dirs, () => writeKnown(this.dirs, files, dirs));
+			underLock(this.dirs, () => writeKnown(this.dirs, files, dirs, seq));
 		} catch (error) {
 			this.log(`could not save local/sync/known.json: ${error.message}`);
 		}
 	}
+	/**
+	* The hub's seq known.json is written with (KnownFile.seq): one as of which the files it names, its directories and
+	* remote.json are the hub's, but for paths changed on the server after it, so that what changed since names every
+	* path whose version there differs. Only while the client holds the hub (holdsHub) and no snapshot is under way, as
+	* the files it is taking in are of later seqs; and none while a listed file is being downloaded. It is hubSeq, or
+	* lower when a file's version known.json names is not the server's the client knows of, as one the outbox holds a
+	* write about while the server changed it: one before that change (changedAt). Undefined when there is none.
+	*/
+	knownSeq() {
+		if (!this.holdsHub || this.hubSeq < 0 || this.resyncing !== null || this.awaiting.size > 0) return void 0;
+		const listed = this.listedRemote();
+		let seq = this.hubSeq;
+		for (const path of /* @__PURE__ */ new Set([
+			...this.cloud.keys(),
+			...this.confirmed.keys(),
+			...this.remote.keys()
+		])) {
+			if (!this.syncs(path)) continue;
+			const disk = this.confirmed.get(path);
+			if ((listed.get(path) ?? (disk ? disk.hash : null)) === this.serverView(path)) continue;
+			seq = Math.min(seq, (this.changedAt.get(path) ?? 0) - 1);
+			if (seq < 0) return void 0;
+		}
+		return seq;
+	}
 };
 //#endregion
 //#region ../sync/dist/ipc.js
@@ -5724,30 +5820,75 @@ var DaemonUnavailable = class extends Error {
 };
 /** Another sync client already runs for the hub. */
 var DaemonRunning = class extends Error {};
+/** The answer's body could not be read to its end, after its status came. */
+var BodyUnread = class extends Error {};
+/**
+* One request to the sync client on the loopback interface, with the status and the whole body of its answer. It uses
+* node:http, taken when first called, rather than fetch: fetch loads undici and with it tls, and a process with
+* NODE_USE_SYSTEM_CA set reads the system's certificates when tls loads, which costs every hook that writes about 140 ms.
+* `agent: false` opens a connection for this request alone, so no kept-alive socket holds a short-lived command open.
+* No answer within `timeoutMs` rejects with an error named TimeoutError, which callDaemon takes as a silent sync client;
+* the time running out while the body is read rejects with BodyUnread, as does any failure reading it.
+*/
+function loopbackRequest(port, path, headers, body, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		let answered = false;
+		const request = process.getBuiltinModule("node:http").request({
+			host: "127.0.0.1",
+			port,
+			path,
+			method: body === void 0 ? "GET" : "POST",
+			headers,
+			agent: false
+		}, (response) => {
+			answered = true;
+			const chunks = [];
+			response.on("data", (chunk) => chunks.push(chunk));
+			response.on("end", () => {
+				clearTimeout(timer);
+				resolve({
+					status: response.statusCode ?? 0,
+					text: Buffer.concat(chunks).toString("utf8")
+				});
+			});
+			response.on("error", (error) => {
+				clearTimeout(timer);
+				reject(new BodyUnread(error.message));
+			});
+		});
+		const timer = setTimeout(() => {
+			const error = answered ? new BodyUnread("the answer did not end in time") : Object.assign(/* @__PURE__ */ new Error("The operation was aborted due to timeout"), { name: "TimeoutError" });
+			request.destroy(error);
+			reject(error);
+		}, timeoutMs);
+		request.on("error", (error) => {
+			clearTimeout(timer);
+			reject(answered ? new BodyUnread(error.message) : error);
+		});
+		request.end(body);
+	});
+}
 async function callDaemon(daemon, route, body, timeoutMs = 6e4) {
+	const notSync = () => new DaemonUnavailable(`what answers on port ${daemon.port} is not mainflow sync (pid ${daemon.pid})`);
 	let response;
 	try {
-		response = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
-			method: body === void 0 ? "GET" : "POST",
-			headers: {
-				[SECRET_HEADER]: daemon.secret,
-				"content-type": "application/json"
-			},
-			body: body === void 0 ? void 0 : JSON.stringify(body),
-			signal: AbortSignal.timeout(timeoutMs)
-		});
+		response = await loopbackRequest(daemon.port, route, {
+			[SECRET_HEADER]: daemon.secret,
+			"content-type": "application/json"
+		}, body === void 0 ? void 0 : JSON.stringify(body), timeoutMs);
 	} catch (error) {
+		if (error instanceof BodyUnread) throw notSync();
 		const silent = error.name === "TimeoutError";
 		throw new DaemonUnavailable(`mainflow sync (pid ${daemon.pid}) does not answer: ${error.message}`, silent);
 	}
 	let parsed;
 	try {
-		parsed = await response.json();
+		parsed = JSON.parse(response.text);
 	} catch {
-		throw new DaemonUnavailable(`what answers on port ${daemon.port} is not mainflow sync (pid ${daemon.pid})`);
+		throw notSync();
 	}
 	if (response.status === 403) throw new DaemonUnavailable(`what answers on port ${daemon.port} is not this hub's mainflow sync (pid ${daemon.pid})`);
-	if (!response.ok) throw new Error(`mainflow sync failed: ${parsed.error}`);
+	if (response.status < 200 || response.status > 299) throw new Error(`mainflow sync failed: ${parsed.error}`);
 	return parsed;
 }
 /** How long a probe waits for the sync client's answer; a client holding the write lock answers after it. */

package/dist/{ui-8NTeAfC7.js → ui-qqVCewFz.js}

@@ -1,7 +1,7 @@
 import { I as configSchema, tt as repoPaths } from "./dist-CXrUfRQp.js";
 import { A as transcriptPath, D as readNotices$1, E as parseWarn, It as hubAtRoot, L as attributeTrace, O as loadSessions, Q as HubError, Qt as hubPath, R as traceTranscript, T as markNoticesHandled, Xt as dataFile, _ as ARCHIVE_KINDS, a as openInApp, at as mainlineEdges, ct as refIndex, et as loadConfig, it as dependencyGraph, k as readSession, lt as remoteMembers, mt as readYaml, nn as DATA_DIR, ot as linksInto, rn as WriteError, rt as sectionText, tn as ConflictError, tt as loadHub, u as groupPlan, v as setArchivedMany, w as HANDLED_FILE, z as transcriptTitle } from "./host-C74j2Qox.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { C as readRemote, F as syncPaths, N as SYNC_DIR, P as isSynced, S as watchTree, _ as DaemonUnavailable, b as readDaemon, n as hubWriter, r as writtenLines, s as remoteMode, v as callDaemon } from "./operation-BmCeGKHw.js";
+import { C as readRemote, F as syncPaths, N as SYNC_DIR, P as isSynced, S as watchTree, _ as DaemonUnavailable, b as readDaemon, n as hubWriter, r as writtenLines, s as remoteMode, v as callDaemon } from "./operation-CUeOFEaf.js";
 import { t as CLI_VERSION } from "./version-Dvv4jwF1.js";
 import { readUiRecord, realRoot } from "./launch.js";
 import { createRequire } from "node:module";

package/package.json

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