@mulmoclaude/core 3.0.0 → 3.1.0

package/dist/{server-CedIocRS.js → server-AA2kfDfk.js}

@@ -1,11 +1,11 @@
 import { a as isErrorWithCode, c as isStringArray, l as isUnknownArray, s as isRecord, t as errorMessage } from "./dist-D8zokgGo.js";
-import { t as writeFileAtomic } from "./atomic-DPpdrJzO.js";
+import { n as writeFileAtomic } from "./root-BMroU_mB.js";
 import { n as toPosixRelPath } from "./relPath-DW8MC8VO.js";
 import { A as fieldTextOrNull, E as isFieldDrivenEvery, O as storageKindFor, S as COMPUTED_TYPES, T as embedTargetId, k as fieldText, l as parseIsoDate, u as parseIsoDateTime } from "./calendarGrid-Csy2rpjp.js";
 import { C as actionVisible, _ as uniqueRefTargets, b as projectBacklinkRow, c as selectDynamicRecord, f as itemIsDone, g as uniqueEmbedTargets, h as uniqueBacklinkSources, i as ownProp, n as deriveAll, o as firstDateField, s as resolveIcon, t as defangForPrompt, v as backlinkRows, x as rollupValue, y as coerceNumeric } from "./promptSafety-ACXw_2Yu.js";
-import { B as resolveDataDir, F as resolveCreateItemId, G as archiveDir, L as SCHEMA_FILE$1, M as isRegularFile, R as isContainedInRoot, S as queryCsv, T as CollectionQueryZ, U as safeSlugName, V as resolveTemplatePath, X as isPresetSlug$1, Y as getWorkspaceRoot, Z as log, c as resolveMutateSet, d as storeFor, f as checkpointSqliteDatabase, g as cacheDir, i as resolvePrimaryField, k as isBackendUnavailable, n as discoverCollections, r as loadCollection, s as CollectionSchemaZ, tt as skillsStagingDir, u as readOnlyRefusal, w as compileJsonlQuery, x as normalizeCsvValue } from "./discovery-4Z-ZWFam.js";
+import { B as resolveDataDir, F as resolveCreateItemId, G as archiveDir, L as SCHEMA_FILE$1, M as isRegularFile, R as isContainedInRoot, S as queryCsv, T as CollectionQueryZ, U as safeSlugName, V as resolveTemplatePath, X as isPresetSlug$1, Y as getWorkspaceRoot, Z as log, c as resolveMutateSet, d as storeFor, f as checkpointSqliteDatabase, g as cacheDir, i as resolvePrimaryField, k as isBackendUnavailable, n as discoverCollections, r as loadCollection, rt as stagingSkillDir, s as CollectionSchemaZ, u as readOnlyRefusal, w as compileJsonlQuery, x as normalizeCsvValue } from "./discovery-CC7kuwHf.js";
 import { ingestStatePath } from "./feeds/paths.js";
