@mulmoclaude/core 0.18.1 → 0.19.0

package/dist/{server-C3FOqabY.js → server-Bd8l1bhv.js}

@@ -1,5 +1,6 @@
-import { A as SAFE_RECORD_ID_PATTERN, C as coerceNumeric, E as actionVisible, F as COMPUTED_TYPES, I as FEED_SCHEDULES, L as INGEST_KINDS, M as isSafeRecordId, N as isSafeSlug, P as AGENT_INGEST_KIND, R as embedTargetId, S as backlinkRows, T as rollupValue, b as selectDynamicRecord, h as deriveAll, j as SAFE_SLUG_PATTERN, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, w as projectBacklinkRow, y as resolveIcon, z as isFieldDrivenEvery } from "./calendarGrid-B3dtFN-m.js";
+import { B as isFieldDrivenEvery, C as backlinkRows, D as actionVisible, E as rollupValue, F as AGENT_INGEST_KIND, I as COMPUTED_TYPES, L as FEED_SCHEDULES, M as SAFE_SLUG_PATTERN, N as isSafeRecordId, P as isSafeSlug, R as INGEST_KINDS, T as projectBacklinkRow, b as resolveIcon, d as parseIsoDateTime, g as deriveAll, j as SAFE_RECORD_ID_PATTERN, t as defangForPrompt, u as parseIsoDate, w as coerceNumeric, x as selectDynamicRecord, y as firstDateField, z as embedTargetId } from "./promptSafety-DyG3EuC7.js";
 import { isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath } from "./collection/paths.js";
+import { dataSkillDir, mirrorSkillWrite } from "./skill-bridge/index.js";
 import path from "node:path";
 import { promises, realpathSync } from "node:fs";
 import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
@@ -60,7 +61,7 @@ function collectionsRegistriesConfigPath() {
 	const host = requireHost();
 	return host.paths.collectionsRegistriesConfig(host.workspaceRoot);
 }
