@mulmoclaude/core 3.5.0 → 3.7.0

package/dist/collection-watchers/index.js

@@ -2,8 +2,8 @@ import { t as canonicalRoot } from "../root-BMroU_mB.js";
 import { R as fieldText, y as isValidCollectionName } from "../calendarGrid-CQ8MVSRb.js";
 import { E as whenMatches, f as itemIsDone } from "../promptSafety-CpiME8pj.js";
 import "../collection/index.js";
-import { d as storeFor, et as peekWorkspaceRoot, n as discoverCollections, nt as publishCollectionChange, q as collectionChangePayload, r as loadCollection, z as itemFilePath } from "../discovery-DH9wweuj.js";
-import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-BiRLLMpW.js";
+import { D as loadCollection, E as discoverCollections, H as itemFilePath, Q as collectionChangePayload, ct as publishCollectionChange, ot as peekWorkspaceRoot, r as storeFor, tt as firestoreHandle } from "../store-_61sO8K8.js";
+import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-B48Jyxcj.js";
 import { d as publish, m as updateForPlugin, n as clear, s as listAll } from "../notifier-DhnwR82U.js";
 import { access } from "node:fs/promises";
 //#region src/collection-watchers/config.ts
@@ -132,16 +132,28 @@ function resolveDisplayLabel(schema, item, itemId) {
 	const label = fieldText(item[displayField]).trim();
 	return label.length > 0 ? label : itemId;
 }
+/** The scope a collection's bells belong to.
+*
+*  A shared collection's `appId` wins over the call's `workspaceRoot`: the
+*  root is where this host happens to have the repository checked out, which
+*  is exactly the fact that must NOT reach the identity. A local collection is
+*  unchanged — its root is present only when the call carried an explicit one,
+*  so a single-workspace host's ids stay byte-identical to what it has already
+*  written to `active.json`. */
+function bellScopeOf(collection, ioOpts) {
+	return collection.appId === void 0 ? { root: ioOpts.workspaceRoot } : { aid: collection.appId };
+}
+var scopedLegacyId = (slug, itemId, scope) => completionLegacyId(slug, itemId, scope.root, scope.aid);
 /** Every active bell entry whose key matches this (slug, itemId).
 *  Returns multiple when defensive cleanup is needed. Scans `listAll()`
 *  — cheap because the active set is bounded. */
