@mulmoclaude/core 0.24.0 → 0.25.1

package/dist/{server-CkysfLh4.cjs → discovery-cwtfyDxl.cjs}

@@ -1,7 +1,7 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_promptSafety = require("./promptSafety-DI_1Rvhk.cjs");
-const require_collection_paths = require("./collection/paths.cjs");
-const require_skill_bridge_index = require("./skill-bridge/index.cjs");
+const require_ids = require("./ids-Dl9Ij63K.cjs");
+const require_project = require("./project-BWI5w_BT.cjs");
+const require_templatePath = require("./templatePath-27vUZowm.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_fs = require("node:fs");
@@ -66,7 +66,7 @@ function collectionsRegistriesConfigPath() {
 	const host = requireHost();
 	return host.paths.collectionsRegistriesConfig(host.workspaceRoot);
 }
-function isPresetSlug$1(slug) {
+function isPresetSlug(slug) {
 	return requireHost().isPresetSlug(slug);
 }
 /** Logger proxy so engine modules can `import { log }` and use it exactly like
@@ -83,7 +83,7 @@ var log = {
 };
 //#endregion
 //#region src/collection/server/paths.ts
-var SCHEMA_FILE$1 = "schema.json";
+var SCHEMA_FILE = "schema.json";
 /** Sanitise a user-supplied slug into a safe directory-name leaf.
 *  Returns null for anything that fails the slug whitelist OR isn't a
 *  basename (i.e. survives `path.basename` round-trip unchanged).
@@ -91,7 +91,7 @@ var SCHEMA_FILE$1 = "schema.json";
 *  `js/path-injection` sanitiser. */
 function safeSlugName(slug) {
 	if (typeof slug !== "string") return null;
-	if (!require_promptSafety.SAFE_SLUG_PATTERN.test(slug)) return null;
+	if (!require_ids.SAFE_SLUG_PATTERN.test(slug)) return null;
 	const basename = node_path.default.basename(slug);
 	if (basename !== slug) return null;
 	return basename;
@@ -103,7 +103,7 @@ function safeSlugName(slug) {
 *  `js/path-injection` sanitiser CodeQL recognises on `safeSlugName`. */
 function safeRecordId(recordId) {
 	if (typeof recordId !== "string") return null;
-	if (!require_promptSafety.SAFE_RECORD_ID_PATTERN.test(recordId)) return null;
+	if (!require_ids.SAFE_RECORD_ID_PATTERN.test(recordId)) return null;
 	if (recordId.includes("..")) return null;
 	const basename = node_path.default.basename(recordId);
 	if (basename !== recordId) return null;
@@ -940,7 +940,7 @@ async function readHead(absPath, bytes) {
 /** Decode the whole file into a UTF-8 cache copy and return its path.
 *  Cache key = (path, mtime, size), so a replaced CSV re-decodes and an
 *  unchanged one never does. */
-async function pathExists$1(target) {
+async function pathExists(target) {
 	try {
 		await (0, node_fs_promises.stat)(target);
 		return true;
@@ -967,7 +967,7 @@ async function evictSupersededCache(key, keepBasename) {
 async function decodeToCache(absPath, info) {
 	const key = (0, node_crypto.createHash)("sha256").update(absPath).digest("hex").slice(0, 16);
 	const cached = node_path.default.join(cacheDir(), `${key}-${Math.trunc(info.mtimeMs)}-${info.size}.csv`);
-	if (!await pathExists$1(cached)) {
+	if (!await pathExists(cached)) {
 		const whole = await (0, node_fs_promises.readFile)(absPath);
 		const encoding = fallbackEncoding(whole);
 		const text = iconv_lite.default.decode(whole, encoding);
@@ -1050,13 +1050,12 @@ async function queryCsv(sql, params) {
 		connection.disconnectSync();
 	}
 }
-/** Every row of the CSV as records — capped, deduped, id-encoded. The
-*  key column is pinned to VARCHAR (see `readCsvArgs`). `workspaceRoot`
-*  drives the per-read containment check; omitted, the configured host
-*  root is used. */
 async function csvList(absPath, primaryKey, workspaceRoot) {
 	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
-	if (utf8Path === null) return [];
+	if (utf8Path === null) return {
+		items: [],
+		truncated: false
+	};
 	let rows;
 	try {
 		rows = await queryCsv(`SELECT * FROM read_csv(${readCsvArgs(primaryKey)}) LIMIT 5001`, [utf8Path]);
@@ -1066,9 +1065,13 @@ async function csvList(absPath, primaryKey, workspaceRoot) {
 			path: absPath,
 			primaryKey
 		});
-		return [];
+		return {
+			items: [],
+			truncated: false
+		};
 	}
-	if (rows.length > 5e3) {
+	const truncated = rows.length > MAX_CSV_ROWS;
+	if (truncated) {
 		log.warn("collections", "dataSource CSV truncated to row cap", {
 			path: absPath,
 			cap: MAX_CSV_ROWS
@@ -1086,7 +1089,10 @@ async function csvList(absPath, primaryKey, workspaceRoot) {
 		path: absPath,
 		duplicates: deduped.duplicates
 	});
-	return deduped.items;
+	return {
+		items: deduped.items,
+		truncated
+	};
 }
 /** The scan-order ordinal column the last-match read adds. Underscore
 *  prefix keeps it out of any plausible CSV header namespace; it is
@@ -1118,287 +1124,357 @@ async function csvRunQuery(absPath, primaryKey, query, workspaceRoot) {
 	return (await queryCsv(sql, [utf8Path, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
 }
 //#endregion
-//#region src/collection/server/store.ts
-/** True when the collection accepts UI/tool writes. A `dataSource`
-*  collection is read-only: updates happen by editing/replacing the
-*  data file itself. Every write entry point checks this BEFORE calling
-*  `writeItem`/`deleteItem` — server-enforced, not just UI-hidden. */
-function collectionWritable(collection) {
-	return !require_promptSafety.isReadOnlySchema(collection.schema);
-}
-/** The one-line refusal write paths surface (HTTP 405 / MCP error text). */
-function readOnlyRefusal(slug) {
-	return `collection '${slug}' is read-only (backed by an external dataSource) — update the data file itself instead`;
-}
-/** Pick the store implementation for a discovered collection. A
-*  `dataSource` schema whose `dataSourceFile` failed to resolve yields a
-*  read-only EMPTY store rather than falling back to the (writable) file
-*  store — a half-loaded read-only collection must never become writable. */
-function storeFor(collection, opts = {}) {
-	if (require_promptSafety.isReadOnlySchema(collection.schema)) {
-		const file = collection.dataSourceFile;
-		const key = collection.schema.primaryKey;
-		return {
-			capabilities: { writable: false },
-			list: () => file === void 0 ? Promise.resolve([]) : csvList(file, key, opts.workspaceRoot),
-			read: (itemId) => file === void 0 ? Promise.resolve(null) : csvRead(file, key, itemId, opts.workspaceRoot),
-			query: (query) => file === void 0 ? Promise.resolve([]) : csvRunQuery(file, key, query, opts.workspaceRoot)
-		};
-	}
+//#region src/collection/server/storePage.ts
+/** Project `fields` (+ the primary key, always) out of each record. Thin
+*  server-typed alias over the shared isomorphic `projectRecordFields`
+*  (../core/project.ts) — kept as the store layer's exported name. */
+function projectItemFields(items, fields, primaryKey) {
+	return require_project.projectRecordFields(items, fields, primaryKey);
+}
+/** Slice + project an already-ordered full read into a `ListPage` — the
+*  shared emulation for stores without native paging. Pure, exported for
+*  tests. `limit: 0` is a valid "count only" page. */
+function pageFromFullRead(items, opts, primaryKey, truncated) {
+	const offset = Math.max(0, opts.offset ?? 0);
+	const end = opts.limit === void 0 ? void 0 : offset + Math.max(0, opts.limit);
 	return {
-		capabilities: { writable: true },
-		list: () => listItems(collection.dataDir, opts),
-		read: (itemId) => readItem(collection.dataDir, itemId, opts)
+		items: projectItemFields(items.slice(offset, end), opts.fields, primaryKey),
+		total: items.length,
+		truncated
 	};
 }
 //#endregion
-//#region src/collection/server/jsonlQuery.ts
-/** SQL semantics for an aggregate-only query over ZERO rows: one scalar
-*  row (`count` = 0, everything else NULL) — the same shape the CSV path
-*  produces for a header-only file, so callers reading `rows[0]` never
-*  break on storage kind or emptiness. A grouped query over zero rows is
-*  zero groups (`[]`), also matching SQL. Synthesized here because DuckDB
-*  has no empty file to infer a schema from. */
-function emptyCollectionResult(query) {
-	if ((query.groupBy?.length ?? 0) > 0) return [];
-	const aggregates = Object.entries(query.aggregates ?? {});
-	return [Object.fromEntries(aggregates.map(([alias, aggregate]) => [alias, aggregate.op === "count" ? 0 : null]))];
-}
-/** The SOURCE columns a query reads: groupBy columns, aggregate input
-*  columns, and where fields. (orderBy resolves to groupBy columns or
-*  aggregate ALIASES — never to a new source column — so it adds none.) */
-function referencedSourceColumns(query) {
-	const columns = new Set(query.groupBy ?? []);
-	for (const aggregate of Object.values(query.aggregates ?? {})) if (aggregate.column !== void 0) columns.add(aggregate.column);
-	for (const cond of query.where ?? []) columns.add(cond.field);
-	return [...columns];
-}
-/** Referenced columns that appear in NO row — a freshly-added optional
-*  field, or a derived field whose inputs no record has yet. DuckDB only
-*  infers columns from keys that occur in the JSONL, so without help a
-*  valid query on such a field binder-errors here while the CSV path
-*  (whose header always declares the column) returns NULLs. Padding the
-*  FIRST line with `col: null` makes the column exist (full-scan
-*  inference unions keys across lines) with matching NULL semantics. */
-function absentReferencedColumns(rows, query) {
-	const present = /* @__PURE__ */ new Set();
-	for (const row of rows) for (const key of Object.keys(row)) present.add(key);
-	return referencedSourceColumns(query).filter((column) => !present.has(column));
-}
-/** Run a validated query over enriched collection rows. */
-async function runQueryOverRows(rows, query) {
-	if (rows.length === 0) return emptyCollectionResult(query);
-	await (0, node_fs_promises.mkdir)(cacheDir(), {
-		recursive: true,
-		mode: 448
+//#region src/collection/server/sqliteStore.ts
+var sqliteModule = null;
+/** Lazy-load node:sqlite once. A runtime without it (Node < 22.5) throws a
+*  clearly-worded error the caller surfaces — never a bare MODULE_NOT_FOUND. */
+function loadSqlite() {
+	sqliteModule ??= import("node:sqlite").then((mod) => mod, (err) => {
+		sqliteModule = null;
+		throw new Error(`sqlite storage needs the node:sqlite module (Node.js >= 22.5) — this runtime cannot load it: ${String(err)}`);
 	});
-	const jsonlPath = node_path.default.join(cacheDir(), `q-${(0, node_crypto.randomBytes)(8).toString("hex")}.jsonl`);
+	return sqliteModule;
+}
+/** The db file's on-disk state. A symlink or non-regular file is refused
+*  (file-disclosure defense, same rule as io.ts record files); ENOENT is
+*  just "no records yet". Any OTHER lstat failure (EACCES, EIO, …) is
+*  rethrown so reads surface a real filesystem problem instead of
+*  silently reporting an empty collection. */
+async function dbFileState(absPath) {
 	try {
-		const nullPads = Object.fromEntries(absentReferencedColumns(rows, query).map((column) => [column, null]));
-		const handle = await (0, node_fs_promises.open)(jsonlPath, "wx", 384);
-		try {
-			let first = true;
-			for (const row of rows) {
-				await handle.write(`${JSON.stringify(first ? {
-					...nullPads,
-					...row
-				} : row)}\n`);
-				first = false;
-			}
-		} finally {
-			await handle.close();
-		}
-		const { sql, params } = compileJsonlQuery(query);
-		return (await queryCsv(sql, [jsonlPath, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
-	} finally {
-		await (0, node_fs_promises.unlink)(jsonlPath).catch((err) => {
-			if (err.code !== "ENOENT") log.warn("collections", "temp JSONL cleanup failed", {
-				path: jsonlPath,
-				error: String(err)
-			});
-		});
+		return (await (0, node_fs_promises.lstat)(absPath)).isFile() ? "file" : "refused";
+	} catch (err) {
+		if (err.code === "ENOENT") return "missing";
+		throw err;
 	}
 }
-//#endregion
-//#region src/collection/core/recordZ.ts
-/** The emptiness rule shared by `required` and the "only check present
-*  values" gate. NOT a truthiness check — `0` and `false` are filled. */
-var isEmptyValue = (value) => value === void 0 || value === null || value === "";
-/** The historical write-gate checks, verbatim: required non-empty, enum
-*  membership (compared as strings, so a numeric `5` satisfies `"5"`). */
-function enforcedProblem(key, spec, value) {
-	const empty = isEmptyValue(value);
-	if (spec.required && empty) return `missing required field '${key}'`;
-	if (!empty && spec.type === "enum" && !spec.values.includes(String(value))) return `'${key}' = '${String(value)}' is not one of [${spec.values.join(", ")}]`;
-	return null;
-}
-/** Report-only per-type checks on a PRESENT value. Date / datetime reuse the
-*  calendar's STRICT civil parsers (`parseIsoDate` / `parseIsoDateTime`), so
-*  the lint flags exactly the values the calendar / trigger / spawn code
-*  would silently drop — impossible days like `2026-02-30`, and datetimes
-*  outside the canonical `YYYY-MM-DDTHH:MM[:SS]` shape (e.g. a `Z` suffix,
-*  which the day view can't place). `string`-backed types accept anything
-*  stringifiable; `ref` existence is out of scope. */
-function strictTypeProblem(key, spec, value) {
-	switch (spec.type) {
-		case "number":
-		case "money": return Number.isFinite(require_promptSafety.coerceNumeric(value)) ? null : `'${key}' = '${String(value)}' is not numeric (a '${spec.type}' field stores a plain number)`;
-		case "boolean": return value === true || value === false ? null : `'${key}' = '${String(value)}' is not a boolean (store true or false, unquoted)`;
-		case "date": return require_promptSafety.parseIsoDate(value) !== null ? null : `'${key}' = '${String(value)}' is not a real YYYY-MM-DD date`;
-		case "datetime": return require_promptSafety.parseIsoDateTime(value) !== null ? null : `'${key}' = '${String(value)}' is not a YYYY-MM-DDTHH:MM datetime (seconds optional, no timezone suffix — the shape the calendar parses)`;
-		default: return null;
-	}
-}
-/** Strict check for a PRESENT `table` value: an array of row objects, each
-*  row conforming to the sub-schema (required / enum / typed sub-values).
-*  First row problem wins, prefixed with the row number so the fix is
-*  locatable. */
-function strictTableProblem(key, spec, value) {
-	if (!Array.isArray(value)) return `'${key}' = '${String(value)}' is not an array of rows (a 'table' field stores an array of row objects)`;
-	for (let index = 0; index < value.length; index++) {
-		const row = value[index];
-		if (!row || typeof row !== "object" || Array.isArray(row)) return `'${key}' row ${index + 1} is not an object`;
-		for (const [subKey, subSpec] of Object.entries(spec.of)) {
-			const subValue = row[subKey];
-			const problem = enforcedProblem(subKey, subSpec, subValue) ?? (isEmptyValue(subValue) ? null : strictTypeProblem(subKey, subSpec, subValue));
-			if (problem) return `'${key}' row ${index + 1}: ${problem}`;
+var CREATE_TABLE = "CREATE TABLE IF NOT EXISTS records (id TEXT PRIMARY KEY, record TEXT NOT NULL)";
+/** Open the database for one operation, classifying the two unavailable
+*  states so callers can map them honestly (`refused` ⇒ path-escape,
+*  `missing` ⇒ empty / not-found — conflating them would misreport a
+*  containment escape as "item not found"). The containment pre-check runs
+*  BEFORE mkdir even when the file is missing — `isContainedInRoot`
+*  resolves through the closest existing ancestor, so a symlinked-away
+*  parent can never make the recursive mkdir create directories outside
+*  the workspace (same pre/post belt-and-suspenders as io.ts writes). */
+async function openDb(absPath, workspaceRoot, mode) {
+	const state = await dbFileState(absPath);
+	if (state === "refused") {
+		log.warn("collections", "sqlite database refused: not a regular file", { path: absPath });
+		return { kind: "refused" };
+	}
+	if (!isContainedInRoot(node_path.default.dirname(absPath), workspaceRoot)) {
+		log.warn("collections", "sqlite refused: database dir escapes workspace via symlink", { path: absPath });
+		return { kind: "refused" };
+	}
+	if (mode === "read" && state === "missing") return { kind: "missing" };
+	if (mode === "write") {
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(absPath), { recursive: true });
+		if (!isContainedInRoot(node_path.default.dirname(absPath), workspaceRoot)) {
+			log.warn("collections", "sqlite write refused: database dir escapes workspace via symlink (post-mkdir)", { path: absPath });
+			return { kind: "refused" };
 		}
 	}
-	return null;
-}
-/** First problem for one field's stored value under `tier`, or null.
-*  Enforced checks always run (and their messages never vary by tier — the
-*  scan and the write gate must agree on them); strict adds the per-type
-*  layer on present values only. */
-function recordFieldProblem(key, spec, value, tier) {
-	const enforced = enforcedProblem(key, spec, value);
-	if (enforced || tier === "enforced") return enforced;
-	if (isEmptyValue(value)) return null;
-	if (spec.type === "table") return strictTableProblem(key, spec, value);
-	return strictTypeProblem(key, spec, value);
-}
-var compiled = /* @__PURE__ */ new WeakMap();
-/** Compile `schema.fields` into a zod validator for a stored record.
-*  Loose object: unknown keys are allowed and any declared key may be
-*  absent (records are user files, not parse-and-rewrite targets —
-*  callers validate, they never persist the parse output). The checks run
-*  as ONE object-level refine iterating fields in declaration order —
-*  per-key shape schemas can't express "key may be absent BUT its absence
-*  must still reach the required check", and the single loop keeps the
-*  first reported issue identical to the historical first-problem-wins
-*  contract. */
-function compileRecordZ(schema, tier) {
-	const cached = compiled.get(schema)?.[tier];
-	if (cached) return cached;
-	const stored = Object.entries(schema.fields).filter(([, spec]) => !require_promptSafety.COMPUTED_TYPES.has(spec.type));
-	const validator = zod.z.looseObject({}).superRefine((record, ctx) => {
-		for (const [key, spec] of stored) {
-			const problem = recordFieldProblem(key, spec, record[key], tier);
-			if (problem) ctx.addIssue({
-				code: "custom",
-				message: problem,
-				path: [key]
-			});
-		}
-	});
-	const entry = compiled.get(schema) ?? {};
-	entry[tier] = validator;
-	compiled.set(schema, entry);
-	return validator;
-}
-/** First schema problem on an in-memory record under `tier`, or null. One
-*  issue per record keeps the report short and the fix obvious (the
-*  historical contract of `validateRecordObject`). */
-function firstRecordProblem(record, schema, tier) {
-	const result = compileRecordZ(schema, tier).safeParse(record);
-	if (result.success) return null;
-	return result.error.issues[0]?.message ?? "record failed schema validation";
+	const { DatabaseSync } = await loadSqlite();
+	const database = new DatabaseSync(absPath);
+	database.exec("PRAGMA busy_timeout = 5000");
+	database.exec(CREATE_TABLE);
+	return {
+		kind: "ok",
+		database
+	};
 }
-//#endregion
-//#region src/collection/server/validate.ts
-var MAX_ISSUES = 25;
-/** Read every `<id>.json` under the collection's dataDir and report the
-*  ones that won't load or violate the schema. An empty list means every
-*  record is fine. */
-/** List entries under the data dir, guarding realpath containment (against a
-*  symlinked dir swapped in after discovery, like `listItems`) and treating a
-*  missing dir as empty while surfacing real I/O faults. */
-async function listRecordFilenames(dataDir, workspaceRoot) {
-	if (!isContainedInRoot(dataDir, workspaceRoot)) {
-		log.warn("collections", "validate refused: dataDir escapes workspace via symlink", { dataDir });
-		return [];
-	}
+/** Run `operation` against the database and always close it; unavailable
+*  states resolve through `onUnavailable` so each caller maps `missing`
+*  vs `refused` to its own result kind. */
+async function withDb(absPath, workspaceRoot, mode, onUnavailable, operation) {
+	const handle = await openDb(absPath, workspaceRoot, mode);
+	if (handle.kind !== "ok") return onUnavailable(handle.kind);
 	try {
-		return await (0, node_fs_promises.readdir)(dataDir);
-	} catch (err) {
-		if (err.code === "ENOENT") return [];
-		throw err;
+		return await operation(handle.database);
+	} finally {
+		handle.database.close();
 	}
 }
-async function validateCollectionRecords(collection, opts = {}) {
-	if (collection.schema.dataSource !== void 0) return [];
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const entries = await listRecordFilenames(collection.dataDir, workspaceRoot);
-	const issues = [];
-	for (const name of entries.sort()) {
-		if (!name.endsWith(".json") || name.startsWith(".")) continue;
-		if (issues.length >= MAX_ISSUES) break;
-		const issue = await inspectRecord(node_path.default.join(collection.dataDir, name), name, collection.schema);
-		if (issue) issues.push(issue);
-	}
-	return issues;
+/** node:sqlite throws ERR_SQLITE_ERROR with the SQLite extended result
+*  code on `errcode`. Our INSERT's duplicate-id failure is
+*  SQLITE_CONSTRAINT_PRIMARYKEY (1555); SQLITE_CONSTRAINT_UNIQUE (2067)
+*  covers a plain UNIQUE index. Checked structurally (message text kept
+*  only as a fallback for runtimes that don't expose `errcode`). */
+function isUniqueConstraintError(err) {
+	const { errcode } = err;
+	if (errcode !== void 0) return errcode === 1555 || errcode === 2067;
+	return String(err).includes("UNIQUE constraint");
 }
-async function readRecordText(fullPath, name) {
+function parseRow(raw) {
+	if (typeof raw !== "string") return null;
 	try {
-		if (!(await (0, node_fs_promises.lstat)(fullPath)).isFile()) return {
-			file: name,
-			problem: "not a regular file (symlink?) — skipped, won't appear"
-		};
-		return { raw: await (0, node_fs_promises.readFile)(fullPath, "utf-8") };
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
 	} catch {
+		return null;
+	}
+}
+function rowsToItems(rows) {
+	return rows.map((row) => parseRow(row.record)).filter((item) => item !== null);
+}
+async function sqliteList(absPath, workspaceRoot) {
+	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
+}
+async function sqlitePage(absPath, primaryKey, opts, workspaceRoot) {
+	const emptyPage = {
+		items: [],
+		total: 0,
+		truncated: false
+	};
+	return withDb(absPath, workspaceRoot, "read", () => emptyPage, (database) => {
+		const total = Number(database.prepare("SELECT COUNT(*) AS n FROM records").get().n);
+		const offset = Math.max(0, opts.offset ?? 0);
+		const limit = opts.limit === void 0 ? -1 : Math.max(0, opts.limit);
 		return {
-			file: name,
-			problem: "could not be read — skipped, won't appear"
+			items: projectItemFields(rowsToItems(database.prepare("SELECT record FROM records ORDER BY id LIMIT ? OFFSET ?").all(limit, offset)), opts.fields, primaryKey),
+			total,
+			truncated: false
 		};
-	}
+	});
 }
-/** Classify a single record file: unreadable / unparseable / non-object /
-*  schema violation, or null when it's fine. */
-async function inspectRecord(fullPath, name, schema) {
-	const read = await readRecordText(fullPath, name);
-	if ("problem" in read) return read;
-	let parsed;
-	try {
-		parsed = JSON.parse(read.raw);
-	} catch (err) {
+async function sqliteRead(absPath, itemId, workspaceRoot) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return null;
+	return withDb(absPath, workspaceRoot, "read", () => null, (database) => {
+		const row = database.prepare("SELECT record FROM records WHERE id = ?").get(safeId);
+		return row === void 0 ? null : parseRow(row.record);
+	});
+}
+async function sqliteWrite(absPath, itemId, item, opts) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
+	};
+	const outcome = await withDb(absPath, opts.workspaceRoot, "write", () => ({
+		kind: "path-escape",
+		itemId: safeId
+	}), (database) => {
+		const payload = JSON.stringify(item);
+		if (opts.refuseOverwrite) try {
+			database.prepare("INSERT INTO records (id, record) VALUES (?, ?)").run(safeId, payload);
+		} catch (err) {
+			if (isUniqueConstraintError(err)) return {
+				kind: "conflict",
+				itemId: safeId
+			};
+			throw err;
+		}
+		else database.prepare("INSERT INTO records (id, record) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET record = excluded.record").run(safeId, payload);
 		return {
-			file: name,
-			problem: `invalid JSON (${err instanceof Error ? err.message : String(err)}) — SKIPPED, won't appear. Usual cause: an unescaped " inside a string value; use 「」/『』 or write \\" instead.`
+			kind: "ok",
+			itemId: safeId,
+			item
+		};
+	});
+	if (outcome.kind === "ok" && opts.slug) publishCollectionChange({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "upsert"
+	});
+	return outcome;
+}
+async function sqliteDelete(absPath, itemId, opts) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
+	};
+	const outcome = await withDb(absPath, opts.workspaceRoot, "read", (reason) => reason === "refused" ? {
+		kind: "path-escape",
+		itemId: safeId
+	} : {
+		kind: "not-found",
+		itemId: safeId
+	}, (database) => {
+		const { changes } = database.prepare("DELETE FROM records WHERE id = ?").run(safeId);
+		return Number(changes) === 0 ? {
+			kind: "not-found",
+			itemId: safeId
+		} : {
+			kind: "ok",
+			itemId: safeId
 		};
+	});
+	if (outcome.kind === "ok" && opts.slug) publishCollectionChange({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "delete"
+	});
+	return outcome;
+}
+/** Best-effort full WAL checkpoint so the MAIN db file alone is a
+*  complete snapshot (committed pages in `<db>-wal` are folded in and the
+*  WAL truncated). Used by `deleteCollection` before archiving. Returns
+*  false on any failure (runtime without node:sqlite, locked db, missing
+*  file) — the caller then archives the sidecar files alongside the db so
+*  no committed data is lost either way. */
+async function checkpointSqliteDatabase(absPath) {
+	try {
+		const { DatabaseSync } = await loadSqlite();
+		const database = new DatabaseSync(absPath);
+		try {
+			database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		} finally {
+			database.close();
+		}
+		return true;
+	} catch {
+		return false;
 	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {
-		file: name,
-		problem: "not a JSON object — skipped, won't appear"
+}
+/** A `storage: sqlite` store over `collection.storageFile`. A schema whose
+*  `storageFile` failed to resolve yields a read-only EMPTY store rather
+*  than a writable one — same fail-closed rule as the CSV store. */
+function sqliteStoreFor(collection, opts) {
+	const file = collection.storageFile;
+	const key = collection.schema.primaryKey;
+	const slug = opts.slug ?? collection.slug;
+	const root = () => opts.workspaceRoot ?? getWorkspaceRoot();
+	if (file === void 0) return {
+		capabilities: {
+			writable: false,
+			nativeQuery: false,
+			nativePaging: false
+		},
+		list: () => Promise.resolve([]),
+		page: () => Promise.resolve({
+			items: [],
+			total: 0,
+			truncated: false
+		}),
+		read: () => Promise.resolve(null)
 	};
-	const problem = validateRecordObject(parsed, name.replace(/\.json$/, ""), schema, "strict");
-	return problem ? {
-		file: name,
-		problem
-	} : null;
-}
-/** First schema problem on an in-memory record (primaryKey↔id mismatch,
-*  then the compiled per-field checks — see `../core/recordZ` for the two
-*  tiers), or null when it's fine. One issue per record keeps the report
-*  short and the fix obvious. Pure + exported so write paths
-*  (manageCollection putItems) can gate on the SAME enforced rules the
-*  post-hoc file scan reports — `itemId` is the id the record is (or
-*  would be) stored under. The default `"enforced"` tier keeps every
-*  write gate on the historical three checks; only pass `"strict"` from
-*  report-only surfaces. */
-function validateRecordObject(record, itemId, schema, tier = "enforced") {
-	const idValue = record[schema.primaryKey];
-	if (typeof idValue !== "string" || idValue !== itemId) return `'${schema.primaryKey}' is '${String(idValue ?? "")}' but must equal the filename ('${itemId}'), or the record can't be opened`;
-	return firstRecordProblem(record, schema, tier);
+	return {
+		capabilities: {
+			writable: true,
+			nativeQuery: false,
+			nativePaging: true
+		},
+		list: () => sqliteList(file, root()),
+		page: (pageOpts = {}) => sqlitePage(file, key, pageOpts, root()),
+		read: (itemId) => sqliteRead(file, itemId, root()),
+		write: (itemId, item, writeOpts = {}) => sqliteWrite(file, itemId, item, {
+			workspaceRoot: root(),
+			slug,
+			refuseOverwrite: writeOpts.refuseOverwrite
+		}),
+		delete: (itemId) => sqliteDelete(file, itemId, {
+			workspaceRoot: root(),
+			slug
+		})
+	};
+}
+//#endregion
+//#region src/collection/server/store.ts
+/** The file store's stable order: lexicographic by record id (codepoint
+*  compare — locale-independent). `listItems` returns readdir order, which
+*  is filesystem-dependent; paging needs determinism. */
+function sortByRecordId(items, primaryKey) {
+	return [...items].sort((left, right) => {
+		const leftId = String(left[primaryKey] ?? "");
+		const rightId = String(right[primaryKey] ?? "");
+		if (leftId < rightId) return -1;
+		return leftId > rightId ? 1 : 0;
+	});
+}
+/** True when the collection accepts UI/tool writes. A `dataSource`
+*  collection is read-only: updates happen by editing/replacing the
+*  data file itself. Every write entry point checks this BEFORE calling
+*  `writeItem`/`deleteItem` — server-enforced, not just UI-hidden. */
+function collectionWritable(collection) {
+	return !require_ids.isReadOnlySchema(collection.schema);
+}
+/** The one-line refusal write paths surface (HTTP 405 / MCP error text). */
+function readOnlyRefusal(slug) {
+	return `collection '${slug}' is read-only (backed by an external dataSource) — update the data file itself instead`;
+}
+/** A `dataSource` store over `file` (CSV row order; DuckDB-native query).
+*  A schema whose `dataSourceFile` failed to resolve yields a read-only
+*  EMPTY store rather than falling back to the (writable) file store — a
+*  half-loaded read-only collection must never become writable. */
+function csvStoreFor(collection, opts) {
+	const file = collection.dataSourceFile;
+	const key = collection.schema.primaryKey;
+	const listAll = () => file === void 0 ? Promise.resolve({
+		items: [],
+		truncated: false
+	}) : csvList(file, key, opts.workspaceRoot);
+	return {
+		capabilities: {
+			writable: false,
+			nativeQuery: true,
+			nativePaging: false
+		},
+		list: () => listAll().then((result) => result.items),
+		page: (pageOpts = {}) => listAll().then((result) => pageFromFullRead(result.items, pageOpts, key, result.truncated)),
+		read: (itemId) => file === void 0 ? Promise.resolve(null) : csvRead(file, key, itemId, opts.workspaceRoot),
+		query: (query) => file === void 0 ? Promise.resolve([]) : csvRunQuery(file, key, query, opts.workspaceRoot)
+	};
+}
+/** The classic file store over `<dataDir>/<itemId>.json` records. */
+function fileStoreFor(collection, opts) {
+	const key = collection.schema.primaryKey;
+	const ioOpts = {
+		...opts,
+		slug: opts.slug ?? collection.slug
+	};
+	return {
+		capabilities: {
+			writable: true,
+			nativeQuery: false,
+			nativePaging: false
+		},
+		list: () => listItems(collection.dataDir, opts),
+		page: async (pageOpts = {}) => pageFromFullRead(sortByRecordId(await listItems(collection.dataDir, opts), key), pageOpts, key, false),
+		read: (itemId) => readItem(collection.dataDir, itemId, opts),
+		write: (itemId, item, writeOpts = {}) => writeItem(collection.dataDir, itemId, item, {
+			...ioOpts,
+			refuseOverwrite: writeOpts.refuseOverwrite
+		}),
+		delete: (itemId) => deleteItem(collection.dataDir, itemId, ioOpts)
+	};
+}
+var storeFactories = /* @__PURE__ */ new Map([
+	["file", fileStoreFor],
+	["csv", csvStoreFor],
+	["sqlite", sqliteStoreFor]
+]);
+/** Pick the store implementation for a discovered collection via the
+*  factory registry. An unknown kind cannot normally reach here (the
+*  schema's `StorageZ` union gates it), so the throw is a loud invariant
+*  breach, not a user-facing path. */
+function storeFor(collection, opts = {}) {
+	const kind = require_ids.storageKindFor(collection.schema);
+	const factory = storeFactories.get(kind);
+	if (!factory) throw new Error(`no store factory registered for storage kind '${kind}'`);
+	return factory(collection, opts);
 }
 /** The param name a `set` value references, or null when the value is a
 *  literal (non-strings can never be references). A bare/empty prefix
@@ -1427,70 +1503,6 @@ function resolveMutateSet(set, params) {
 	return resolved;
 }
 //#endregion
-//#region src/collection/server/mutate.ts
-/** First problem with the submitted params, or null. Every declared param
-*  is checked by the shared record-field validator; keys the action never
-*  declared are rejected outright — a stray key would otherwise ride the
-*  resolved `set` semantics silently. */
-function firstMutateParamProblem(action, params) {
-	const declared = action.params ?? {};
-	for (const key of Object.keys(params)) if (declared[key] === void 0) return `unknown param '${key}' — not declared by action '${action.id}'`;
-	for (const [key, spec] of Object.entries(declared)) {
-		const problem = recordFieldProblem(key, spec, params[key], "strict");
-		if (problem) return problem;
-	}
-	return null;
-}
-/** Apply one mutate action to one record. Never throws for data-shaped
-*  failures — the outcome's `problem` doubles as agent feedback when an
-*  LLM (not the user) pressed the button. */
-async function applyMutateAction(collection, action, itemId, params, opts = {}) {
-	const paramProblem = firstMutateParamProblem(action, params);
-	if (paramProblem) return {
-		ok: false,
-		status: "invalid-params",
-		problem: paramProblem
-	};
-	const existing = await readItem(collection.dataDir, itemId, opts);
-	if (!existing) return {
-		ok: false,
-		status: "not-found",
-		problem: `item '${itemId}' not found`
-	};
-	if (!require_promptSafety.actionVisible(action, existing)) return {
-		ok: false,
-		status: "require-unmet",
-		problem: `action '${action.id}' is not available for item '${itemId}' in its current state`
-	};
-	const stored = Object.entries(existing).filter(([key]) => {
-		const spec = collection.schema.fields[key];
-		return !spec || !require_promptSafety.COMPUTED_TYPES.has(spec.type);
-	});
-	const merged = {
-		...Object.fromEntries(stored),
-		...resolveMutateSet(action.set, params)
-	};
-	const invalid = validateRecordObject(merged, itemId, collection.schema);
-	if (invalid) return {
-		ok: false,
-		status: "invalid-record",
-		problem: invalid
-	};
-	const result = await writeItem(collection.dataDir, itemId, merged, {
-		workspaceRoot: opts.workspaceRoot,
-		slug: collection.slug
-	});
-	if (result.kind !== "ok") return {
-		ok: false,
-		status: "write-refused",
-		problem: `write refused (${result.kind})`
-	};
-	return {
-		ok: true,
-		item: merged
-	};
-}
-//#endregion
 //#region src/collection/core/schemaZ.ts
 /** Optional visibility predicate shared by actions and fields: the target
 *  shows only when the open record's `field` (stringified) is one of `in`.
@@ -1583,7 +1595,7 @@ var RefFieldZ = zod.z.object({
 	type: zod.z.literal("ref"),
 	...fieldBase,
 	to: zod.z.string().min(1)
-}).refine((spec) => require_promptSafety.isSafeSlug(spec.to), slugMessage("to"));
+}).refine((spec) => require_ids.isSafeSlug(spec.to), slugMessage("to"));
 /** A money amount. See `currencyKeys` for the currency-source contract. */
 var MoneyFieldZ = zod.z.object({
 	type: zod.z.literal("money"),
@@ -1618,7 +1630,7 @@ var SubRefFieldZ = zod.z.object({
 	type: zod.z.literal("ref"),
 	...subFieldBase,
 	to: zod.z.string().min(1)
-}).refine((spec) => require_promptSafety.isSafeSlug(spec.to), slugMessage("to"));
+}).refine((spec) => require_ids.isSafeSlug(spec.to), slugMessage("to"));
 var SubMoneyFieldZ = zod.z.object({
 	type: zod.z.literal("money"),
 	...subFieldBase,
@@ -1681,7 +1693,7 @@ var EmbedFieldZ = zod.z.object({
 	to: zod.z.string().min(1),
 	id: zod.z.string().trim().min(1).optional(),
 	idField: zod.z.string().trim().min(1).optional()
-}).refine((spec) => require_promptSafety.isSafeSlug(spec.to) && spec.id !== void 0 !== (spec.idField !== void 0), {
+}).refine((spec) => require_ids.isSafeSlug(spec.to) && spec.id !== void 0 !== (spec.idField !== void 0), {
 	message: "fields with type 'embed' must declare a `to` (valid collection slug) and exactly one of `id` (a fixed record's primary key) or `idField` (a sibling field naming the per-record target)",
 	path: ["id"]
 });
@@ -1702,7 +1714,7 @@ var BacklinksFieldZ = zod.z.object({
 	via: zod.z.string().trim().min(1),
 	display: zod.z.array(zod.z.string().trim().min(1)).min(1),
 	filter: WhenZ.optional()
-}).refine((spec) => require_promptSafety.isSafeSlug(spec.from), slugMessage("from"));
+}).refine((spec) => require_ids.isSafeSlug(spec.from), slugMessage("from"));
 /** A cross-collection AGGREGATE over a backlink relation (plan step ⑤ of
 *  plans/done/collection-ontology.md): a computed number — never stored — that
 *  sums a source column (or counts rows) over the records in `from` whose
@@ -1723,7 +1735,7 @@ var RollupFieldZ = zod.z.object({
 	op: zod.z.enum(["sum", "count"]),
 	column: zod.z.string().trim().min(1).optional(),
 	filter: WhenZ.optional()
-}).refine((spec) => require_promptSafety.isSafeSlug(spec.from), slugMessage("from")).refine((spec) => spec.op === "sum" === (spec.column !== void 0), {
+}).refine((spec) => require_ids.isSafeSlug(spec.from), slugMessage("from")).refine((spec) => spec.op === "sum" === (spec.column !== void 0), {
 	message: "a rollup's `column` names the source column to aggregate: required for op \"sum\", meaningless for op \"count\"",
 	path: ["column"]
 });
@@ -1795,7 +1807,7 @@ var SeededActionZ = zod.z.object({
 	kind: zod.z.enum(["chat", "agent"]),
 	...actionBase,
 	role: zod.z.string().trim().min(1),
-	template: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/invoice.md`; no `..`, no leading `/`, no backslash)"),
+	template: zod.z.string().trim().min(1).refine(require_templatePath.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/invoice.md`; no `..`, no leading `/`, no backslash)"),
 	when: WhenZ.optional()
 });
 /** `kind: "mutate"` — a declarative, HOST-executed write; no LLM, no
@@ -1839,8 +1851,8 @@ var CustomViewZ = zod.z.object({
 	label: zod.z.string().trim().min(1),
 	icon: zod.z.string().trim().min(1).optional(),
 	target: zod.z.enum(["desktop", "mobile"]).optional(),
-	file: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeCustomViewPath, "must be a safe path under `views/` ending in `.html` (e.g. `views/year.html`; no `..`, no leading `/`, no backslash)"),
-	i18n: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeCustomViewI18nPath, "must be a safe path under `views/` ending in `.i18n.json` (e.g. `views/year.i18n.json`; no `..`, no leading `/`, no backslash)").optional(),
+	file: zod.z.string().trim().min(1).refine(require_templatePath.isSafeCustomViewPath, "must be a safe path under `views/` ending in `.html` (e.g. `views/year.html`; no `..`, no leading `/`, no backslash)"),
+	i18n: zod.z.string().trim().min(1).refine(require_templatePath.isSafeCustomViewI18nPath, "must be a safe path under `views/` ending in `.i18n.json` (e.g. `views/year.i18n.json`; no `..`, no leading `/`, no backslash)").optional(),
 	capabilities: zod.z.array(zod.z.enum(["read", "write"])).optional(),
 	editableFields: zod.z.array(zod.z.string().trim().min(1)).optional(),
 	allowDelete: zod.z.boolean().optional(),
@@ -1897,9 +1909,9 @@ var SpawnZ = zod.z.object({
 *  array) only when the response body isn't itself the array; rss/atom yield
 *  items natively and ignore it — so no kind-specific requirement here. */
 var DeclarativeIngestZ = zod.z.object({
-	kind: zod.z.enum(require_promptSafety.INGEST_KINDS),
+	kind: zod.z.enum(require_ids.INGEST_KINDS),
 	url: zod.z.string().url(),
-	schedule: zod.z.enum(require_promptSafety.FEED_SCHEDULES),
+	schedule: zod.z.enum(require_ids.FEED_SCHEDULES),
 	atHour: zod.z.number().int().min(0).max(23).optional(),
 	itemsAt: zod.z.string().trim().min(1).optional(),
 	map: zod.z.record(zod.z.string().trim().min(1), zod.z.string().trim().min(1)),
@@ -1913,11 +1925,26 @@ var DeclarativeIngestZ = zod.z.object({
 *  validated the SAME way an action's template is (safe path under
 *  `templates/`), so the skill-bridge mirrors it identically. */
 var AgentIngestZ = zod.z.object({
-	kind: zod.z.literal(require_promptSafety.AGENT_INGEST_KIND),
-	schedule: zod.z.enum(require_promptSafety.FEED_SCHEDULES),
+	kind: zod.z.literal(require_ids.AGENT_INGEST_KIND),
+	schedule: zod.z.enum(require_ids.FEED_SCHEDULES),
 	atHour: zod.z.number().int().min(0).max(23).optional(),
 	role: zod.z.string().trim().min(1),
-	template: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/refresh.md`; no `..`, no leading `/`, no backslash)")
+	template: zod.z.string().trim().min(1).refine(require_templatePath.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/refresh.md`; no `..`, no leading `/`, no backslash)")
+});
+/** Marks a collection as the destination of the LLM-free Google Calendar
+*  sync (#2095). `map` is collectionField → Google event field, so the user's
+*  collection keeps whatever field names it already uses. */
+var GoogleCalendarSyncZ = zod.z.object({
+	/** Calendar to pull from; defaults to the user's primary. */
+	calendarId: zod.z.string().trim().min(1).optional(),
+	map: zod.z.record(zod.z.string().trim().min(1), zod.z.enum([
+		"summary",
+		"start",
+		"end",
+		"htmlLink",
+		"colorId",
+		"status"
+	])).refine((map) => Object.keys(map).length > 0, { message: "map at least one field — a `googleCalendar` sync with an empty map writes records that carry only the event id" })
 });
 /** `ingest` is a discriminated union on `kind`: the three declarative
 *  retrievers fetch-and-map; `agent` dispatches a hidden worker. Optional on
@@ -2024,11 +2051,24 @@ var DataSourceZ = zod.z.object({
 	type: zod.z.literal("csv"),
 	path: zod.z.string().min(1)
 });
+/** Alternative WRITABLE storage backend for a collection's records —
+*  unlike `dataSource` (external read-only file), a `storage` collection
+*  behaves like a normal writable collection; only where the rows live
+*  changes. v1: `sqlite` — records in a single SQLite database file
+*  (`node:sqlite`, one JSON record per row keyed by the primaryKey).
+*  `path` is workspace-relative and containment-checked exactly like
+*  `dataPath`. The store factory registry (`server/store.ts`) picks the
+*  implementation by `type` (plans/refactor-storage-virtualization.md). */
+var StorageZ = zod.z.object({
+	type: zod.z.literal("sqlite"),
+	path: zod.z.string().min(1)
+});
 var BareCollectionSchemaZ = zod.z.object({
 	title: zod.z.string().min(1),
 	icon: zod.z.string().min(1),
 	dataPath: zod.z.string().min(1).optional(),
 	dataSource: DataSourceZ.optional(),
+	storage: StorageZ.optional(),
 	primaryKey: zod.z.string().min(1),
 	singleton: zod.z.string().trim().min(1).optional(),
 	fields: zod.z.record(zod.z.string(), FieldSpecZ),
@@ -2047,17 +2087,28 @@ var BareCollectionSchemaZ = zod.z.object({
 	views: zod.z.array(CustomViewZ).optional(),
 	notifyWhen: WhenZ.optional(),
 	ingest: IngestZ.optional(),
+	googleCalendar: GoogleCalendarSyncZ.optional(),
 	dynamicIcon: DynamicIconSpecZ.optional()
-}).refine((schema) => schema.dataPath !== void 0 !== (schema.dataSource !== void 0), {
-	message: "declare exactly one of `dataPath` (native JSON records) or `dataSource` (external read-only data file), never both or neither",
+}).refine((schema) => [
+	schema.dataPath,
+	schema.dataSource,
+	schema.storage
+].filter((declared) => declared !== void 0).length === 1, {
+	message: "declare exactly one of `dataPath` (native JSON records), `dataSource` (external read-only data file), or `storage` (alternative writable backend)",
 	path: ["dataPath"]
-}).refine((schema) => schema.dataSource === void 0 || schema.singleton === void 0 && schema.ingest === void 0 && schema.spawn === void 0, {
-	message: "a `dataSource` collection is read-only — it cannot declare `singleton`, `ingest`, or `spawn` (all of them write records)",
+}).refine((schema) => schema.dataSource === void 0 || schema.singleton === void 0 && schema.ingest === void 0 && schema.spawn === void 0 && schema.googleCalendar === void 0, {
+	message: "a `dataSource` collection is read-only — it cannot declare `singleton`, `ingest`, `spawn`, or `googleCalendar` (all of them write records)",
 	path: ["dataSource"]
+}).refine((schema) => schema.googleCalendar === void 0 || Object.keys(schema.googleCalendar.map).every((key) => {
+	const target = schema.fields[key];
+	return target !== void 0 && !require_ids.COMPUTED_TYPES.has(target.type) && key !== schema.primaryKey;
+}), {
+	message: "a `googleCalendar` map key must name a declared, non-computed field, and never the primaryKey (that always holds the Google event id)",
+	path: ["googleCalendar"]
 }).refine((schema) => schema.dataSource === void 0 || [...schema.actions ?? [], ...schema.collectionActions ?? []].every((action) => action.kind !== "mutate"), {
 	message: "a `dataSource` collection is read-only — its actions cannot use `kind: \"mutate\"` (a host write); use `chat`/`agent` actions instead",
 	path: ["dataSource"]
-}).refine((schema) => schema.singleton === void 0 || require_promptSafety.isSafeRecordId(schema.singleton), {
+}).refine((schema) => schema.singleton === void 0 || require_ids.isSafeRecordId(schema.singleton), {
 	message: "schema `singleton` must be a valid item id (alphanumeric / hyphen / underscore / interior dot, no `..` or path separators)",
 	path: ["singleton"]
 }).refine((schema) => schema.actions === void 0 || new Set(schema.actions.map((action) => action.id)).size === schema.actions.length, {
@@ -2068,7 +2119,7 @@ var BareCollectionSchemaZ = zod.z.object({
 	path: ["collectionActions"]
 }).refine((schema) => (schema.actions ?? []).every((action) => action.kind !== "mutate" || Object.keys(action.set).every((key) => {
 	const target = schema.fields[key];
-	return target !== void 0 && !require_promptSafety.COMPUTED_TYPES.has(target.type) && key !== schema.primaryKey;
+	return target !== void 0 && !require_ids.COMPUTED_TYPES.has(target.type) && key !== schema.primaryKey;
 })), {
 	message: "a mutate action's `set` keys must name declared, non-computed fields (and never the primaryKey)",
 	path: ["actions"]
@@ -2107,7 +2158,7 @@ var BareCollectionSchemaZ = zod.z.object({
 	if (spec?.type !== "flag") return true;
 	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
 		const target = schema.fields[name];
-		return target !== void 0 && !require_promptSafety.COMPUTED_TYPES.has(target.type);
+		return target !== void 0 && !require_ids.COMPUTED_TYPES.has(target.type);
 	}));
 }, {
 	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
@@ -2182,7 +2233,7 @@ var BareCollectionSchemaZ = zod.z.object({
 }).refine((schema) => schema.notifyWhen === void 0 || schema.fields[schema.notifyWhen.field] !== void 0, {
 	message: "schema `notifyWhen.field` must name a top-level field declared in `fields`",
 	path: ["notifyWhen"]
-}).refine((schema) => schema.views === void 0 || schema.views.every((view) => require_promptSafety.isSafeSlug(view.id)), {
+}).refine((schema) => schema.views === void 0 || schema.views.every((view) => require_ids.isSafeSlug(view.id)), {
 	message: "every `views[].id` must be a valid slug (alphanumeric / hyphen / underscore, no path separators)",
 	path: ["views"]
 }).refine((schema) => schema.views === void 0 || new Set(schema.views.map((view) => view.id)).size === schema.views.length, {
@@ -2294,6 +2345,23 @@ function acceptParsedSchema(schema, opts) {
 			dataSourceFile
 		};
 	}
+	if (schema.storage !== void 0) {
+		const storageFile = resolveDataDir(schema.storage.path, opts.workspaceRoot);
+		if (storageFile === null) return {
+			ok: false,
+			reason: `storage.path '${schema.storage.path}' escapes the workspace`
+		};
+		const dataDir = resolveDataDir(conventionalDataPath(opts.slug), opts.workspaceRoot);
+		if (dataDir === null) return {
+			ok: false,
+			reason: `slug '${opts.slug}' yields no workspace-contained data dir`
+		};
+		return {
+			ok: true,
+			dataDir,
+			storageFile
+		};
+	}
 	const dataDir = resolveDataDir(schema.dataPath ?? "", opts.workspaceRoot);
 	if (dataDir === null) return {
 		ok: false,
@@ -2307,7 +2375,7 @@ function acceptParsedSchema(schema, opts) {
 async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
 	const safeName = safeSlugName(slug);
 	if (safeName === null) return null;
-	const schemaPath = node_path.default.join(skillsRoot, safeName, SCHEMA_FILE$1);
+	const schemaPath = node_path.default.join(skillsRoot, safeName, SCHEMA_FILE);
 	let raw;
 	try {
 		if (!(await (0, node_fs_promises.stat)(schemaPath)).isFile()) return null;
@@ -2358,6 +2426,7 @@ async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
 		schema,
 		dataDir: acceptance.dataDir,
 		...acceptance.dataSourceFile !== void 0 ? { dataSourceFile: acceptance.dataSourceFile } : {},
+		...acceptance.storageFile !== void 0 ? { storageFile: acceptance.storageFile } : {},
 		skillDir: node_path.default.join(skillsRoot, safeName)
 	};
 }
@@ -2440,1156 +2509,6 @@ function toDetail(collection) {
 	};
 }
 //#endregion
-//#region src/collection/server/ontology.ts
-/** Extract the relations a schema declares, in field declaration order:
-*  top-level `ref` / `embed` / `backlinks` fields plus `ref` sub-fields
-*  inside `table` columns. Pure — exported so the phase-2 graph panel
-*  can reuse it on already-loaded schemas. */
-function schemaRelations(schema) {
-	const relations = [];
-	for (const [key, spec] of Object.entries(schema.fields)) {
-		if (spec.type === "ref" || spec.type === "embed") relations.push({
-			field: key,
-			kind: spec.type,
-			to: spec.to
-		});
-		if (spec.type === "backlinks" || spec.type === "rollup") relations.push({
-			field: key,
-			kind: spec.type,
-			to: spec.from
-		});
-		if (spec.type !== "table") continue;
-		for (const [subKey, subSpec] of Object.entries(spec.of)) if (subSpec.type === "ref") relations.push({
-			field: `${key}.${subKey}`,
-			kind: "ref",
-			to: subSpec.to
-		});
-	}
-	return relations;
-}
-/** Count the record files in a collection's data dir — the same
-*  `<id>.json` entries `listItems` considers, WITHOUT parsing them (the
-*  ontology is a summary; a malformed record is still a record). Each
-*  candidate is classified by the SHARED `isRegularFile` lstat helper —
-*  the exact file-disclosure defense `listItems` applies — so a
-*  symlinked record never counts and the count can't diverge from the
-*  readable set on any filesystem (Codex review on PR #2099, twice).
-*  Fail-soft: a missing dir or a dataDir escaping the workspace via
-*  symlink counts 0. */
-async function countRecordFiles(dataDir, workspaceRoot) {
-	if (!isContainedInRoot(dataDir, workspaceRoot)) return 0;
-	try {
-		const names = (await (0, node_fs_promises.readdir)(dataDir)).filter((name) => name.endsWith(".json") && !name.startsWith("."));
-		return (await Promise.all(names.map((name) => isRegularFile(node_path.default.join(dataDir, name))))).filter(Boolean).length;
-	} catch {
-		return 0;
-	}
-}
-/** A collection's record count for the ontology. File-backed: the cheap
-*  readdir count. `dataSource`-backed: the row count via the CSV store
-*  (subject to its row cap) — the dataDir is a phantom there, so the
-*  readdir count would always misreport 0. Fail-soft to 0 like
-*  `countRecordFiles` (an unreadable file / missing DuckDB must not
-*  break the whole ontology). */
-async function countRecords(collection, workspaceRoot) {
-	if (!collectionWritable(collection)) try {
-		return (await storeFor(collection, { workspaceRoot }).list()).length;
-	} catch {
-		return 0;
-	}
-	return countRecordFiles(collection.dataDir, workspaceRoot);
-}
-async function toOntologyEntry(collection, workspaceRoot) {
-	const { schema } = collection;
-	return {
-		slug: collection.slug,
-		title: schema.title,
-		icon: schema.icon,
-		primaryKey: schema.primaryKey,
-		displayField: schema.displayField ?? schema.primaryKey,
-		recordCount: await countRecords(collection, workspaceRoot),
-		relations: schemaRelations(schema)
-	};
-}
-/** Build the workspace ontology: every discovered collection (slug-sorted,
-*  discovery's order), each with its outbound relations and a
-*  readdir-cheap record count — fine to call on demand. */
-async function buildWorkspaceOntology(opts = {}) {
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const collections = await discoverCollections(opts);
-	return Promise.all(collections.map((collection) => toOntologyEntry(collection, workspaceRoot)));
-}
-//#endregion
-//#region src/collection/server/derive.ts
-/** Slugs of every collection referenced by a `ref` field — top-level
-*  and one level into `table` sub-fields (nested tables are
-*  schema-rejected). Mirrors the client's `uniqueRefTargets`. */
-function uniqueRefTargets(schema) {
-	const targets = /* @__PURE__ */ new Set();
-	const walk = (fields) => {
-		for (const field of Object.values(fields)) {
-			if (field.type === "ref" && typeof field.to === "string" && field.to.length > 0) targets.add(field.to);
-			if (field.type === "table" && field.of) walk(field.of);
-		}
-	};
-	walk(schema.fields);
-	return [...targets];
-}
-/** Slugs of every collection referenced by an `embed` field (top-level
-*  only, like the client). */
-function uniqueEmbedTargets(schema) {
-	const targets = /* @__PURE__ */ new Set();
-	for (const field of Object.values(schema.fields)) if (field.type === "embed" && typeof field.to === "string" && field.to.length > 0) targets.add(field.to);
-	return [...targets];
-}
-/** Slugs of every SOURCE collection a `backlinks` or `rollup` field
-*  reverses over — loaded exactly like ref/embed targets (whole
-*  collection, once; the two field kinds share one load). */
-function uniqueBacklinkSources(schema) {
-	const sources = /* @__PURE__ */ new Set();
-	for (const field of Object.values(schema.fields)) if ((field.type === "backlinks" || field.type === "rollup") && field.from.length > 0) sources.add(field.from);
-	return [...sources];
-}
-async function loadTarget(slug, opts) {
-	const target = await loadCollection(slug, opts);
-	if (!target) return null;
-	const items = await storeFor(target, { workspaceRoot: opts.workspaceRoot }).list();
-	const byId = {};
-	for (const item of items) {
-		const itemId = item[target.schema.primaryKey];
-		if (typeof itemId === "string" && itemId.length > 0) byId[itemId] = require_promptSafety.deriveAll(target.schema, item, {});
-	}
-	return {
-		schema: target.schema,
-		byId
-	};
-}
-/** Load every ref/embed target and backlink source collection once.
-*  Unknown / unloadable targets are simply absent — downstream derefs
-*  resolve to null (em-dash) and backlinks to an empty row set, the
-*  same fail-soft the UI renders. */
-async function loadLinkedTargets(schema, opts) {
-	const slugs = [.../* @__PURE__ */ new Set([
-		...uniqueRefTargets(schema),
-		...uniqueEmbedTargets(schema),
-		...uniqueBacklinkSources(schema)
-	])];
-	const loaded = {};
-	for (const slug of slugs) {
-		const target = await loadTarget(slug, opts);
-		if (target) loaded[slug] = target;
-	}
-	return loaded;
-}
-function toRefRecords(linked) {
-	return Object.fromEntries(Object.entries(linked).map(([slug, target]) => [slug, target.byId]));
-}
-/** The matching source rows for one `backlinks` field, projected to the
-*  source primaryKey + `display` columns — so getItems on a
-*  heavily-referenced record stays a summary, not a dump of the source
-*  collection. Missing source ⇒ [] (fail-soft). The rows come from the
-*  DERIVED source records (`byId`), so `display`/`filter` on a derived
-*  source column (an invoice `total`) works. */
-function projectBacklinks(field, schema, enriched, linked) {
-	const source = linked[field.from];
-	if (!source) return [];
-	return require_promptSafety.backlinkRows(field, String(enriched[schema.primaryKey] ?? ""), Object.values(source.byId)).map((row) => require_promptSafety.projectBacklinkRow(row, field.display, source.schema.primaryKey));
-}
-/** Project the computed (never-stored) field kinds onto one derived
-*  record: `toggle` → boolean off its enum, `embed` → the target record
-*  (fixed `id` or per-record `idField`), or null when missing,
-*  `backlinks` → the matching source rows (see `projectBacklinks`). */
-function projectComputed(schema, enriched, linked) {
-	for (const [key, field] of Object.entries(schema.fields)) {
-		if (field.type === "toggle" && field.field) enriched[key] = String(enriched[field.field] ?? "") === field.onValue;
-		if (field.type === "embed" && field.to) {
-			const targetId = require_promptSafety.embedTargetId(field, enriched);
-			enriched[key] = targetId && linked[field.to]?.byId[targetId] || null;
-		}
-		if (field.type === "backlinks") enriched[key] = projectBacklinks(field, schema, enriched, linked);
-	}
-	return enriched;
-}
-/** Resolve every rollup field onto a COPY of the record, BEFORE the
-*  formula pass — a `derived` formula may reference rollup values as
-*  plain identifiers (`played = homePlayed + awayPlayed`). Same reverse
-*  machinery as backlinks, collapsed to a number: an unresolvable source
-*  is null (a formula reading it fails soft to em-dash); an empty match
-*  set is a real 0. Returns `record` unchanged when the schema declares
-*  no rollups. */
-function projectRollups(schema, record, linked) {
-	let out = record;
-	for (const [key, field] of Object.entries(schema.fields)) {
-		if (field.type !== "rollup") continue;
-		if (out === record) out = { ...record };
-		const source = linked[field.from];
-		const selfId = String(record[schema.primaryKey] ?? "");
-		out[key] = source ? require_promptSafety.rollupValue(field, selfId, Object.values(source.byId)) : null;
-	}
-	return out;
-}
-/** Enrich records with every host-computed field: derived formulas
-*  evaluated (cross-collection derefs included), toggles projected,
-*  embeds resolved. Loads each linked collection ONCE per call. Input
-*  records are not mutated. */
-async function enrichItems(collection, items, opts = {}) {
-	const { schema } = collection;
-	const linked = await loadLinkedTargets(schema, opts);
-	const refRecords = toRefRecords(linked);
-	return items.map((item) => projectComputed(schema, require_promptSafety.deriveAll(schema, projectRollups(schema, item, linked), refRecords), linked));
-}
-//#endregion
-//#region src/collection/server/dynamicIcon.ts
-/** Index `items` by their `primaryKey` value — the `recordsById` map a
-*  `valueFrom` reference (e.g. `_config.defaultCity`) resolves against.
-*  Items whose primary key isn't a string (shouldn't happen for a valid
-*  schema, but records are untyped storage) are skipped rather than
-*  coerced, so a broken key never silently shadows a real one. */
-function buildRecordsById(items, primaryKey) {
-	const entries = items.filter((item) => typeof item[primaryKey] === "string").map((item) => [String(item[primaryKey]), item]);
-	return Object.fromEntries(entries);
-}
-/** Order records by their `primaryKey` so record selection is deterministic:
-*  `listItems` returns filesystem `readdir` order (arbitrary across machines),
-*  which would let `from: "first"`, the no-`orderBy` `latest`, and `orderBy`
-*  ties pick a different record — and thus a different icon — between
-*  reconciles. A stable id sort pins one answer. */
-function sortByPrimaryKey(items, primaryKey) {
-	return [...items].sort((left, right) => String(left[primaryKey] ?? "").localeCompare(String(right[primaryKey] ?? "")));
-}
-/** Compute the effective launcher icon for `collection`: its static
-*  `schema.icon` when it declares no `dynamicIcon`, else the icon
-*  resolved from `dynamicIcon.source`'s RAW stored records (no
-*  derive/enrich — the icon rules match against stored values) via the
-*  pure resolver. Fails soft on any read/discovery error (missing source
-*  collection, filesystem error): falls back to `dynamicIcon.fallback ??
-*  schema.icon` rather than surfacing to the collections list. */
-async function computeCollectionIcon(collection, opts = {}) {
-	const { schema } = collection;
-	const spec = schema.dynamicIcon;
-	if (!spec) return schema.icon;
-	try {
-		const source = await loadCollection(spec.source.collection, opts);
-		if (!source) return spec.fallback ?? schema.icon;
-		const ordered = sortByPrimaryKey(await storeFor(source, { workspaceRoot: opts.workspaceRoot }).list(), source.schema.primaryKey);
-		const orderBy = spec.source.orderBy ?? require_promptSafety.firstDateField(source.schema);
-		const recordsById = buildRecordsById(ordered, source.schema.primaryKey);
-		return require_promptSafety.resolveIcon(require_promptSafety.selectDynamicRecord(ordered, spec.source, orderBy, recordsById), spec, schema.icon, recordsById);
-	} catch (err) {
-		log.warn("collections", "dynamic icon compute failed, falling back", {
-			slug: collection.slug,
-			source: spec.source.collection,
-			error: String(err)
-		});
-		return spec.fallback ?? schema.icon;
-	}
-}
-//#endregion
-//#region src/collection/server/util.ts
-/** Human-readable message from an unknown thrown value. */
-function errorMessage(err) {
-	return err instanceof Error ? err.message : String(err);
-}
-var ONE_SECOND_MS = 1e3;
-var ONE_DAY_MS = 1440 * 60 * 1e3;
-//#endregion
-//#region src/collection/server/spawn.ts
-var YMD_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
-function pad2(value) {
-	return String(value).padStart(2, "0");
-}
-function pad4(value) {
-	return String(value).padStart(4, "0");
-}
-/** Days in `month` (1-12) of `year`, leap-year-aware. `new Date(y, m, 0)`
-*  is day 0 of the *next* month = the last day of `month`; `.getDate()`
-*  reads the civil day regardless of timezone. */
-function daysInMonth(year, month) {
-	return new Date(year, month, 0).getDate();
-}
-/** Parse a `YYYY-MM-DD` string into a CivilDate, or null when the value
-*  isn't a well-formed in-range calendar date. */
-function parseCivil(raw) {
-	if (typeof raw !== "string") return null;
-	const match = YMD_PATTERN.exec(raw.trim());
-	if (!match) return null;
-	const year = Number(match[1]);
-	const month = Number(match[2]);
-	const day = Number(match[3]);
-	if (month < 1 || month > 12) return null;
-	if (day < 1 || day > daysInMonth(year, month)) return null;
-	return {
-		y: year,
-		m: month,
-		d: day
-	};
-}
-/** `YYYY-MM-DD` for storage in a `date` field. */
-function formatCivil(date) {
-	return `${pad4(date.y)}-${pad2(date.m)}-${pad2(date.d)}`;
-}
-/** A monotonic integer key for a civil date (YYYYMMDD), for ordering /
-*  equality without timezone concerns. */
-function ordinal(date) {
-	return date.y * 1e4 + date.m * 100 + date.d;
-}
-/** Add `n` whole days to a civil date. Uses UTC epoch arithmetic so it
-*  is DST-immune (we only ever read back the civil Y/M/D). */
-function addDays(date, days) {
-	const shifted = new Date(Date.UTC(date.y, date.m - 1, date.d) + days * ONE_DAY_MS);
-	return {
-		y: shifted.getUTCFullYear(),
-		m: shifted.getUTCMonth() + 1,
-		d: shifted.getUTCDate()
-	};
-}
-/** Advance a civil date by one `every` step. Month/year units preserve
-*  the rule's day-of-month anchor, clamped to the target month's length
-*  (no drift); day/week units do civil day arithmetic. */
-function advanceTriggerDate(source, every) {
-	const { unit, interval } = every;
-	if (unit === "day") return addDays(source, interval);
-	if (unit === "week") return addDays(source, interval * 7);
-	const monthsToAdd = interval * (unit === "year" ? 12 : 1);
-	const total = source.y * 12 + (source.m - 1) + monthsToAdd;
-	const nextYear = Math.floor(total / 12);
-	const nextMonth = total % 12 + 1;
-	const dim = daysInMonth(nextYear, nextMonth);
-	const anchor = every.dayOfMonth === "last" ? dim : every.dayOfMonth ?? source.d;
-	return {
-		y: nextYear,
-		m: nextMonth,
-		d: Math.min(anchor, dim)
-	};
-}
-/** True iff `now`'s civil date (local timezone) has reached the fire date
-*  for `triggerRaw` — i.e. the trigger date minus `leadDays` (so a 10-day
-*  lead fires 10 days early). Returns null when `triggerRaw` isn't a
-*  parseable date — callers treat that as "don't fire" and warn. */
-function isTriggerDue(triggerRaw, now, leadDays = 0) {
-	const due = parseCivil(triggerRaw);
-	if (due === null) return null;
-	const fireDate = leadDays > 0 ? addDays(due, -leadDays) : due;
-	return ordinal({
-		y: now.getFullYear(),
-		m: now.getMonth() + 1,
-		d: now.getDate()
-	}) >= ordinal(fireDate);
-}
-var DATE_SUFFIX_PATTERN = /-\d{8}$/;
-/** Deterministic successor id: `<stem>-<YYYYMMDD>`, where `<stem>` is the
-*  source id with a trailing `-YYYYMMDD` stripped if present. So a chain
-*  shares one stem and each instance is dated:
-*    `rent`           → `rent-20260610`
-*    `rent-20260610`  → `rent-20260710`
-*  Slug-safe (alphanumeric + hyphen) and a pure function of the inputs,
-*  which is what makes create-if-absent idempotent. */
-function successorId(sourceId, next) {
-	return `${sourceId.replace(DATE_SUFFIX_PATTERN, "")}-${pad4(next.y)}${pad2(next.m)}${pad2(next.d)}`;
-}
-/** True iff `item` satisfies the spawn predicate. With an explicit
-*  `when`, matches `String(item[when.field]) ∈ when.in`. Without one,
-*  defaults to the completion-done condition — the shared, flag-aware
-*  `itemIsDone` (core/completion; downhill import, so the module graph
-*  stays acyclic). */
-function matchesWhen(when, schema, item) {
-	if (when) {
-		const raw = item[when.field];
-		return raw !== void 0 && raw !== null && when.in.includes(String(raw));
-	}
-	return require_promptSafety.itemIsDone(schema, item);
-}
-/** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
-*  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
-*  `sourceItem[fromField]` and looks it up in `map`; an empty field or a
-*  value with no map entry yields null (caller skips + logs — see plan §5).
-*  Discovery rejects a map that doesn't cover the enum's values, so null
-*  here means a record that predates a map/enum edit. */
-function resolveEvery(every, sourceItem) {
-	if (!require_promptSafety.isFieldDrivenEvery(every)) return every;
-	const raw = sourceItem[every.fromField];
-	if (raw === void 0 || raw === null || raw === "") return null;
-	return every.map[String(raw)] ?? null;
-}
-/** Build the successor record purely from (schema, source record, source
-*  id). Returns null when the schema has no spawn/triggerField or the
-*  source's trigger date is unparseable. */
-function computeSuccessor(schema, sourceItem, sourceId) {
-	const { spawn, triggerField } = schema;
-	if (!spawn || !triggerField) return null;
-	const srcDate = parseCivil(sourceItem[triggerField]);
-	if (srcDate === null) return null;
-	const every = resolveEvery(spawn.every, sourceItem);
-	if (every === null) return null;
-	const next = advanceTriggerDate(srcDate, every);
-	const nextId = successorId(sourceId, next);
-	const record = {};
-	for (const field of spawn.carry ?? []) if (Object.prototype.hasOwnProperty.call(sourceItem, field)) record[field] = sourceItem[field];
-	Object.assign(record, spawn.set ?? {});
-	record[triggerField] = formatCivil(next);
-	record[schema.primaryKey] = nextId;
-	return {
-		id: nextId,
-		record
-	};
-}
-/** Warn precisely about which of `computeSuccessor`'s two null causes fired
-*  (plan §5): an unparseable source trigger date (the original cause), or a
-*  field-driven `every` whose record value has no `map` entry (a record that
-*  predates a map/enum edit — discovery rejects this statically otherwise). */
-function logSpawnSkip(slug, triggerField, every, sourceItem, sourceId) {
-	if (parseCivil(sourceItem[triggerField]) === null) {
-		log.warn("collections", "spawn skipped: source trigger date unparseable", {
-			slug,
-			sourceId,
-			triggerField
-		});
-		return;
-	}
-	const fromField = require_promptSafety.isFieldDrivenEvery(every) ? every.fromField : void 0;
-	log.warn("collections", "spawn skipped: no `every` mapping for frequency value", {
-		slug,
-		sourceId,
-		fromField,
-		value: fromField === void 0 ? void 0 : sourceItem[fromField]
-	});
-}
-/** Idempotently create the successor for `sourceItem` when it matches the
-*  spawn predicate. No-op when the schema declares no spawn, the
-*  predicate doesn't match, the trigger date is unparseable, or the
-*  successor already exists (create-if-absent). Never overwrites an
-*  existing successor — protects any edits the user made to it. */
-async function maybeSpawnSuccessor(slug, schema, dataDir, sourceItem, sourceId, ioOpts = {}) {
-	const { spawn } = schema;
-	if (!spawn || !schema.triggerField) return;
-	if (!matchesWhen(spawn.when, schema, sourceItem)) return;
-	const computed = computeSuccessor(schema, sourceItem, sourceId);
-	if (computed === null) {
-		logSpawnSkip(slug, schema.triggerField, spawn.every, sourceItem, sourceId);
-		return;
-	}
-	if (matchesWhen(spawn.when, schema, computed.record)) {
-		log.warn("collections", "spawn skipped: successor would be born matching its own predicate (unbounded respawn)", {
-			slug,
-			sourceId,
-			successorId: computed.id
-		});
-		return;
-	}
-	try {
-		const result = await writeItem(dataDir, computed.id, computed.record, {
-			...ioOpts,
-			refuseOverwrite: true,
-			slug
-		});
-		if (result.kind === "ok") log.info("collections", "spawned successor", {
-			slug,
-			sourceId,
-			successorId: computed.id
-		});
-		else if (result.kind !== "conflict") log.warn("collections", "spawn write failed", {
-			slug,
-			sourceId,
-			successorId: computed.id,
-			kind: result.kind
-		});
-	} catch (err) {
-		log.warn("collections", "spawn write threw", {
-			slug,
-			sourceId,
-			successorId: computed.id,
-			error: errorMessage(err)
-		});
-	}
-}
-//#endregion
-//#region src/collection/server/delete.ts
-/** Human-readable reason for a non-`ok` delete result. Exported so the
-*  route maps `kind` → message without inlining the switch (keeps the
-*  handler short and the mapping unit-testable). The `Record` is
-*  exhaustive — a new refusal kind won't compile until it's added. */
-function deleteCollectionRefusalMessage(result) {
-	const { slug } = result;
-	return {
-		"user-scope": `collection '${slug}' is user-scope (~/.claude/skills/) and is read-only from MulmoClaude`,
-		preset: `collection '${slug}' is a preset (mc-*) and re-seeds on restart; unstar it from the catalog instead`,
-		"unsafe-data-path": `collection '${slug}' declares a dataPath outside its own data/${slug}/ subtree; refusing to delete`,
-		"path-escape": `a directory for collection '${slug}' escapes the workspace`
-	}[result.kind];
-}
-/** The canonical staging dir for a slug: `data/skills/<slug>`. */
-function stagingSkillDir(workspaceRoot, slug) {
-	return node_path.default.join(skillsStagingDir(workspaceRoot), slug);
-}
-async function pathExists(target) {
-	try {
-		await (0, node_fs_promises.stat)(target);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** UTC `YYYY-MM-DD` — keeps the archive folder human-sortable. */
-function todayStamp() {
-	return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-/** Every directory the delete will touch must resolve under the
-*  workspace root — guards against a symlinked ancestor escaping it. */
-function deleteTargets(collection, workspaceRoot) {
-	return [
-		stagingSkillDir(workspaceRoot, collection.slug),
-		collection.skillDir,
-		collection.dataDir
-	];
-}
-/** The records directory the delete recursively archives + removes
-*  (`collection.dataDir`) must live in this collection's OWN per-slug
-*  subtree. `dataDir` is normally derived from `schema.dataPath`, but
-*  `deleteCollection` accepts a `LoadedCollection` whose fields could be
-*  inconsistent — so we validate the RESOLVED target the destructive ops
-*  actually touch, not the schema string. A shared root like `data` or
-*  `data/skills` would otherwise turn the recursive removal into a
-*  workspace-wide wipe whose archive captures only this collection.
-*  `path.resolve` collapses any `..` before the prefix test (symlink
-*  escapes are caught separately by the realpath containment check in
-*  `deleteTargets`).
-*
-*  TWO acceptable per-slug subtrees:
-*    - `data/<slug>/...` — the convention authored collections default to.
-*    - `data/collections/<slug>/...` — what `normalizedDataPath` in the
-*      registry-import path stamps onto every imported schema (so imported
-*      collections never collide with `data/<slug>/`-shaped authored ones).
-*  Both are equally per-collection and equally safe; a delete that targets
-*  anything else (e.g. raw `data/`, `data/wiki/`, a sibling slug) is
-*  refused. */
-function isDataDirSafe(dataDir, slug, workspaceRoot) {
-	const acceptableRoots = [node_path.default.resolve(workspaceRoot, "data", slug), node_path.default.resolve(workspaceRoot, "data", "collections", slug)];
-	const resolved = node_path.default.resolve(dataDir);
-	return acceptableRoots.some((root) => resolved === root || resolved.startsWith(root + node_path.default.sep));
-}
-/** Step 2 of the restore doc — how to bring the records back. A
-*  `dataSource` collection has no record files to copy (its rows live in
-*  the external data file, which the delete never touches). */
-function restoreRecordsStep(schema) {
-	if (schema.dataPath === void 0) return `2. Records: nothing to copy. This is a \`dataSource\` collection —
-   its records are the rows of \`${schema.dataSource?.path}\`, which the
-   delete never touched.`;
-	return `2. Copy the item data: \`cp\` every file under \`records/\` into
-   \`${schema.dataPath}/\`. The records are part of the collection and
-   must be restored. They are plain data files (NOT bridged), so use
-   \`cp\` — the Write-tool rule in step 1 applies ONLY to the skill
-   files, not to these records (there may be many; copy them, do not
-   Write them one by one).`;
-}
-function buildRestoreDoc(collection) {
-	const { slug, schema } = collection;
-	return `# Restore "${schema.title}" (collection \`${slug}\`)
-
-This folder is an automatic backup made when the collection was deleted.
-Follow these steps to restore it.
-
-1. Recreate the skill files in \`data/skills/${slug}/\` using the **Write
-   tool**: read each file under \`skill/\` and Write it to the matching
-   path — \`SKILL.md\`, \`schema.json\`, and any \`templates/*\`.
-
-   IMPORTANT — use the Write tool, NOT \`cp\` / \`mv\` / a shell redirect.
-   The skill-bridge hook mirrors \`data/skills/${slug}/\` into
-   \`.claude/skills/${slug}/\`, and that mirror is what actually registers
-   the collection. The hook only fires on Write/Edit tool calls, so a
-   \`cp\` would leave the files in staging with no \`.claude/skills/\`
-   mirror — the collection would stay invisible. (Writing
-   \`.claude/skills/\` directly is not an option either: that path is
-   permission-gated.)
-
-${restoreRecordsStep(schema)}
-
-3. Confirm the collection reappears at \`/collections/${slug}\`.
-
-- slug: \`${slug}\`
-- title: ${schema.title}
-- dataPath: \`${schema.dataPath ?? `(dataSource) ${schema.dataSource?.path}`}\`
-`;
-}
-/** Copy one skill copy + the records + RESTORE.md into `archiveDir`. */
-async function writeArchive(collection, archiveDir, workspaceRoot) {
-	const staging = stagingSkillDir(workspaceRoot, collection.slug);
-	await (0, node_fs_promises.cp)(await pathExists(staging) ? staging : collection.skillDir, node_path.default.join(archiveDir, "skill"), { recursive: true });
-	if (await pathExists(collection.dataDir)) await (0, node_fs_promises.cp)(collection.dataDir, node_path.default.join(archiveDir, "records"), { recursive: true });
-	await (0, node_fs_promises.writeFile)(node_path.default.join(archiveDir, "RESTORE.md"), buildRestoreDoc(collection), "utf-8");
-}
-/** Remove all three locations. `rm -rf`-style (force) so a missing dir
-*  is a no-op; the now-empty data parent (`data/<slug>/` after its
-*  `items/` is gone) is swept too, but only when empty. */
-async function removeLocations(collection, workspaceRoot) {
-	await (0, node_fs_promises.rm)(stagingSkillDir(workspaceRoot, collection.slug), {
-		recursive: true,
-		force: true
-	});
-	await (0, node_fs_promises.rm)(collection.skillDir, {
-		recursive: true,
-		force: true
-	});
-	await (0, node_fs_promises.rm)(collection.dataDir, {
-		recursive: true,
-		force: true
-	});
-	await (0, node_fs_promises.rmdir)(node_path.default.dirname(collection.dataDir)).catch(() => void 0);
-}
-async function deleteCollection(collection, opts = {}) {
-	const { slug } = collection;
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	if (collection.source === "user") return {
-		kind: "user-scope",
-		slug
-	};
-	if (isPresetSlug$1(slug)) return {
-		kind: "preset",
-		slug
-	};
-	if (!isDataDirSafe(collection.dataDir, slug, workspaceRoot)) {
-		log.warn("collections", "deleteCollection refused: dataDir is not under the per-collection root", {
-			slug,
-			dataDir: collection.dataDir
-		});
-		return {
-			kind: "unsafe-data-path",
-			slug
-		};
-	}
-	if (deleteTargets(collection, workspaceRoot).some((target) => !isContainedInRoot(target, workspaceRoot))) {
-		log.warn("collections", "deleteCollection refused: a target escapes the workspace", { slug });
-		return {
-			kind: "path-escape",
-			slug
-		};
-	}
-	const archiveRel = node_path.default.join(archiveDir(), `${opts.dateStamp ?? todayStamp()}-${(0, node_crypto.randomUUID)()}`);
-	const archiveDir$1 = node_path.default.join(workspaceRoot, archiveRel);
-	await (0, node_fs_promises.mkdir)(archiveDir$1, { recursive: true });
-	await writeArchive(collection, archiveDir$1, workspaceRoot);
-	await removeLocations(collection, workspaceRoot);
-	log.info("collections", "collection deleted + archived", {
-		slug,
-		archive: archiveRel
-	});
-	return {
-		kind: "ok",
-		slug,
-		archivePath: archiveRel
-	};
-}
-//#endregion
-//#region src/collection/server/views.ts
-async function fileExists(target) {
-	try {
-		await (0, node_fs_promises.stat)(target);
-		return true;
-	} catch (err) {
-		const { code } = err;
-		if (code === "ENOENT" || code === "ENOTDIR") return false;
-		throw err;
-	}
-}
-/** The authoritative base dir for a collection's schema.json + view HTML.
-*  For a project collection, prefer the staging tree when its schema.json is
-*  present (authoring layout); otherwise fall back to the active skill dir
-*  (imported layout — staging never materialised). For feed / user, it's
-*  always the discovered skillDir. Matches `readCustomViewHtml` so reads and
-*  deletes agree on both layouts. */
-async function canonicalBase(collection, workspaceRoot, safeSlug) {
-	if (collection.source !== "project") return collection.skillDir;
-	const staging = node_path.default.join(skillsStagingDir(workspaceRoot), safeSlug);
-	if (await fileExists(node_path.default.join(staging, "schema.json"))) return staging;
-	return collection.skillDir;
-}
-/** Every on-disk schema.json that must reflect the removal. The active
-*  `<skillDir>/schema.json` is the discovery anchor and is always present.
-*  The staging copy is included only when it actually exists, so an imported
-*  project collection (no staging mirror) doesn't have an empty staging tree
-*  materialised by a side effect of the delete. */
-async function schemaWriteTargets(collection, workspaceRoot, safeSlug) {
-	const active = node_path.default.join(collection.skillDir, SCHEMA_FILE$1);
-	if (collection.source !== "project") return [active];
-	const stagingSchema = node_path.default.join(skillsStagingDir(workspaceRoot), safeSlug, SCHEMA_FILE$1);
-	const targets = [];
-	if (await fileExists(stagingSchema)) targets.push(stagingSchema);
-	targets.push(active);
-	return targets;
-}
-/** Idempotent unlink — a missing file is fine (the schema entry still gets
-*  cleaned), but a real error (permissions, etc.) propagates. */
-async function unlinkIfPresent(target) {
-	try {
-		await (0, node_fs_promises.unlink)(target);
-	} catch (err) {
-		if (err.code !== "ENOENT") throw err;
-	}
-}
-/** Re-read the canonical schema.json, drop the `views[]` entry, and write the
-*  result back to every on-disk copy so staging + active stay identical. Reads
-*  raw (not `collection.schema`) so fields the typed schema doesn't model are
-*  preserved verbatim. */
-async function removeViewFromSchemas(collection, viewId, workspaceRoot, safeSlug) {
-	const base = await canonicalBase(collection, workspaceRoot, safeSlug);
-	const canonical = node_path.default.join(base, SCHEMA_FILE$1);
-	const parsed = JSON.parse(await (0, node_fs_promises.readFile)(canonical, "utf-8"));
-	if (Array.isArray(parsed.views)) parsed.views = parsed.views.filter((entry) => entry?.id !== viewId);
-	const serialized = `${JSON.stringify(parsed, null, 2)}\n`;
-	for (const target of await schemaWriteTargets(collection, workspaceRoot, safeSlug)) await writeFileAtomic(target, serialized);
-}
-/** Delete one custom view from `collection`: unlink its HTML file and drop it
-*  from every schema.json copy. User-scope and preset (mc-*) collections are
-*  refused (read-only / re-seeded on boot), consistent with `deleteCollection`. */
-async function deleteCustomView(collection, viewId, opts = {}) {
-	if (collection.source === "user") return { kind: "user-scope" };
-	if (isPresetSlug$1(collection.slug)) return { kind: "preset" };
-	const safeSlug = safeSlugName(collection.slug);
-	if (safeSlug === null) return {
-		kind: "unsafe-path",
-		viewId
-	};
-	const views = collection.schema.views ?? [];
-	const view = views.find((entry) => entry.id === viewId);
-	if (!view) return {
-		kind: "not-found",
-		viewId
-	};
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const htmlPath = resolveTemplatePath(await canonicalBase(collection, workspaceRoot, safeSlug), view.file);
-	if (htmlPath === null) return {
-		kind: "unsafe-path",
-		viewId
-	};
-	await removeViewFromSchemas(collection, viewId, workspaceRoot, safeSlug);
-	if (!views.some((entry) => entry.id !== viewId && entry.file === view.file)) await unlinkIfPresent(htmlPath);
-	return {
-		kind: "ok",
-		viewId
-	};
-}
-/** True for a launcher-managed preset slug (`mc-<something>`). The sync logic uses
-*  this to bound which active skills it may refresh/prune, so user-authored skills are
-*  never touched. */
-function isPresetSlug(slug) {
-	return slug.startsWith("mc-") && slug.length > 3;
-}
-//#endregion
-//#region src/collection/server/manageTool.ts
-/** Refuse an unselective getItems beyond this many records — a silent
-*  truncation would read as "covered everything", and an unbounded dump
-*  of a large collection is a token bomb. `ids` or `fields` lifts it. */
-var MAX_UNSELECTIVE_ITEMS = 200;
-/** schema.json basename under a skill dir (canonical staging + active mirror). */
-var SCHEMA_FILE = "schema.json";
-/** The collection-authoring reference, served by the `schemaDocs` action. */
-var SCHEMA_DOCS_FILE = "collection-skills.md";
-/** Cap the rejected-schema issue list so a deeply-broken schema can't flood the result. */
-var MAX_SCHEMA_ISSUES = 20;
-/** The workspace help-docs dir both hosts seed (`@mulmoclaude/core/workspace-setup`
-*  syncs the bundled assets here) — the user-editable copy schemaDocs prefers. */
-var HELPS_DIR = "config/helps";
-/** Resolve the workspace root the same way every collections call does:
-*  the injected override (tests) or the configured collection host. */
-function resolveBase(deps) {
-	return deps.workspaceRoot ?? getWorkspaceRoot();
-}
-/** Shared "unknown collection" message — its schema.json is missing or
-*  failed validation, so discovery skipped it. */
-function unknownCollection(slug) {
-	return `manageCollection: unknown collection '${require_promptSafety.defangForPrompt(slug)}' — its schema.json is missing or failed validation.`;
-}
-function optionalStringArray(value, name) {
-	if (value === void 0) return { ok: true };
-	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string" && entry.length > 0)) return {
-		ok: false,
-		error: `manageCollection: \`${name}\` must be an array of non-empty strings when present.`
-	};
-	return {
-		ok: true,
-		value
-	};
-}
-/** Project a record down to the requested fields. The primary key is
-*  always kept so every returned record stays addressable for a
-*  follow-up getItems/putItems. */
-function projectFields(record, fields, primaryKey) {
-	const keys = fields.includes(primaryKey) ? fields : [primaryKey, ...fields];
-	return Object.fromEntries(keys.filter((key) => key in record).map((key) => [key, record[key]]));
-}
-/** The validation warning appended to a getItems result when stored
-*  record files are malformed (they're silently skipped at read time,
-*  so without this they'd just look missing). Issue strings quote
-*  record-controlled text → defanged, mirroring the presentCollection
-*  dispatch. The record VALUES in `items` ride verbatim, like a raw
-*  file Read — only host-composed report strings are defanged. */
-async function recordIssuesWarning(collection, deps) {
-	if (deps.ablateValidation) return void 0;
-	const issues = await validateCollectionRecords(collection, { workspaceRoot: deps.workspaceRoot });
-	if (issues.length === 0) return void 0;
-	const lines = issues.map((issue) => `- ${require_promptSafety.defangForPrompt(issue.file)}: ${require_promptSafety.defangForPrompt(issue.problem)}`).join("\n");
-	return `${issues.length} record file(s) have data problems and are missing from this result. Fix each (Read → correct → Write):\n${lines}`;
-}
-async function loadRequestedItems(collection, ids, deps) {
-	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
-	if (!ids) return {
-		items: await store.list(),
-		missing: []
-	};
-	const items = [];
-	const missing = [];
-	for (const recordId of ids) {
-		const item = await store.read(recordId).catch(() => null);
-		if (item) items.push(item);
-		else missing.push(recordId);
-	}
-	return {
-		items,
-		missing
-	};
-}
-async function handleGetItems(collection, args, deps) {
-	const { items, missing } = await loadRequestedItems(collection, args.ids, deps);
-	if (!args.ids && !args.fields && items.length > 200) return `manageCollection: refused — '${collection.slug}' has ${items.length} records, over the unselective limit of 200. Pass \`ids\` for specific records or \`fields\` to project only the columns you need.`;
-	const enriched = await enrichItems(collection, items, deps);
-	const projected = args.fields ? enriched.map((item) => projectFields(item, args.fields, collection.schema.primaryKey)) : enriched;
-	const warning = !args.ids || missing.length > 0 ? await recordIssuesWarning(collection, deps) : void 0;
-	return JSON.stringify({
-		collection: collection.slug,
-		count: projected.length,
-		items: projected,
-		...missing.length > 0 ? { missing: missing.map((recordId) => require_promptSafety.defangForPrompt(recordId)) } : {},
-		...warning ? { warning } : {}
-	});
-}
-/** Reject writes that set host-computed keys, with a pointer at the
-*  writable source of truth (the toggle's enum) where one exists. */
-function computedKeyProblem(record, schema) {
-	for (const key of Object.keys(record)) {
-		const spec = schema.fields[key];
-		if (!spec || !require_promptSafety.COMPUTED_TYPES.has(spec.type)) continue;
-		if (spec.type === "toggle" && spec.field) return `'${key}' is a toggle projection — write the enum field '${spec.field}' instead`;
-		return `'${key}' is ${{
-			derived: "derived",
-			embed: "an embed",
-			backlinks: "a backlinks view",
-			rollup: "a rollup"
-		}[spec.type] ?? "computed"} — computed by the host, remove it from the record`;
-	}
-	return null;
-}
-/** `mode: "merge"` resolves the row against the EXISTING record —
-*  a partial row updates just the fields it carries, instead of a
-*  whole-record upsert silently erasing the optional fields it omits
-*  (an upsert of `{id, status}` would pass validation yet drop
-*  `notes`/`lesson`/…). Merge is a partial UPDATE by definition, so a
-*  missing record is a reject, not an implicit create — a merged-over-
-*  nothing partial record is exactly the data shape this mode exists
-*  to prevent.
-*
-*  Computed keys found in the STORED record are stripped before the
-*  merge: the caller's own row was already computed-key-rejected, but a
-*  raw-written / legacy record can carry a stale `derived`/`embed`/
-*  `toggle` value, and re-writing it would perpetuate a forged
-*  host-computed value. A merge heals the record instead.
-*
-*  readItem THROWS on a malformed stored file (only ENOENT is null) —
-*  downgraded to a per-row rejection here, like loadRequestedItems'
-*  `missing`, so one broken file can't abort the whole putItems batch. */
-async function mergeWithExisting(collection, record, itemId, deps) {
-	let existing;
-	try {
-		existing = await readItem(collection.dataDir, itemId, { workspaceRoot: deps.workspaceRoot });
-	} catch {
-		return `'${itemId}' has a malformed stored file — mode "merge" needs to read it; fix the file (Read → correct → Write) or replace it whole with "upsert"`;
-	}
-	if (!existing) return `'${itemId}' not found — mode "merge" updates an existing record; use "upsert" or "create" to add it`;
-	const stored = Object.entries(existing).filter(([key]) => {
-		const spec = collection.schema.fields[key];
-		return !spec || !require_promptSafety.COMPUTED_TYPES.has(spec.type);
-	});
-	return {
-		...Object.fromEntries(stored),
-		...record
-	};
-}
-async function putOneItem(collection, record, mode, deps) {
-	const { schema } = collection;
-	const itemId = resolveCreateItemId(schema, record);
-	const reject = (about, problem) => ({ rejected: {
-		id: require_promptSafety.defangForPrompt(about),
-		problem: require_promptSafety.defangForPrompt(problem)
-	} });
-	if (itemId === null) return reject("(no id)", `record has no '${schema.primaryKey}' value — set it (it doubles as the filename)`);
-	const computed = computedKeyProblem(record, schema);
-	if (computed) return reject(itemId, computed);
-	let toWrite = record;
-	if (mode === "merge") {
-		const merged = await mergeWithExisting(collection, record, itemId, deps);
-		if (typeof merged === "string") return reject(itemId, merged);
-		toWrite = merged;
-	}
-	if (!deps.ablateValidation) {
-		const invalid = validateRecordObject(toWrite, itemId, schema);
-		if (invalid) return reject(itemId, invalid);
-	}
-	const result = await writeItem(collection.dataDir, itemId, toWrite, {
-		refuseOverwrite: mode === "create",
-		workspaceRoot: deps.workspaceRoot,
-		slug: collection.slug
-	});
-	if (result.kind === "ok") return { written: result.itemId };
-	if (result.kind === "invalid-id") return reject(itemId, `'${itemId}' is not a valid record id (letters/digits at the ends; -, _, or . inside; no '..' or path characters)`);
-	if (result.kind === "conflict") return reject(itemId, `'${itemId}' already exists — mode "create" refuses overwrite; use "upsert" to update it`);
-	return reject(itemId, "write refused: the collection's data dir escapes the workspace");
-}
-/** Aggregation over a collection via the structured query DSL
-*  (`core/queryZ.ts`) — the paved road for counts / sums / group-bys
-*  that a row listing can't answer honestly. Two engines behind one
-*  shape: a dataSource collection queries its CSV natively through the
-*  store (`store.query`, uncapped whole-file scan); a file-backed
-*  collection aggregates its ENRICHED records (computed fields —
-*  `derived` / `rollup` / `toggle` — are real columns) through the same
-*  compiled SQL over a temp JSONL (`runQueryOverRows`). */
-async function handleQueryItems(collection, queryArg, deps) {
-	const parsed = CollectionQueryZ.safeParse(queryArg);
-	if (!parsed.success) return `manageCollection: \`query\` rejected — fix and retry:\n${parsed.error.issues.slice(0, 20).map((issue) => `- ${issue.path.map(String).join(".") || "(root)"}: ${require_promptSafety.defangForPrompt(issue.message)}`).join("\n")}`;
-	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
-	if (store.query) {
-		const rows = await store.query(parsed.data);
-		return JSON.stringify({
-			collection: collection.slug,
-			count: rows.length,
-			rows
-		});
-	}
-	const rows = await runQueryOverRows(await enrichItems(collection, await store.list(), deps), parsed.data);
-	return JSON.stringify({
-		collection: collection.slug,
-		count: rows.length,
-		rows
-	});
-}
-async function handlePutItems(collection, args, deps) {
-	if (!collectionWritable(collection)) return `manageCollection: ${readOnlyRefusal(collection.slug)} (its records are the rows of '${collection.schema.dataSource?.path}'; edit that file to change the data).`;
-	const written = [];
-	const rejected = [];
-	for (const record of args.items) {
-		const outcome = await putOneItem(collection, record, args.mode, deps);
-		if (outcome.written) written.push(outcome.written);
-		if (outcome.rejected) rejected.push(outcome.rejected);
-	}
-	return JSON.stringify({
-		collection: collection.slug,
-		written,
-		rejected
-	});
-}
-function parsePutItems(args, slug) {
-	const { items, mode } = args;
-	if (!(Array.isArray(items) && items.length > 0 && items.every((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)))) return "manageCollection: `items` is required for putItems — a non-empty array of record objects.";
-	if (mode !== void 0 && mode !== "upsert" && mode !== "create" && mode !== "merge") return "manageCollection: `mode` must be \"upsert\" (default), \"create\", or \"merge\".";
-	return {
-		slug,
-		items,
-		mode: mode ?? "upsert"
-	};
-}
-/** The machine-readable workspace ontology: every collection with its
-*  identity, record count, and outbound `ref`/`embed` relations. Slugs
-*  are discovery-sanitized; titles/labels are workspace-authored schema
-*  text and ride verbatim — the same trust class as the record values
-*  getItems returns. */
-async function handleGetOntology(deps) {
-	const collections = await buildWorkspaceOntology(deps);
-	return JSON.stringify({
-		count: collections.length,
-		collections
-	});
-}
-/** Return the collection-authoring reference (`collection-skills.md`).
-*  Workspace copy first (reflects user edits), bundled asset as the
-*  always-present fallback. Both reads guarded; if neither resolves the
-*  agent still gets an actionable message instead of a thrown call. */
-async function handleSchemaDocs(deps) {
-	const candidates = [node_path.default.join(resolveBase(deps), HELPS_DIR, SCHEMA_DOCS_FILE), ...deps.bundledHelpsDir ? [node_path.default.join(deps.bundledHelpsDir(), SCHEMA_DOCS_FILE)] : []];
-	for (const candidate of candidates) try {
-		return await (0, node_fs_promises.readFile)(candidate, "utf-8");
-	} catch {}
-	return `manageCollection: could not read the collection-authoring reference (${SCHEMA_DOCS_FILE}).`;
-}
-/** Return the raw schema.json of an existing collection, for editing.
-*  Staging (the canonical writable copy) first, the active mirror as a
-*  fallback for user-scope skills that have no staging copy. Raw text —
-*  not the parsed schema — so the agent edits the true on-disk source. */
-async function handleGetSchema(slug, deps) {
-	const collection = await loadCollection(slug, deps);
-	if (!collection) return unknownCollection(slug);
-	const candidates = [node_path.default.join(require_skill_bridge_index.dataSkillDir(resolveBase(deps), collection.slug), SCHEMA_FILE), node_path.default.join(collection.skillDir, SCHEMA_FILE)];
-	for (const candidate of candidates) try {
-		return await (0, node_fs_promises.readFile)(candidate, "utf-8");
-	} catch {}
-	return `manageCollection: '${require_promptSafety.defangForPrompt(slug)}' has no readable ${SCHEMA_FILE}.`;
-}
-/** Refuse a schema edit the host can't honour: user-scope/feed collections
-*  are read-only, and presets (mc-*) re-seed on restart so an edit is lost. */
-function schemaEditRefusal(collection, slug) {
-	if (collection.source !== "project") return `manageCollection: '${require_promptSafety.defangForPrompt(slug)}' is ${collection.source}-scope and read-only here — only project collections (data/skills/) can be edited.`;
-	if (isPresetSlug(slug)) return `manageCollection: '${require_promptSafety.defangForPrompt(slug)}' is a preset (mc-*) and re-seeds on restart — copy it under a different slug to customise.`;
-	return null;
-}
-/** Turn a CollectionSchemaZ failure into a short, actionable list the
-*  agent can fix, pointing back at the field reference. */
-function formatSchemaIssues(issues) {
-	const shown = issues.slice(0, 20);
-	const lines = shown.map((issue) => `- ${issue.path.map(String).join(".") || "(root)"}: ${require_promptSafety.defangForPrompt(issue.message)}`).join("\n");
-	const omitted = issues.length - shown.length;
-	return `manageCollection: schema rejected — fix and retry (call schemaDocs for the field reference):\n${lines}${omitted > 0 ? `\n- …and ${omitted} more issue(s); fix these first and retry.` : ""}`;
-}
-/** Write the validated schema to the canonical staging copy, then mirror
-*  it into the active `.claude/skills/` tree discovery reads — an internal
-*  write doesn't fire the skill-bridge hook, so we mirror explicitly. */
-async function writeAndMirrorSchema(slug, schema, deps) {
-	const base = resolveBase(deps);
-	await writeFileAtomic(node_path.default.join(require_skill_bridge_index.dataSkillDir(base, slug), SCHEMA_FILE), `${JSON.stringify(schema, null, 2)}\n`);
-	require_skill_bridge_index.mirrorSkillWrite(base, {
-		slug,
-		relSegments: [SCHEMA_FILE]
-	});
-	try {
-		await deps.refreshAfterWrite?.();
-	} catch {}
-}
-/** The post-Zod acceptance gates discovery applies before a parsed schema
-*  becomes a live collection. Mirrors discovery's checks (`loadOneCollection`)
-*  so a write can't pass here yet be silently skipped on the next load.
-*  putSchema only runs for project-scope collections, so the feed-`ingest`
-*  gate doesn't apply. Returns a one-line reason, or null when the schema
-*  would be accepted. */
-function schemaDiscoveryGate(schema, base) {
-	const primaryField = schema.fields[schema.primaryKey];
-	if (!primaryField) return `primaryKey '${schema.primaryKey}' is not one of the declared fields`;
-	if (primaryField.primary !== true) return `the primaryKey field '${schema.primaryKey}' must be flagged \`primary: true\``;
-	if (schema.dataPath !== void 0 && resolveDataDir(schema.dataPath, base) === null) return `dataPath '${schema.dataPath}' escapes the workspace`;
-	if (schema.dataSource !== void 0 && resolveDataDir(schema.dataSource.path, base) === null) return `dataSource.path '${schema.dataSource.path}' escapes the workspace`;
-	return null;
-}
-/** Validate a schema against CollectionSchemaZ and, on success, persist it.
-*  Edit-only: a new collection is created by writing SKILL.md + schema.json
-*  under data/skills/<slug>/ (the normal create flow), not through here. */
-async function handlePutSchema(slug, schemaArg, deps) {
-	if (!schemaArg || typeof schemaArg !== "object" || Array.isArray(schemaArg)) return "manageCollection: `schema` is required for putSchema — the full collection schema object.";
-	const collection = await loadCollection(slug, deps);
-	if (!collection) return `manageCollection: unknown collection '${require_promptSafety.defangForPrompt(slug)}' — create it by writing SKILL.md + ${SCHEMA_FILE} under data/skills/${require_promptSafety.defangForPrompt(slug)}/, then edit it here.`;
-	const refusal = schemaEditRefusal(collection, slug);
-	if (refusal) return refusal;
-	const parsed = CollectionSchemaZ.safeParse(schemaArg);
-	if (!parsed.success) return formatSchemaIssues(parsed.error.issues);
-	const gate = schemaDiscoveryGate(parsed.data, resolveBase(deps));
-	if (gate) return `manageCollection: schema rejected — ${gate} (call schemaDocs for the field reference). It passes basic validation but discovery would skip it, hiding the collection.`;
-	await writeAndMirrorSchema(collection.slug, parsed.data, deps);
-	return JSON.stringify({
-		collection: collection.slug,
-		written: true
-	});
-}
-var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference, then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. Answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` on ANY collection — on a dataSource (CSV) collection it scans the whole file (getItems is row-capped, so aggregates computed from its output can be silently wrong on large files); on a file-backed collection it aggregates the enriched records, so computed fields (derived/rollup/toggle) are queryable columns.";
-/** Validate getItems' optional `ids`/`fields` args, then delegate. */
-async function dispatchGetItems(collection, args, deps) {
-	const ids = optionalStringArray(args.ids, "ids");
-	if (!ids.ok) return ids.error;
-	const fields = optionalStringArray(args.fields, "fields");
-	if (!fields.ok) return fields.error;
-	return handleGetItems(collection, {
-		slug: collection.slug,
-		ids: ids.value,
-		fields: fields.value
-	}, deps);
-}
-async function manageCollectionHandler(deps, args) {
-	const action = typeof args.action === "string" ? args.action : "";
-	if (action === "schemaDocs") return handleSchemaDocs(deps);
-	if (action === "getOntology") return handleGetOntology(deps);
-	const slug = typeof args.slug === "string" ? args.slug.trim() : "";
-	if (!slug) return "manageCollection: `slug` is required (the collection's slug).";
-	if (action === "getSchema") return handleGetSchema(slug, deps);
-	if (action === "putSchema") return handlePutSchema(slug, args.schema, deps);
-	if (action !== "getItems" && action !== "putItems" && action !== "queryItems") return "manageCollection: `action` must be \"getItems\", \"putItems\", \"queryItems\", \"getOntology\", \"schemaDocs\", \"getSchema\", or \"putSchema\".";
-	const collection = await loadCollection(slug, deps);
-	if (!collection) return unknownCollection(slug);
-	if (action === "getItems") return dispatchGetItems(collection, args, deps);
-	if (action === "queryItems") return handleQueryItems(collection, args.query, deps);
-	const parsed = parsePutItems(args, slug);
-	if (typeof parsed === "string") return parsed;
-	return handlePutItems(collection, parsed, deps);
-}
-var MANAGE_COLLECTION_DEFINITION = {
-	name: "manageCollection",
-	description: "Read and write a schema-driven collection through the host — both its records and its structure. getItems returns records WITH computed values (derived formulas, toggles, embeds) the stored JSON files don't contain; putItems validates each row against the schema before writing. getOntology maps the whole workspace: every collection with its record count and outbound ref/embed relations — call it first for cross-collection questions. schemaDocs returns the collection-authoring reference; getSchema/putSchema read and validate-then-write the collection's schema.json. Prefer it over raw file I/O on collections.",
-	inputSchema: {
-		type: "object",
-		properties: {
-			action: {
-				type: "string",
-				enum: [
-					"getItems",
-					"putItems",
-					"queryItems",
-					"getOntology",
-					"schemaDocs",
-					"getSchema",
-					"putSchema"
-				],
-				description: "What to do."
-			},
-			slug: {
-				type: "string",
-				description: "The collection's slug (its directory name, e.g. `stock-quotes`). Required for everything except schemaDocs and getOntology."
-			},
-			ids: {
-				type: "array",
-				items: { type: "string" },
-				description: "getItems: only these record ids (primary-key values). Omit for all records."
-			},
-			fields: {
-				type: "array",
-				items: { type: "string" },
-				description: "getItems: only these fields per record (the primary key is always included). Omit for all fields. Use on large collections."
-			},
-			items: {
-				type: "array",
-				items: { type: "object" },
-				description: "putItems: the record objects to store. Each must carry the schema's primaryKey value (it doubles as the filename)."
-			},
-			mode: {
-				type: "string",
-				enum: [
-					"upsert",
-					"create",
-					"merge"
-				],
-				description: "putItems: \"upsert\" (default) replaces existing records WHOLE; \"create\" rejects rows whose id already exists; \"merge\" updates only the fields a row carries, keeping the rest of the existing record (rejects unknown ids). Use \"merge\" when changing a few fields."
-			},
-			schema: {
-				type: "object",
-				description: "putSchema: the full collection schema object (same shape as schema.json — title, icon, dataPath, primaryKey, fields, …). Call getSchema first for the current one, and schemaDocs for the field DSL."
-			},
-			query: {
-				type: "object",
-				description: "queryItems: a structured aggregation query — `{ groupBy?: [\"col\"], aggregates?: { alias: { op: \"count\"|\"sum\"|\"avg\"|\"min\"|\"max\", column? } }, where?: [{ field, op, value }], orderBy?: [{ field, dir? }], limit? }`. At least one of groupBy/aggregates. On a dataSource (CSV) collection it scans the WHOLE file uncapped (unlike getItems); on a file-backed collection it aggregates the ENRICHED records, so computed fields (derived/rollup/toggle) are queryable columns. Use it for counts / sums / averages / group-bys instead of arithmetic over getItems output."
-			}
-		},
-		required: ["action"]
-	}
-};
-function makeManageCollectionTool(deps = {}) {
-	return {
-		definition: MANAGE_COLLECTION_DEFINITION,
-		alwaysActive: true,
-		prompt: MANAGE_COLLECTION_PROMPT,
-		handler: (args) => manageCollectionHandler(deps, args)
-	};
-}
-//#endregion
 Object.defineProperty(exports, "CollectionQueryZ", {
 	enumerable: true,
 	get: function() {
@@ -3620,28 +2539,10 @@ Object.defineProperty(exports, "MAX_QUERY_ROWS", {
 		return MAX_QUERY_ROWS;
 	}
 });
-Object.defineProperty(exports, "MAX_SCHEMA_ISSUES", {
-	enumerable: true,
-	get: function() {
-		return MAX_SCHEMA_ISSUES;
-	}
-});
-Object.defineProperty(exports, "MAX_UNSELECTIVE_ITEMS", {
-	enumerable: true,
-	get: function() {
-		return MAX_UNSELECTIVE_ITEMS;
-	}
-});
-Object.defineProperty(exports, "ONE_SECOND_MS", {
-	enumerable: true,
-	get: function() {
-		return ONE_SECOND_MS;
-	}
-});
 Object.defineProperty(exports, "SCHEMA_FILE", {
 	enumerable: true,
 	get: function() {
-		return SCHEMA_FILE$1;
+		return SCHEMA_FILE;
 	}
 });
 Object.defineProperty(exports, "acceptParsedSchema", {
@@ -3650,16 +2551,10 @@ Object.defineProperty(exports, "acceptParsedSchema", {
 		return acceptParsedSchema;
 	}
 });
-Object.defineProperty(exports, "advanceTriggerDate", {
+Object.defineProperty(exports, "archiveDir", {
 	enumerable: true,
 	get: function() {
-		return advanceTriggerDate;
-	}
-});
-Object.defineProperty(exports, "applyMutateAction", {
-	enumerable: true,
-	get: function() {
-		return applyMutateAction;
+		return archiveDir;
 	}
 });
 Object.defineProperty(exports, "buildActionSeedPrompt", {
@@ -3674,10 +2569,16 @@ Object.defineProperty(exports, "buildCollectionActionSeedPrompt", {
 		return buildCollectionActionSeedPrompt;
 	}
 });
-Object.defineProperty(exports, "buildWorkspaceOntology", {
+Object.defineProperty(exports, "cacheDir", {
+	enumerable: true,
+	get: function() {
+		return cacheDir;
+	}
+});
+Object.defineProperty(exports, "checkpointSqliteDatabase", {
 	enumerable: true,
 	get: function() {
-		return buildWorkspaceOntology;
+		return checkpointSqliteDatabase;
 	}
 });
 Object.defineProperty(exports, "collectionWritable", {
@@ -3704,24 +2605,6 @@ Object.defineProperty(exports, "compileJsonlQuery", {
 		return compileJsonlQuery;
 	}
 });
-Object.defineProperty(exports, "compileRecordZ", {
-	enumerable: true,
-	get: function() {
-		return compileRecordZ;
-	}
-});
-Object.defineProperty(exports, "computeCollectionIcon", {
-	enumerable: true,
-	get: function() {
-		return computeCollectionIcon;
-	}
-});
-Object.defineProperty(exports, "computeSuccessor", {
-	enumerable: true,
-	get: function() {
-		return computeSuccessor;
-	}
-});
 Object.defineProperty(exports, "configureCollectionHost", {
 	enumerable: true,
 	get: function() {
@@ -3734,12 +2617,6 @@ Object.defineProperty(exports, "csvRowToItem", {
 		return csvRowToItem;
 	}
 });
-Object.defineProperty(exports, "daysInMonth", {
-	enumerable: true,
-	get: function() {
-		return daysInMonth;
-	}
-});
 Object.defineProperty(exports, "decodeCsvRecordId", {
 	enumerable: true,
 	get: function() {
@@ -3752,24 +2629,6 @@ Object.defineProperty(exports, "dedupeByRecordId", {
 		return dedupeByRecordId;
 	}
 });
-Object.defineProperty(exports, "deleteCollection", {
-	enumerable: true,
-	get: function() {
-		return deleteCollection;
-	}
-});
-Object.defineProperty(exports, "deleteCollectionRefusalMessage", {
-	enumerable: true,
-	get: function() {
-		return deleteCollectionRefusalMessage;
-	}
-});
-Object.defineProperty(exports, "deleteCustomView", {
-	enumerable: true,
-	get: function() {
-		return deleteCustomView;
-	}
-});
 Object.defineProperty(exports, "deleteItem", {
 	enumerable: true,
 	get: function() {
@@ -3788,30 +2647,6 @@ Object.defineProperty(exports, "encodeCsvRecordId", {
 		return encodeCsvRecordId;
 	}
 });
-Object.defineProperty(exports, "enrichItems", {
-	enumerable: true,
-	get: function() {
-		return enrichItems;
-	}
-});
-Object.defineProperty(exports, "errorMessage", {
-	enumerable: true,
-	get: function() {
-		return errorMessage;
-	}
-});
-Object.defineProperty(exports, "firstMutateParamProblem", {
-	enumerable: true,
-	get: function() {
-		return firstMutateParamProblem;
-	}
-});
-Object.defineProperty(exports, "formatCivil", {
-	enumerable: true,
-	get: function() {
-		return formatCivil;
-	}
-});
 Object.defineProperty(exports, "generateItemId", {
 	enumerable: true,
 	get: function() {
@@ -3836,16 +2671,16 @@ Object.defineProperty(exports, "isContainedInWorkspace", {
 		return isContainedInWorkspace;
 	}
 });
-Object.defineProperty(exports, "isRegularFile", {
+Object.defineProperty(exports, "isPresetSlug", {
 	enumerable: true,
 	get: function() {
-		return isRegularFile;
+		return isPresetSlug;
 	}
 });
-Object.defineProperty(exports, "isTriggerDue", {
+Object.defineProperty(exports, "isRegularFile", {
 	enumerable: true,
 	get: function() {
-		return isTriggerDue;
+		return isRegularFile;
 	}
 });
 Object.defineProperty(exports, "itemFilePath", {
@@ -3872,28 +2707,22 @@ Object.defineProperty(exports, "log", {
 		return log;
 	}
 });
-Object.defineProperty(exports, "makeManageCollectionTool", {
+Object.defineProperty(exports, "normalizeCsvValue", {
 	enumerable: true,
 	get: function() {
-		return makeManageCollectionTool;
+		return normalizeCsvValue;
 	}
 });
-Object.defineProperty(exports, "maybeSpawnSuccessor", {
+Object.defineProperty(exports, "pageFromFullRead", {
 	enumerable: true,
 	get: function() {
-		return maybeSpawnSuccessor;
+		return pageFromFullRead;
 	}
 });
-Object.defineProperty(exports, "normalizeCsvValue", {
+Object.defineProperty(exports, "projectItemFields", {
 	enumerable: true,
 	get: function() {
-		return normalizeCsvValue;
-	}
-});
-Object.defineProperty(exports, "parseCivil", {
-	enumerable: true,
-	get: function() {
-		return parseCivil;
+		return projectItemFields;
 	}
 });
 Object.defineProperty(exports, "promptPathsFor", {
@@ -3908,6 +2737,12 @@ Object.defineProperty(exports, "publishCollectionChange", {
 		return publishCollectionChange;
 	}
 });
+Object.defineProperty(exports, "queryCsv", {
+	enumerable: true,
+	get: function() {
+		return queryCsv;
+	}
+});
 Object.defineProperty(exports, "readCustomViewHtml", {
 	enumerable: true,
 	get: function() {
@@ -3938,12 +2773,6 @@ Object.defineProperty(exports, "readSkillTemplate", {
 		return readSkillTemplate;
 	}
 });
-Object.defineProperty(exports, "recordFieldProblem", {
-	enumerable: true,
-	get: function() {
-		return recordFieldProblem;
-	}
-});
 Object.defineProperty(exports, "resolveCreateItemId", {
 	enumerable: true,
 	get: function() {
@@ -3956,10 +2785,10 @@ Object.defineProperty(exports, "resolveDataDir", {
 		return resolveDataDir;
 	}
 });
-Object.defineProperty(exports, "resolveEvery", {
+Object.defineProperty(exports, "resolveMutateSet", {
 	enumerable: true,
 	get: function() {
-		return resolveEvery;
+		return resolveMutateSet;
 	}
 });
 Object.defineProperty(exports, "resolveTemplatePath", {
@@ -3968,12 +2797,6 @@ Object.defineProperty(exports, "resolveTemplatePath", {
 		return resolveTemplatePath;
 	}
 });
-Object.defineProperty(exports, "runQueryOverRows", {
-	enumerable: true,
-	get: function() {
-		return runQueryOverRows;
-	}
-});
 Object.defineProperty(exports, "safeRecordId", {
 	enumerable: true,
 	get: function() {
@@ -3986,28 +2809,22 @@ Object.defineProperty(exports, "safeSlugName", {
 		return safeSlugName;
 	}
 });
-Object.defineProperty(exports, "schemaRelations", {
-	enumerable: true,
-	get: function() {
-		return schemaRelations;
-	}
-});
 Object.defineProperty(exports, "setCollectionChangePublisher", {
 	enumerable: true,
 	get: function() {
 		return setCollectionChangePublisher;
 	}
 });
-Object.defineProperty(exports, "storeFor", {
+Object.defineProperty(exports, "skillsStagingDir", {
 	enumerable: true,
 	get: function() {
-		return storeFor;
+		return skillsStagingDir;
 	}
 });
-Object.defineProperty(exports, "successorId", {
+Object.defineProperty(exports, "storeFor", {
 	enumerable: true,
 	get: function() {
-		return successorId;
+		return storeFor;
 	}
 });
 Object.defineProperty(exports, "toDetail", {
@@ -4022,18 +2839,6 @@ Object.defineProperty(exports, "toSummary", {
 		return toSummary;
 	}
 });
-Object.defineProperty(exports, "validateCollectionRecords", {
-	enumerable: true,
-	get: function() {
-		return validateCollectionRecords;
-	}
-});
-Object.defineProperty(exports, "validateRecordObject", {
-	enumerable: true,
-	get: function() {
-		return validateRecordObject;
-	}
-});
 Object.defineProperty(exports, "writeFileAtomic", {
 	enumerable: true,
 	get: function() {
@@ -4047,4 +2852,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-CkysfLh4.cjs.map
+//# sourceMappingURL=discovery-cwtfyDxl.cjs.map