-import { dataSkillDir, mirrorSkillWrite } from "./skill-bridge/index.js";
+import { mirrorSkillWrite } from "./skill-bridge/index.js";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
@@ -37,7 +37,8 @@ async function readSourceAwareFile(collection, relPath, opts) {
 	const safeSlug = safeSlugName(collection.slug);
 	if (safeSlug === null) return null;
 	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const bases = collection.source === "project" ? [path.join(skillsStagingDir(workspaceRoot), safeSlug), collection.skillDir] : [collection.skillDir];
+	const staging = collection.source === "project" ? stagingSkillDir(workspaceRoot, safeSlug) : null;
+	const bases = staging === null ? [collection.skillDir] : [staging, collection.skillDir];
 	for (const base of bases) {
 		const resolved = resolveTemplatePath(base, relPath);
 		if (resolved === null) continue;
@@ -1024,10 +1025,6 @@ function deleteCollectionRefusalMessage(result) {
 		"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 path.join(skillsStagingDir(workspaceRoot), slug);
-}
 async function pathExists(target) {
 	try {
 		await stat(target);
@@ -1043,8 +1040,9 @@ function todayStamp() {
 /** Every directory the delete will touch must resolve under the
 *  workspace root — guards against a symlinked ancestor escaping it. */
 function deleteTargets(collection, workspaceRoot) {
+	const staging = stagingSkillDir(workspaceRoot, collection.slug);
 	return [
-		stagingSkillDir(workspaceRoot, collection.slug),
+		...staging === null ? [] : [staging],
 		collection.skillDir,
 		collection.dataDir,
 		ingestStatePath(collection.slug, workspaceRoot),
@@ -1095,14 +1093,22 @@ function restoreRecordsStep(schema) {
    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.
+/** Step 1 of the restore doc, which depends on the root's authoring layout.
+*
+*  A staged root routes around the `.claude/` permission gate and relies on the
+*  bridge hook; a root with no staging tree has neither, so the same
+*  instructions would have the user restore into `data/skills/<slug>/`, where
+*  nothing would ever read it — the collection would stay deleted while the
+*  document said it was restored. */
+function restoreSkillStep(slug, staged) {
+	if (!staged) return `1. Recreate the skill files in \`.claude/skills/${slug}/\`: read each
+   file under \`skill/\` and write it to the matching path — \`SKILL.md\`,
+   \`schema.json\`, any \`templates/*\`, and any \`views/*\`.
 
-1. Recreate the skill files in \`data/skills/${slug}/\` using the **Write
+   This project has no \`data/skills/\` staging tree and no bridge hook, so
+   the skill directory is read directly and no mirroring step follows. Do
+   NOT restore into \`data/skills/${slug}/\` — nothing reads it there.`;
+	return `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/*\`.
 
@@ -1113,7 +1119,16 @@ Follow these steps to restore it.
    \`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.)
+   permission-gated.)`;
+}
+function buildRestoreDoc(collection, staged) {
+	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.
+
+${restoreSkillStep(slug, staged)}
 
 ${restoreRecordsStep(schema)}
 
@@ -1127,7 +1142,7 @@ ${restoreRecordsStep(schema)}
 /** Copy one skill copy + the records + RESTORE.md into `archiveDir`. */
 async function writeArchive(collection, archiveDir, workspaceRoot) {
 	const staging = stagingSkillDir(workspaceRoot, collection.slug);
-	const skillSrc = await pathExists(staging) ? staging : collection.skillDir;
+	const skillSrc = staging !== null && await pathExists(staging) ? staging : collection.skillDir;
 	await cp(skillSrc, path.join(archiveDir, "skill"), { recursive: true });
 	if (await pathExists(collection.dataDir)) await cp(collection.dataDir, path.join(archiveDir, "records"), { recursive: true });
 	if (collection.storageFile !== void 0 && await pathExists(collection.storageFile)) {
@@ -1142,13 +1157,14 @@ async function writeArchive(collection, archiveDir, workspaceRoot) {
 			if (await pathExists(sidecar)) await cp(sidecar, path.join(archiveDir, path.basename(sidecar)));
 		}
 	}
-	await writeFile(path.join(archiveDir, "RESTORE.md"), buildRestoreDoc(collection), "utf-8");
+	await writeFile(path.join(archiveDir, "RESTORE.md"), buildRestoreDoc(collection, staging !== null), "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 rm(stagingSkillDir(workspaceRoot, collection.slug), {
+	const staging = stagingSkillDir(workspaceRoot, collection.slug);
+	if (staging !== null) await rm(staging, {
 		recursive: true,
 		force: true
 	});
@@ -1232,8 +1248,8 @@ async function fileExists(target) {
 *  deletes agree on both layouts. */
 async function canonicalBase(collection, workspaceRoot, safeSlug) {
 	if (collection.source !== "project") return collection.skillDir;
-	const staging = path.join(skillsStagingDir(workspaceRoot), safeSlug);
-	if (await fileExists(path.join(staging, "schema.json"))) return staging;
+	const staging = stagingSkillDir(workspaceRoot, safeSlug);
+	if (staging !== null && await fileExists(path.join(staging, "schema.json"))) return staging;
 	return collection.skillDir;
 }
 /** Every on-disk schema.json that must reflect the removal. The active
@@ -1244,9 +1260,9 @@ async function canonicalBase(collection, workspaceRoot, safeSlug) {
 async function schemaWriteTargets(collection, workspaceRoot, safeSlug) {
 	const active = path.join(collection.skillDir, SCHEMA_FILE$1);
 	if (collection.source !== "project") return [active];
-	const stagingSchema = path.join(skillsStagingDir(workspaceRoot), safeSlug, SCHEMA_FILE$1);
+	const staging = stagingSkillDir(workspaceRoot, safeSlug);
 	const targets = [];
-	if (await fileExists(stagingSchema)) targets.push(stagingSchema);
+	if (staging !== null && await fileExists(path.join(staging, "schema.json"))) targets.push(path.join(staging, SCHEMA_FILE$1));
 	targets.push(active);
 	return targets;
 }
@@ -1304,6 +1320,43 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 		viewId
 	};
 }
+//#endregion
+//#region src/collection/server/schemaDocs.ts
+/** Fenced authoring variants inside the reference doc.
+*
+*  A collection's authoring LOCATION depends on the root it lives in, and the
+*  doc is served to the agent by both hosts:
+*
+*  - a MANAGED workspace gates writes into `.claude/` and runs a skill-bridge
+*    hook, so the agent authors under `data/skills/<slug>/` and the hook
+*    mirrors it across (`staged`);
+*  - a plain project root has neither gate nor bridge, so `data/skills/` is
+*    never discovered — writing there produces nothing, silently — and the
+*    agent must author under `.claude/skills/<slug>/` (`direct`).
+*
+*  The two variants are fenced in the markdown so everything else stays shared
+*  and the doc keeps reading as one document. Fence lines are removed with
+*  their newline, so the `staged` render is byte-identical to the doc as it was
+*  before the fences existed — which is what protects the single-workspace
+*  host. */
+var VARIANT_FENCE = /^<!-- \/?authoring:(staged|direct) -->$/;
+/** Strip the fences and drop whichever variant's body doesn't apply. Runs
+*  BEFORE section parsing, so a variant may contain headings or code fences. */
+function applyAuthoringVariant(doc, variant) {
+	if (!doc.includes("<!-- authoring:")) return doc;
+	const kept = [];
+	let dropping = null;
+	for (const line of doc.split("\n")) {
+		const match = VARIANT_FENCE.exec(line.trim());
+		if (match) {
+			const [, name = ""] = match;
+			dropping = line.trim().startsWith("<!-- /") ? null : name === variant ? null : name;
+			continue;
+		}
+		if (dropping === null) kept.push(line);
+	}
+	return kept.join("\n");
+}
 /** Ceiling for ANY assembled reply — topic or default — safely inside
 *  the agent's per-result limit (the full doc is what overflowed it).
 *  A matched section too large to fit degrades to its own prose plus a
@@ -1444,7 +1497,8 @@ function renderTopic(lines, sections, topic) {
 *  up outside any single piece's budget, and the ceiling must hold no
 *  matter what shape of document arrives. Only the explicit \`"all"\`
 *  opt-in and the small-doc verbatim path may exceed it. */
-function renderSchemaDocs(doc, topic) {
+function renderSchemaDocs(rawDoc, topic, variant = "staged") {
+	const doc = applyAuthoringVariant(rawDoc, variant);
 	const requested = topic?.trim() ?? "";
 	if (normalize(requested) === "all") return doc;
 	if (doc.length <= 2e4) return doc;
@@ -1474,11 +1528,33 @@ 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";
+/** `schemaDocs` names no collection, but the authoring layout is resolved per
+*  slug (staging is `<staging>/<slug>`). This stands in, so the doc variant and
+*  a later `putSchema` on any slug in this root cannot disagree. */
+var SCHEMA_DOCS_PROBE_SLUG = "_";
 /** 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();
 }
+/** Where a collection skill is authored in THIS root, and therefore both which
+*  authoring guide `schemaDocs` serves and where `getSchema` / `putSchema`
+*  read and write. `null` staging means "author in the active skill dir".
+*
+*  ONE predicate on purpose. Two knobs describe this — the host's
+*  `stagedSkillAuthoring` and its `skillsStagingDir` — and either alone can
+*  disagree with the other: a host that says `stagedSkillAuthoring: false`
+*  while still returning a staging path would have the agent told to write
+*  `.claude/skills/<slug>/` while `putSchema` wrote `data/skills/` and mirrored
+*  from there, so the tool would silently contradict its own documentation.
+*  Staged requires BOTH to agree; anything else is direct. */
+function authoringTarget(deps, slug) {
+	const stagingDir = deps.stagedSkillAuthoring === false ? null : stagingSkillDir(resolveBase(deps), slug);
+	return {
+		variant: stagingDir === null ? "direct" : "staged",
+		stagingDir
+	};
+}
 /** Shared "unknown collection" message — its schema.json is missing or
 *  failed validation, so discovery skipped it. */
 function unknownCollection(slug) {
@@ -1745,9 +1821,10 @@ async function handleGetOntology(deps) {
 *  fallback. Both reads guarded; if neither resolves the agent still
 *  gets an actionable message instead of a thrown call. */
 async function handleSchemaDocs(deps, topic) {
+	const { variant } = authoringTarget(deps, SCHEMA_DOCS_PROBE_SLUG);
 	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 renderSchemaDocs(await readFile(candidate, "utf-8"), topic);
+		return renderSchemaDocs(await readFile(candidate, "utf-8"), topic, variant);
 	} catch {}
 	return `manageCollection: could not read the collection-authoring reference (${SCHEMA_DOCS_FILE}).`;
 }
@@ -1758,16 +1835,25 @@ async function handleSchemaDocs(deps, topic) {
 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)];
+	const { stagingDir } = authoringTarget(deps, collection.slug);
+	const candidates = [...stagingDir === null ? [] : [path.join(stagingDir, 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}.`;
 }
+/** Where the agent should CREATE a collection skill in this root, named in the
+*  messages that tell it to. Naming `data/skills/` under a root that has no
+*  staging tree sends the agent to a directory nothing reads — the exact
+*  silent failure the root-aware authoring guide exists to prevent, reappearing
+*  in an error string the agent is far more likely to act on immediately. */
+function authoringDirLabel(deps, slug) {
+	return authoringTarget(deps, slug).variant === "staged" ? `data/skills/${slug}/` : `.claude/skills/${slug}/`;
+}
 /** 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.`;
+function schemaEditRefusal(collection, slug, deps) {
+	if (collection.source !== "project") return `manageCollection: '${defangForPrompt(slug)}' is ${collection.source}-scope and read-only here — only project collections (${authoringDirLabel(deps, "<slug>")}) 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;
 }
@@ -1781,14 +1867,23 @@ function formatSchemaIssues(issues) {
 }
 /** 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) {
+*  write doesn't fire the skill-bridge hook, so we mirror explicitly.
+*
+*  A root with NO staging tree has no bridge to mirror through either, so the
+*  active skill dir IS the canonical copy and is written directly. Mirroring
+*  there would read a staging file that never exists. */
+async function writeAndMirrorSchema(slug, skillDir, 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]
-	});
+	const serialized = `${JSON.stringify(schema, null, 2)}\n`;
+	const { stagingDir } = authoringTarget(deps, slug);
+	if (stagingDir === null) await writeFileAtomic(path.join(skillDir, SCHEMA_FILE), serialized);
+	else {
+		await writeFileAtomic(path.join(stagingDir, SCHEMA_FILE), serialized);
+		mirrorSkillWrite(base, {
+			slug,
+			relSegments: [SCHEMA_FILE]
+		});
+	}
 	try {
 		await deps.refreshAfterWrite?.();
 	} catch {}
@@ -1808,19 +1903,19 @@ function schemaDiscoveryGate(schema, base) {
 	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. */
+*  Edit-only: a new collection is created by writing SKILL.md + schema.json in
+*  the root's authoring dir (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 (!collection) return `manageCollection: unknown collection '${defangForPrompt(slug)}' — create it by writing SKILL.md + ${SCHEMA_FILE} under ${authoringDirLabel(deps, defangForPrompt(slug))}, then edit it here.`;
+	const refusal = schemaEditRefusal(collection, slug, deps);
 	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);
+	await writeAndMirrorSchema(collection.slug, collection.skillDir, parsed.data, deps);
 	return JSON.stringify({
 		collection: collection.slug,
 		written: true
@@ -1955,4 +2050,4 @@ function makeManageCollectionTool(deps = {}) {
 //#endregion
 export { buildCollectionActionSeedPrompt as A, validateRecordObject as C, enrichItems as D, runCollectionQuery as E, readCustomViewHtml as M, readCustomViewI18n as N, runQueryOverRows as O, readSkillTemplate as P, validateCollectionRecords as S, recordFieldProblem as T, computeCollectionIcon as _, deleteCollection as a, applyMutateAction as b, computeSuccessor as c, isTriggerDue as d, maybeSpawnSuccessor as f, ONE_SECOND_MS as g, successorId as h, deleteCustomView as i, promptPathsFor as j, buildActionSeedPrompt as k, daysInMonth as l, resolveEvery as m, MAX_UNSELECTIVE_ITEMS as n, deleteCollectionRefusalMessage as o, parseCivil as p, makeManageCollectionTool as r, advanceTriggerDate as s, MAX_SCHEMA_ISSUES as t, formatCivil as u, buildWorkspaceOntology as v, compileRecordZ as w, firstMutateParamProblem as x, schemaRelations as y };
 
-//# sourceMappingURL=server-CedIocRS.js.map
+//# sourceMappingURL=server-AA2kfDfk.js.map