-function isPresetSlug(slug) {
+function isPresetSlug$1(slug) {
 	return requireHost().isPresetSlug(slug);
 }
 /** Logger proxy so engine modules can `import { log }` and use it exactly like
@@ -77,7 +78,7 @@ var log = {
 };
 //#endregion
 //#region src/collection/server/paths.ts
-var SCHEMA_FILE = "schema.json";
+var SCHEMA_FILE$1 = "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).
@@ -1589,7 +1590,7 @@ function acceptParsedSchema(schema, opts) {
 async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
 	const safeName = safeSlugName(slug);
 	if (safeName === null) return null;
-	const schemaPath = path.join(skillsRoot, safeName, SCHEMA_FILE);
+	const schemaPath = path.join(skillsRoot, safeName, SCHEMA_FILE$1);
 	let raw;
 	try {
 		if (!(await stat(schemaPath)).isFile()) return null;
@@ -2300,7 +2301,7 @@ async function deleteCollection(collection, opts = {}) {
 		kind: "user-scope",
 		slug
 	};
-	if (isPresetSlug(slug)) return {
+	if (isPresetSlug$1(slug)) return {
 		kind: "preset",
 		slug
 	};
@@ -2366,9 +2367,9 @@ async function canonicalBase(collection, workspaceRoot, safeSlug) {
 *  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 = path.join(collection.skillDir, SCHEMA_FILE);
+	const active = path.join(collection.skillDir, SCHEMA_FILE$1);
 	if (collection.source !== "project") return [active];
-	const stagingSchema = path.join(skillsStagingDir(workspaceRoot), safeSlug, SCHEMA_FILE);
+	const stagingSchema = path.join(skillsStagingDir(workspaceRoot), safeSlug, SCHEMA_FILE$1);
 	const targets = [];
 	if (await fileExists(stagingSchema)) targets.push(stagingSchema);
 	targets.push(active);
@@ -2389,7 +2390,7 @@ async function unlinkIfPresent(target) {
 *  preserved verbatim. */
 async function removeViewFromSchemas(collection, viewId, workspaceRoot, safeSlug) {
 	const base = await canonicalBase(collection, workspaceRoot, safeSlug);
-	const canonical = path.join(base, SCHEMA_FILE);
+	const canonical = path.join(base, SCHEMA_FILE$1);
 	const parsed = JSON.parse(await 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`;
@@ -2400,7 +2401,7 @@ async function removeViewFromSchemas(collection, viewId, workspaceRoot, safeSlug
 *  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(collection.slug)) return { kind: "preset" };
+	if (isPresetSlug$1(collection.slug)) return { kind: "preset" };
 	const safeSlug = safeSlugName(collection.slug);
 	if (safeSlug === null) return {
 		kind: "unsafe-path",
@@ -2425,7 +2426,392 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 		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 '${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) => `- ${defangForPrompt(issue.file)}: ${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) {
+	if (!ids) return {
+		items: await listItems(collection.dataDir, { workspaceRoot: deps.workspaceRoot }),
+		missing: []
+	};
+	const items = [];
+	const missing = [];
+	for (const recordId of ids) {
+		const item = await readItem(collection.dataDir, recordId, { workspaceRoot: deps.workspaceRoot }).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) => 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 || !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 || !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: defangForPrompt(about),
+		problem: 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");
+}
+async function handlePutItems(collection, args, deps) {
+	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 = [path.join(resolveBase(deps), HELPS_DIR, SCHEMA_DOCS_FILE), ...deps.bundledHelpsDir ? [path.join(deps.bundledHelpsDir(), SCHEMA_DOCS_FILE)] : []];
+	for (const candidate of candidates) try {
+		return await 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 = [path.join(dataSkillDir(resolveBase(deps), collection.slug), SCHEMA_FILE), path.join(collection.skillDir, SCHEMA_FILE)];
+	for (const candidate of candidates) try {
+		return await readFile(candidate, "utf-8");
+	} catch {}
+	return `manageCollection: '${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: '${defangForPrompt(slug)}' is ${collection.source}-scope and read-only here — only project collections (data/skills/) can be edited.`;
+	if (isPresetSlug(slug)) return `manageCollection: '${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)"}: ${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(path.join(dataSkillDir(base, slug), SCHEMA_FILE), `${JSON.stringify(schema, null, 2)}\n`);
+	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 (resolveDataDir(schema.dataPath, base) === null) return `dataPath '${schema.dataPath}' 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 '${defangForPrompt(slug)}' — create it by writing SKILL.md + ${SCHEMA_FILE} under data/skills/${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.";
+/** 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") return "manageCollection: `action` must be \"getItems\", \"putItems\", \"getOntology\", \"schemaDocs\", \"getSchema\", or \"putSchema\".";
+	const collection = await loadCollection(slug, deps);
+	if (!collection) return unknownCollection(slug);
+	if (action === "getItems") return dispatchGetItems(collection, args, deps);
+	const parsed = parsePutItems(args, slug);
+	if (typeof parsed === "string") return parsed;
+	return handlePutItems(collection, parsed, deps);
+}
+function makeManageCollectionTool(deps = {}) {
+	return {
+		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",
+							"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."
+					}
+				},
+				required: ["action"]
+			}
+		},
+		alwaysActive: true,
+		prompt: MANAGE_COLLECTION_PROMPT,
+		handler: (args) => manageCollectionHandler(deps, args)
+	};
+}
 //#endregion
-export { collectionsRegistriesConfigPath as $, recordFieldProblem as A, readItem as B, toSummary as C, validateCollectionRecords as D, firstMutateParamProblem as E, isRegularFile as F, SCHEMA_FILE as G, resolveCreateItemId as H, listItems as I, itemFilePath as J, isContainedInRoot as K, promptPathsFor as L, buildCollectionActionSeedPrompt as M, deleteItem as N, validateRecordObject as O, generateItemId as P, safeSlugName as Q, readCustomViewHtml as R, toDetail as S, applyMutateAction as T, writeItem as U, readSkillTemplate as V, writeFileAtomic as W, resolveTemplatePath as X, resolveDataDir as Y, safeRecordId as Z, buildWorkspaceOntology as _, computeSuccessor as a, discoverCollections as b, isTriggerDue as c, resolveEvery as d, configureCollectionHost as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, setCollectionChangePublisher as it, buildActionSeedPrompt as j, compileRecordZ as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, log as nt, daysInMonth as o, ONE_SECOND_MS as p, isContainedInWorkspace as q, deleteCollectionRefusalMessage as r, publishCollectionChange as rt, formatCivil as s, deleteCustomView as t, getWorkspaceRoot as tt, parseCivil as u, schemaRelations as v, CollectionSchemaZ as w, loadCollection as x, acceptParsedSchema as y, readCustomViewI18n as z };
+export { resolveTemplatePath as $, validateCollectionRecords as A, promptPathsFor as B, discoverCollections as C, CollectionSchemaZ as D, toSummary as E, buildCollectionActionSeedPrompt as F, resolveCreateItemId as G, readCustomViewI18n as H, deleteItem as I, SCHEMA_FILE$1 as J, writeItem as K, generateItemId as L, compileRecordZ as M, recordFieldProblem as N, applyMutateAction as O, buildActionSeedPrompt as P, resolveDataDir as Q, isRegularFile as R, acceptParsedSchema as S, toDetail as T, readItem as U, readCustomViewHtml as V, readSkillTemplate as W, isContainedInWorkspace as X, isContainedInRoot as Y, itemFilePath as Z, errorMessage as _, deleteCollection as a, log as at, buildWorkspaceOntology as b, computeSuccessor as c, isTriggerDue as d, safeRecordId as et, maybeSpawnSuccessor as f, ONE_SECOND_MS as g, successorId as h, deleteCustomView as i, getWorkspaceRoot as it, validateRecordObject as j, firstMutateParamProblem as k, daysInMonth as l, resolveEvery as m, MAX_UNSELECTIVE_ITEMS as n, collectionsRegistriesConfigPath as nt, deleteCollectionRefusalMessage as o, publishCollectionChange as ot, parseCivil as p, writeFileAtomic as q, makeManageCollectionTool as r, configureCollectionHost as rt, advanceTriggerDate as s, setCollectionChangePublisher as st, MAX_SCHEMA_ISSUES as t, safeSlugName as tt, formatCivil as u, computeCollectionIcon as v, loadCollection as w, schemaRelations as x, enrichItems as y, listItems as z };
 
-//# sourceMappingURL=server-C3FOqabY.js.map
+//# sourceMappingURL=server-Bd8l1bhv.js.map