-async function findActiveEntries(slug, itemId, root) {
+async function findActiveEntries(slug, itemId, scope) {
 	const adapter = requireAdapter();
-	const legacyId = completionLegacyId(slug, itemId, root);
+	const legacyId = scopedLegacyId(slug, itemId, scope);
 	return (await listAll()).filter((entry) => adapter.readEntry(entry.pluginData)?.legacyId === legacyId);
 }
-async function findActiveEntryIds(slug, itemId, root) {
-	return (await findActiveEntries(slug, itemId, root)).map((entry) => entry.id);
+async function findActiveEntryIds(slug, itemId, scope) {
+	return (await findActiveEntries(slug, itemId, scope)).map((entry) => entry.id);
 }
 var ensureLocks = /* @__PURE__ */ new Map();
 /** Bell priority for a record: the FIRST flagged value in `notifyWhen.in`
@@ -154,8 +166,8 @@ function notifyPriorityForItem(schema, item) {
 	const value = item[spec.field] === void 0 || item[spec.field] === null ? "" : String(item[spec.field]);
 	return spec.in.indexOf(value) === 0 ? "high" : "normal";
 }
-async function ensureItemNotification(slug, schema, itemId, displayLabel, priority, root) {
-	const legacyId = completionLegacyId(slug, itemId, root);
+async function ensureItemNotification(slug, schema, itemId, displayLabel, priority, scope) {
+	const legacyId = scopedLegacyId(slug, itemId, scope);
 	while (true) {
 		const inflight = ensureLocks.get(legacyId);
 		if (!inflight) break;
@@ -168,7 +180,7 @@ async function ensureItemNotification(slug, schema, itemId, displayLabel, priori
 		legacyId,
 		displayLabel,
 		priority,
-		root
+		scope
 	}) };
 	ensureLocks.set(legacyId, lock);
 	try {
@@ -181,8 +193,9 @@ async function ensureItemNotification(slug, schema, itemId, displayLabel, priori
 *  place (preserving id / position / createdAt) so a record whose flagged
 *  value changed while it stayed pending re-colours the bell without a
 *  clear+republish flicker. No-op when the stored priority already matches. */
-async function reconcileEntrySeverity(slug, itemId, entries, priority, root) {
+async function reconcileEntrySeverity(slug, itemId, entries, priority, scope) {
 	const adapter = requireAdapter();
+	const { root } = scope;
 	for (const entry of entries) {
 		const parsed = adapter.readEntry(entry.pluginData);
 		if (!parsed || parsed.priority === priority) continue;
@@ -199,12 +212,13 @@ async function reconcileEntrySeverity(slug, itemId, entries, priority, root) {
 		});
 	}
 }
-async function doEnsureItemNotification({ slug, schema, itemId, legacyId, displayLabel, priority, root }) {
+async function doEnsureItemNotification({ slug, schema, itemId, legacyId, displayLabel, priority, scope }) {
 	const adapter = requireAdapter();
+	const { root } = scope;
 	try {
-		const existing = await findActiveEntries(slug, itemId, root);
+		const existing = await findActiveEntries(slug, itemId, scope);
 		if (existing.length > 0) {
-			await reconcileEntrySeverity(slug, itemId, existing, priority, root);
+			await reconcileEntrySeverity(slug, itemId, existing, priority, scope);
 			return;
 		}
 		const navigateTarget = adapter.buildNavigateTarget(slug, itemId, root);
@@ -234,9 +248,18 @@ async function doEnsureItemNotification({ slug, schema, itemId, legacyId, displa
 /** Idempotently clear EVERY bell entry that matches this (slug, itemId).
 *  Silent no-op when nothing matches. The "every" is defensive: if a
 *  duplicate ever slips through, this drains the lot. */
-async function clearItemNotification(slug, itemId, root) {
+async function clearItemNotification(slug, itemId, root, aid) {
+	await clearScoped(slug, itemId, {
+		root,
+		aid
+	});
+}
+/** The scoped form every internal caller uses. `clearItemNotification` keeps
+*  its positional `(slug, itemId, root?)` shape because it is public API
+*  (MulmoTerminal calls it); `aid` is additive. */
+async function clearScoped(slug, itemId, scope) {
 	try {
-		const ids = await findActiveEntryIds(slug, itemId, root);
+		const ids = await findActiveEntryIds(slug, itemId, scope);
 		for (const entryId of ids) await clear(entryId);
 	} catch (err) {
 		log().warn("notify clear failed", {
@@ -256,19 +279,19 @@ async function clearItemNotification(slug, itemId, root) {
 *  `{ workspaceRoot: <tmpdir> }` so the check accepts a fixture dataDir. */
 async function reconcileItem(collection, itemId, ioOpts = {}, now = evalNow()) {
 	const { slug, schema } = collection;
-	const root = ioOpts.workspaceRoot;
+	const scope = bellScopeOf(collection, ioOpts);
 	if (!schema.completionField) {
-		await clearItemNotification(slug, itemId, root);
+		await clearScoped(slug, itemId, scope);
 		return;
 	}
 	const item = await storeFor(collection, ioOpts).read(itemId);
 	if (item === null) {
-		await clearItemNotification(slug, itemId, root);
+		await clearScoped(slug, itemId, scope);
 		return;
 	}
 	await maybeSpawnSuccessor(collection, item, itemId, ioOpts);
 	if (itemIsDone(schema, item)) {
-		await clearItemNotification(slug, itemId, root);
+		await clearScoped(slug, itemId, scope);
 		return;
 	}
 	if (schema.triggerField) {
@@ -280,15 +303,15 @@ async function reconcileItem(collection, itemId, ioOpts = {}, now = evalNow()) {
 			triggerField: schema.triggerField
 		});
 		if (due !== true) {
-			await clearItemNotification(slug, itemId, root);
+			await clearScoped(slug, itemId, scope);
 			return;
 		}
 	}
 	if (!whenMatches(schema.notifyWhen, item)) {
-		await clearItemNotification(slug, itemId, root);
+		await clearScoped(slug, itemId, scope);
 		return;
 	}
-	await ensureItemNotification(slug, schema, itemId, resolveDisplayLabel(schema, item, itemId), notifyPriorityForItem(schema, item), root);
+	await ensureItemNotification(slug, schema, itemId, resolveDisplayLabel(schema, item, itemId), notifyPriorityForItem(schema, item), scope);
 }
 /** Boot-time reconcile: walk every record of the collection once (through
 *  its store) and reconcile it. Catches up changes that happened while the
@@ -334,7 +357,7 @@ async function reconcileAllItems(collection, ioOpts = {}, now = evalNow()) {
 *    ever clear, while the reconcile publishes a second rooted one beside it.
 *    Clearing converges — the record republishes rooted if still pending. */
 function sweepVerdict(entry, ownRoot) {
-	if (entry.aid !== void 0) return "skip";
+	if (entry.aid !== void 0) return "shared";
 	if (entry.root === ownRoot) return "mine";
 	if (entry.root === void 0) return "drop-legacy";
 	return "skip";
@@ -344,12 +367,40 @@ function sweepVerdict(entry, ownRoot) {
 *  `notifyWhen`. The reverse of the reconcile invariant, applied to an entry
 *  whose record the forward pass can never walk to (a delete leaves a bell that
 *  a walk over the SURVIVING records cannot clear). */
-async function isStaleEntry(slug, itemId, opts) {
+async function isStaleEntry(slug, itemId, opts, aid) {
 	const collection = await loadCollection(slug, opts);
+	if (aid !== void 0 && collection?.appId !== aid) return false;
 	if (!collection || !collection.schema.completionField) return true;
+	return recordNoLongerBells(collection, itemId, opts);
+}
+/** The record half of the staleness question: gone, done, or outside
+*  `notifyWhen`. Split out so the caller stays one decision — WHOSE entry this
+*  is — and this one stays the other. */
+async function recordNoLongerBells(collection, itemId, opts) {
 	const item = await storeFor(collection, opts).read(itemId);
 	return item === null || itemIsDone(collection.schema, item) || !whenMatches(collection.schema.notifyWhen, item);
 }
+/** One entry's fate: whose it is (`sweepVerdict`), then — when it is this
+*  sweep's to judge — whether its record still justifies the bell. Extracted so
+*  the loop above stays a walk and this stays the decision. */
+async function sweepOneEntry(entryId, parsed, ownRoot, opts) {
+	const verdict = sweepVerdict(parsed, ownRoot);
+	if (verdict === "skip") return;
+	if (verdict === "drop-legacy") {
+		await clear(entryId);
+		return;
+	}
+	const { slug, itemId } = parsed;
+	try {
+		if (await isStaleEntry(slug, itemId, opts, verdict === "shared" ? parsed.aid : void 0)) await clear(entryId);
+	} catch (err) {
+		log().warn("sweep entry failed", {
+			slug,
+			itemId,
+			error: errMsg(err)
+		});
+	}
+}
 async function sweepStaleActiveEntries(opts = {}) {
 	const adapter = requireAdapter();
 	let entries;
@@ -365,22 +416,7 @@ async function sweepStaleActiveEntries(opts = {}) {
 		if (!own) continue;
 		const parsed = parseCompletionLegacyId(own.legacyId);
 		if (!parsed) continue;
-		const verdict = sweepVerdict(parsed, ownRoot);
-		if (verdict === "skip") continue;
-		if (verdict === "drop-legacy") {
-			await clear(entry.id);
-			continue;
-		}
-		const { slug, itemId } = parsed;
-		try {
-			if (await isStaleEntry(slug, itemId, opts)) await clear(entry.id);
-		} catch (err) {
-			log().warn("sweep entry failed", {
-				slug,
-				itemId,
-				error: errMsg(err)
-			});
-		}
+		await sweepOneEntry(entry.id, parsed, ownRoot, opts);
 	}
 }
 /** Test-only: clear the per-key in-flight locks. */
@@ -590,9 +626,58 @@ async function _tickTimeTriggersForTesting(now, workspaceRoot) {
 async function tickTimeTriggers(gen, now = evalNow()) {
 	for (const entry of gen.watchers.values()) {
 		const { schema } = entry.collection;
+		if (cannotReportChanges(gen, entry.collection)) continue;
 		if (!schema.triggerField && !schema.spawn) continue;
 		await reconcileAllItems(entry.collection, gen.discoveryOpts, now);
 	}
+	await tickUnwatchedCollections(gen, now);
+}
+/** True when the collection's store implements no `watch` — nothing will ever
+*  tell this module its records moved, so the clock tick is its only change
+*  detection. A capability question, deliberately not a backend one: the day a
+*  shared collection's store grows an `onSnapshot` watch, it stops being
+*  special here with no edit to this file. */
+function cannotReportChanges(gen, collection) {
+	return storeFor(collection, gen.discoveryOpts).watch === void 0;
+}
+/** True when a schema declares behaviour that only a reconcile pass can
+*  produce: bells (`completionField`), date-triggered bells (`triggerField`),
+*  or recurrence successors (`spawn`). */
+function needsReconcilePass(schema) {
+	return Boolean(schema.completionField ?? schema.triggerField ?? schema.spawn);
+}
+/** One unwatched collection's reconcile pass. Extracted so the single-flight
+*  callback doesn't close over loop state.
+*
+*  `reconcileAllItems` already swallows a failing store read (it logs and
+*  returns), so a closed session or a denied rule surfaces there, not as a
+*  rejection here. This catch is only for the unexpected — it must not let one
+*  collection's fault abort the rest of the tick. */
+async function reconcileUnwatched(gen, collection, now) {
+	try {
+		await runSingleFlight(gen.collectionSlots, collection.slug, () => reconcileAllItems(collection, gen.discoveryOpts, now));
+	} catch (err) {
+		log().warn("unwatched collection reconcile failed", {
+			slug: collection.slug,
+			error: errMsg(err)
+		});
+	}
+}
+/** Stand in for the store-change path (2) on backends that don't have one.
+*
+*  Gated on `needsReconcilePass` so a collection declaring none of it costs
+*  nothing: unlike the local backends, every pass here is a network round trip.
+*
+*  A collection that DROPS OUT of eligibility (its `completionField` edited
+*  away, or the collection removed) is not this pass's problem — `syncWatchers`
+*  already sweeps on a changed schema and on a vanished slug, and the sweep is
+*  what clears bells the declaration no longer justifies. */
+async function tickUnwatchedCollections(gen, now) {
+	if (firestoreHandle() === null) return;
+	const pending = [...gen.watchers.values()].map((entry) => entry.collection).filter((collection) => cannotReportChanges(gen, collection) && needsReconcilePass(collection.schema));
+	if (pending.length === 0) return;
+	for (const collection of pending) await reconcileUnwatched(gen, collection, now);
+	await sweepStaleActiveEntries(gen.discoveryOpts);
 }
 /** Reconcile the watcher set against the currently-discovered
 *  collections. Adds watchers for new slugs (with a boot reconcile of
@@ -633,7 +718,13 @@ function stopVanishedWatchers(gen, liveSlugs) {
 *  modes. The mounted fs.watch is bound to the OLD location, so it must
 *  be remounted, not just re-reconciled. */
 function storagePathChanged(previous, next) {
-	return previous.dataSource?.path !== next.dataSource?.path || previous.dataPath !== next.dataPath || previous.storage?.path !== next.storage?.path;
+	return previous.dataSource?.path !== next.dataSource?.path || previous.dataPath !== next.dataPath || previous.storage?.type !== next.storage?.type || storageFilePath(previous.storage) !== storageFilePath(next.storage);
+}
+/** The on-disk path of a storage backend, or undefined when it has none (a
+*  shared collection keeps its records off this filesystem, so there is no
+*  mount to move — only a `type` change matters for it). */
+function storageFilePath(storage) {
+	return storage?.type === "sqlite" ? storage.path : void 0;
 }
 /** Re-reconcile already-watched collections whose schema changed since
 *  the last tick. New collections fall through to `startNewWatchers`. */