@mulmoclaude/core 3.4.0 → 3.6.0

package/dist/collection-watchers/index.js

@@ -1,9 +1,9 @@
 import { t as canonicalRoot } from "../root-BMroU_mB.js";
-import { k as fieldText } from "../calendarGrid-Csy2rpjp.js";
-import { E as whenMatches, f as itemIsDone } from "../promptSafety-ACXw_2Yu.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 { K as collectionChangePayload, Q as peekWorkspaceRoot, d as storeFor, et as publishCollectionChange, n as discoverCollections, r as loadCollection, z as itemFilePath } from "../discovery-D7LCN8gJ.js";
-import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-D6QY853r.js";
+import { H as itemFilePath, Q as collectionChangePayload, ct as publishCollectionChange, d as storeFor, n as discoverCollections, ot as peekWorkspaceRoot, r as loadCollection, tt as firestoreHandle } from "../discovery-CdkaURVY.js";
+import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-DdHaX_Uu.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
@@ -54,6 +54,12 @@ var LEGACY_ID_PREFIX = "collection-completion:";
 *  so the split is unambiguous. */
 var ROOT_MARK = "@";
 var ROOT_SEP = "\0";
+/** Marks a key that belongs to a SHARED collection (`apps/{aid}/collections/
+*  {cid}`) rather than to a directory: `<prefix>#<aid>\0<cid>:<itemId>`. A
+*  shared collection has no root, and its `cid` may well be the slug some
+*  project already owns, so it needs a mark of its own — reusing the rootless
+*  form would make the two dedupe into one bell. */
+var SHARED_MARK = "#";
 /** Stable key encoding (root, slug, item), round-tripped through the entry's
 *  `pluginData` so we can find it later without a side state file. Slug +
 *  itemId are upstream-validated via `safeSlugName`, which forbids the
@@ -75,21 +81,31 @@ var ROOT_SEP = "\0";
 *  this id is written to disk: a caller reaching `reconcileItem` directly with
 *  `/proj/` where the watcher used `/proj` would otherwise publish a SECOND
 *  bell for the same record, and neither pass would ever clear the other's. */
-function completionLegacyId(slug, itemId, root) {
-	return `${LEGACY_ID_PREFIX}${root === void 0 ? "" : `${ROOT_MARK}${canonicalRoot(root)}${ROOT_SEP}`}${slug}:${itemId}`;
+/** Exported for the format pin in `test/collection-watchers/test_completionId.ts`.
+*  Deliberately NOT on the package barrel: the id is a disk format, not an API. */
+function completionLegacyId(slug, itemId, root, aid) {
+	if (root !== void 0 && aid !== void 0) throw new Error(`completionLegacyId: "${slug}" carries both a root (${root}) and an app (${aid})`);
+	if (!isValidCollectionName(slug)) throw new Error(`completionLegacyId: collection name "${slug}" is not a valid collection name`);
+	if (aid !== void 0 && !isValidCollectionName(aid)) throw new Error(`completionLegacyId: app id "${aid}" is not a valid collection name`);
+	return `${LEGACY_ID_PREFIX}${aid !== void 0 ? `${SHARED_MARK}${aid}${ROOT_SEP}` : root === void 0 ? "" : `${ROOT_MARK}${canonicalRoot(root)}${ROOT_SEP}`}${slug}:${itemId}`;
 }
 /** Decode a key back into its (root, slug, itemId), or null if the string
 *  didn't originate from this module. Accepts both the rooted and the
 *  original root-less form — see the compatibility rule above. Used by the
 *  sweep step. */
+/** @see completionLegacyId — exported for the same reason. */
 function parseCompletionLegacyId(legacyId) {
 	if (!legacyId.startsWith(LEGACY_ID_PREFIX)) return null;
 	let body = legacyId.slice(22);
 	let root;
-	if (body.startsWith(ROOT_MARK)) {
+	let aid;
+	if (body.startsWith(ROOT_MARK) || body.startsWith(SHARED_MARK)) {
+		const shared = body.startsWith(SHARED_MARK);
 		const sep = body.indexOf(ROOT_SEP);
 		if (sep < 0) return null;
-		root = body.slice(1, sep);
+		const scope = body.slice(1, sep);
+		if (shared) aid = scope;
+		else root = canonicalRoot(scope);
 		body = body.slice(sep + 1);
 	}
 	const colon = body.indexOf(":");
@@ -98,6 +114,10 @@ function parseCompletionLegacyId(legacyId) {
 		slug: body.slice(0, colon),
 		itemId: body.slice(colon + 1)
 	};
+	if (aid !== void 0) return {
+		aid,
+		...parsed
+	};
 	return root === void 0 ? parsed : {
 		root,
 		...parsed
@@ -112,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`
@@ -134,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;
@@ -148,7 +180,7 @@ async function ensureItemNotification(slug, schema, itemId, displayLabel, priori
 		legacyId,
 		displayLabel,
 		priority,
-		root
+		scope
 	}) };
 	ensureLocks.set(legacyId, lock);
 	try {
@@ -161,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;
@@ -179,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);
@@ -214,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", {
@@ -236,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) {
@@ -260,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
@@ -313,9 +356,10 @@ async function reconcileAllItems(collection, ioOpts = {}, now = evalNow()) {
 *    on produces a root-less id, so skipping it would strand a bell no pass can
 *    ever clear, while the reconcile publishes a second rooted one beside it.
 *    Clearing converges — the record republishes rooted if still pending. */
-function sweepVerdict(entryRoot, ownRoot) {
-	if (entryRoot === ownRoot) return "mine";
-	if (entryRoot === void 0) return "drop-legacy";
+function sweepVerdict(entry, ownRoot) {
+	if (entry.aid !== void 0) return "shared";
+	if (entry.root === ownRoot) return "mine";
+	if (entry.root === void 0) return "drop-legacy";
 	return "skip";
 }
 /** Should this entry's bell be dropped? True when the collection is gone, no
@@ -323,12 +367,40 @@ function sweepVerdict(entryRoot, 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;
@@ -344,22 +416,7 @@ async function sweepStaleActiveEntries(opts = {}) {
 		if (!own) continue;
 		const parsed = parseCompletionLegacyId(own.legacyId);
 		if (!parsed) continue;
-		const verdict = sweepVerdict(parsed.root, 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. */
@@ -569,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
@@ -612,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`. */