@mulmoclaude/core 3.0.0 → 3.1.0

package/dist/{server-DOZFzx5l.cjs → server-WU35UYlF.cjs}

@@ -1,10 +1,10 @@
 const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
 const require_dist = require("./dist-CsgSfWwR.cjs");
-const require_atomic = require("./atomic-DhUk8uiM.cjs");
+const require_root = require("./root-rPH6FGDT.cjs");
 const require_relPath = require("./relPath-CTAjGdCL.cjs");
 const require_calendarGrid = require("./calendarGrid-p8K-7cuB.cjs");
 const require_promptSafety = require("./promptSafety-CNEW3_qS.cjs");
-const require_discovery = require("./discovery-CtiZMlsX.cjs");
+const require_discovery = require("./discovery-CDOjfctD.cjs");
 const require_feeds_paths = require("./feeds/paths.cjs");
 const require_skill_bridge_index = require("./skill-bridge/index.cjs");
 let node_path = require("node:path");
@@ -39,7 +39,8 @@ async function readSourceAwareFile(collection, relPath, opts) {
 	const safeSlug = require_discovery.safeSlugName(collection.slug);
 	if (safeSlug === null) return null;
 	const workspaceRoot = opts.workspaceRoot ?? require_discovery.getWorkspaceRoot();
-	const bases = collection.source === "project" ? [node_path.default.join(require_discovery.skillsStagingDir(workspaceRoot), safeSlug), collection.skillDir] : [collection.skillDir];
+	const staging = collection.source === "project" ? require_discovery.stagingSkillDir(workspaceRoot, safeSlug) : null;
+	const bases = staging === null ? [collection.skillDir] : [staging, collection.skillDir];
 	for (const base of bases) {
 		const resolved = require_discovery.resolveTemplatePath(base, relPath);
 		if (resolved === null) continue;
@@ -1026,10 +1027,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 node_path.default.join(require_discovery.skillsStagingDir(workspaceRoot), slug);
-}
 async function pathExists(target) {
 	try {
 		await (0, node_fs_promises.stat)(target);
@@ -1045,8 +1042,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 = require_discovery.stagingSkillDir(workspaceRoot, collection.slug);
 	return [
-		stagingSkillDir(workspaceRoot, collection.slug),
+		...staging === null ? [] : [staging],
 		collection.skillDir,
 		collection.dataDir,
 		require_feeds_paths.ingestStatePath(collection.slug, workspaceRoot),
@@ -1097,14 +1095,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/*\`.
 
@@ -1115,7 +1121,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)}
 
@@ -1128,8 +1143,8 @@ ${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 staging = require_discovery.stagingSkillDir(workspaceRoot, collection.slug);
+	const skillSrc = staging !== null && await pathExists(staging) ? staging : collection.skillDir;
 	await (0, node_fs_promises.cp)(skillSrc, 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 });
 	if (collection.storageFile !== void 0 && await pathExists(collection.storageFile)) {
@@ -1144,13 +1159,14 @@ async function writeArchive(collection, archiveDir, workspaceRoot) {
 			if (await pathExists(sidecar)) await (0, node_fs_promises.cp)(sidecar, node_path.default.join(archiveDir, node_path.default.basename(sidecar)));
 		}
 	}
-	await (0, node_fs_promises.writeFile)(node_path.default.join(archiveDir, "RESTORE.md"), buildRestoreDoc(collection), "utf-8");
+	await (0, node_fs_promises.writeFile)(node_path.default.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 (0, node_fs_promises.rm)(stagingSkillDir(workspaceRoot, collection.slug), {
+	const staging = require_discovery.stagingSkillDir(workspaceRoot, collection.slug);
+	if (staging !== null) await (0, node_fs_promises.rm)(staging, {
 		recursive: true,
 		force: true
 	});
@@ -1234,8 +1250,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 = node_path.default.join(require_discovery.skillsStagingDir(workspaceRoot), safeSlug);
-	if (await fileExists(node_path.default.join(staging, "schema.json"))) return staging;
+	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
+	if (staging !== null && 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
@@ -1246,9 +1262,9 @@ async function canonicalBase(collection, workspaceRoot, safeSlug) {
 async function schemaWriteTargets(collection, workspaceRoot, safeSlug) {
 	const active = node_path.default.join(collection.skillDir, require_discovery.SCHEMA_FILE);
 	if (collection.source !== "project") return [active];
-	const stagingSchema = node_path.default.join(require_discovery.skillsStagingDir(workspaceRoot), safeSlug, require_discovery.SCHEMA_FILE);
+	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
 	const targets = [];
-	if (await fileExists(stagingSchema)) targets.push(stagingSchema);
+	if (staging !== null && await fileExists(node_path.default.join(staging, "schema.json"))) targets.push(node_path.default.join(staging, require_discovery.SCHEMA_FILE));
 	targets.push(active);
 	return targets;
 }
@@ -1274,7 +1290,7 @@ async function removeViewFromSchemas(collection, viewId, workspaceRoot, safeSlug
 		views: parsed.views.filter((entry) => !require_dist.isRecord(entry) || entry.id !== viewId)
 	} : parsed;
 	const serialized = `${JSON.stringify(next, null, 2)}\n`;
-	for (const target of await schemaWriteTargets(collection, workspaceRoot, safeSlug)) await require_atomic.writeFileAtomic(target, serialized);
+	for (const target of await schemaWriteTargets(collection, workspaceRoot, safeSlug)) await require_root.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
@@ -1306,6 +1322,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
@@ -1446,7 +1499,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;
@@ -1476,11 +1530,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 ?? require_discovery.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 : require_discovery.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) {
@@ -1747,9 +1823,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 = [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 renderSchemaDocs(await (0, node_fs_promises.readFile)(candidate, "utf-8"), topic);
+		return renderSchemaDocs(await (0, node_fs_promises.readFile)(candidate, "utf-8"), topic, variant);
 	} catch {}
 	return `manageCollection: could not read the collection-authoring reference (${SCHEMA_DOCS_FILE}).`;
 }
@@ -1760,16 +1837,25 @@ async function handleSchemaDocs(deps, topic) {
 async function handleGetSchema(slug, deps) {
 	const collection = await require_discovery.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)];
+	const { stagingDir } = authoringTarget(deps, collection.slug);
+	const candidates = [...stagingDir === null ? [] : [node_path.default.join(stagingDir, 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}.`;
 }
+/** 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: '${require_promptSafety.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: '${require_promptSafety.defangForPrompt(slug)}' is ${collection.source}-scope and read-only here — only project collections (${authoringDirLabel(deps, "<slug>")}) 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;
 }
@@ -1783,14 +1869,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 require_atomic.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]
-	});
+	const serialized = `${JSON.stringify(schema, null, 2)}\n`;
+	const { stagingDir } = authoringTarget(deps, slug);
+	if (stagingDir === null) await require_root.writeFileAtomic(node_path.default.join(skillDir, SCHEMA_FILE), serialized);
+	else {
+		await require_root.writeFileAtomic(node_path.default.join(stagingDir, SCHEMA_FILE), serialized);
+		require_skill_bridge_index.mirrorSkillWrite(base, {
+			slug,
+			relSegments: [SCHEMA_FILE]
+		});
+	}
 	try {
 		await deps.refreshAfterWrite?.();
 	} catch {}
@@ -1810,19 +1905,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 require_discovery.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 (!collection) return `manageCollection: unknown collection '${require_promptSafety.defangForPrompt(slug)}' — create it by writing SKILL.md + ${SCHEMA_FILE} under ${authoringDirLabel(deps, require_promptSafety.defangForPrompt(slug))}, then edit it here.`;
+	const refusal = schemaEditRefusal(collection, slug, deps);
 	if (refusal) return refusal;
 	const parsed = require_discovery.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
@@ -2160,4 +2255,4 @@ Object.defineProperty(exports, "validateRecordObject", {
 	}
 });
 
-//# sourceMappingURL=server-DOZFzx5l.cjs.map
+//# sourceMappingURL=server-WU35UYlF.cjs.map