mdkg 0.1.1 → 0.1.3

package/dist/commands/init.js

@@ -7,6 +7,7 @@ exports.runInitCommand = runInitCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
+const migrate_1 = require("../core/migrate");
 const errors_1 = require("../util/errors");
 const date_1 = require("../util/date");
 const version_1 = require("../core/version");
@@ -39,16 +40,28 @@ function listFiles(dir) {
     }
     return files;
 }
-function copySeedFile(src, dest, force, stats) {
+function displayPath(root, filePath) {
+    const relPath = path_1.default.relative(root, filePath).split(path_1.default.sep).join("/");
+    return relPath.length > 0 ? relPath : ".";
+}
+function recordCreated(root, dest, stats) {
+    stats.created += 1;
+    stats.createdPaths.push(displayPath(root, dest));
+}
+function recordSkipped(root, dest, stats) {
+    stats.skipped += 1;
+    stats.skippedPaths.push(displayPath(root, dest));
+}
+function copySeedFile(root, src, dest, force, stats) {
     if (fs_1.default.existsSync(dest) && !force) {
-        stats.skipped += 1;
+        recordSkipped(root, dest, stats);
         return;
     }
     fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
     fs_1.default.copyFileSync(src, dest);
-    stats.created += 1;
+    recordCreated(root, dest, stats);
 }
-function copySeedDir(srcDir, destDir, force, stats) {
+function copySeedDir(root, srcDir, destDir, force, stats) {
     if (!fs_1.default.existsSync(srcDir)) {
         return;
     }
@@ -56,7 +69,7 @@ function copySeedDir(srcDir, destDir, force, stats) {
     for (const filePath of files) {
         const relPath = path_1.default.relative(srcDir, filePath);
         const destPath = path_1.default.join(destDir, relPath);
-        copySeedFile(filePath, destPath, force, stats);
+        copySeedFile(root, filePath, destPath, force, stats);
     }
 }
 function appendIgnoreEntries(filePath, entries) {
@@ -73,14 +86,14 @@ function appendIgnoreEntries(filePath, entries) {
     fs_1.default.writeFileSync(filePath, updated, "utf8");
     return true;
 }
-function writeFileIfMissing(filePath, content, force, stats) {
+function writeFileIfMissing(root, filePath, content, force, stats) {
     if (fs_1.default.existsSync(filePath) && !force) {
-        stats.skipped += 1;
+        recordSkipped(root, filePath, stats);
         return;
     }
     fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
     fs_1.default.writeFileSync(filePath, content, "utf8");
-    stats.created += 1;
+    recordCreated(root, filePath, stats);
 }
 function soulTemplate(created) {
     return [
@@ -176,6 +189,48 @@ function seededInitEvent(nowIso) {
     };
     return `${JSON.stringify(event)}\n`;
 }
+function listSeedSkillSlugs(seedDefaultSkills) {
+    if (!fs_1.default.existsSync(seedDefaultSkills)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(seedDefaultSkills, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && fs_1.default.existsSync(path_1.default.join(seedDefaultSkills, entry.name, "SKILL.md")))
+        .map((entry) => entry.name.toLowerCase())
+        .sort();
+}
+function listExistingCanonicalSkillSlugs(root) {
+    const skillsDir = path_1.default.join(root, ".mdkg", "skills");
+    if (!fs_1.default.existsSync(skillsDir)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && fs_1.default.existsSync(path_1.default.join(skillsDir, entry.name, "SKILL.md")))
+        .map((entry) => entry.name.toLowerCase())
+        .sort();
+}
+function preflightSeedConfig(seedConfig) {
+    const raw = JSON.parse(fs_1.default.readFileSync(seedConfig, "utf8"));
+    (0, config_1.validateConfigSchema)((0, migrate_1.migrateConfig)(raw).config);
+}
+function emitPartialInitFailure(root, stats, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("mdkg init failed after partial writes");
+    console.error(`error: ${message}`);
+    console.error(`created: ${stats.created}`);
+    for (const created of stats.createdPaths) {
+        console.error(`  created: ${created}`);
+    }
+    console.error(`skipped: ${stats.skipped}`);
+    for (const skipped of stats.skippedPaths) {
+        console.error(`  skipped: ${skipped}`);
+    }
+    console.error("recovery:");
+    console.error("  inspect the created paths above");
+    console.error("  rerun `mdkg init --agent` after resolving the reported error");
+    console.error(`  root: ${root}`);
+}
 function parseCoreList(raw) {
     const lines = raw.split(/\r?\n/);
     const header = [];
@@ -224,9 +279,9 @@ function ensureCorePins(coreListPath, requiredPins) {
 function runInitCommand(options) {
     const root = path_1.default.resolve(options.root);
     const seedRoot = options.seedRoot ? path_1.default.resolve(options.seedRoot) : DEFAULT_SEED_SUBDIR;
-    const createAgents = Boolean(options.createAgents || options.createLlm);
-    const createClaude = Boolean(options.createClaude || options.createLlm);
-    const createStartupDocs = Boolean(options.createLlm || options.agent);
+    const createAgents = Boolean(options.agent);
+    const createClaude = Boolean(options.agent);
+    const createStartupDocs = Boolean(options.agent);
     const force = Boolean(options.force);
     const seedConfig = path_1.default.join(seedRoot, "config.json");
     const seedCore = path_1.default.join(seedRoot, "core");
@@ -238,7 +293,13 @@ function runInitCommand(options) {
     const seedCliMatrix = path_1.default.join(seedRoot, "CLI_COMMAND_MATRIX.md");
     const seedReadme = path_1.default.join(seedRoot, "README.md");
     const seedDefaultSkills = path_1.default.join(seedRoot, "skills", "default");
-    const seedManifest = (0, init_manifest_1.createInitManifest)(seedRoot, (0, version_1.readPackageVersion)());
+    const seedSoul = path_1.default.join(seedCore, "SOUL.md");
+    const seedHuman = path_1.default.join(seedCore, "HUMAN.md");
+    const seedManifest = (0, init_manifest_1.createInitManifest)(seedRoot, (0, version_1.readPackageVersion)(), {
+        includeAgentDocs: Boolean(options.agent),
+        includeStartupDocs: Boolean(options.agent),
+        includeDefaultSkills: Boolean(options.agent),
+    });
     if (!fs_1.default.existsSync(seedConfig) || !fs_1.default.existsSync(seedCore) || !fs_1.default.existsSync(seedTemplates)) {
         throw new errors_1.NotFoundError(`init assets not found at ${seedRoot} (try reinstalling mdkg)`);
     }
@@ -263,67 +324,137 @@ function runInitCommand(options) {
     if (options.agent && !fs_1.default.existsSync(seedDefaultSkills)) {
         throw new errors_1.NotFoundError(`init assets missing default skills at ${seedRoot}`);
     }
-    const mdkgDir = path_1.default.join(root, ".mdkg");
-    fs_1.default.mkdirSync(mdkgDir, { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(mdkgDir, "work"), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(mdkgDir, "design"), { recursive: true });
-    const stats = { created: 0, skipped: 0 };
-    copySeedFile(seedConfig, path_1.default.join(mdkgDir, "config.json"), force, stats);
-    copySeedFile(seedReadme, path_1.default.join(mdkgDir, "README.md"), force, stats);
-    copySeedDir(seedCore, path_1.default.join(mdkgDir, "core"), force, stats);
-    copySeedDir(seedTemplates, path_1.default.join(mdkgDir, "templates"), force, stats);
-    if (createAgents) {
-        copySeedFile(seedAgents, path_1.default.join(root, "AGENTS.md"), force, stats);
-    }
-    if (createClaude) {
-        copySeedFile(seedClaude, path_1.default.join(root, "CLAUDE.md"), force, stats);
+    preflightSeedConfig(seedConfig);
+    if (options.agent) {
+        (0, skill_mirror_1.preflightSkillMirrorTargets)({
+            root,
+            slugs: [...listSeedSkillSlugs(seedDefaultSkills), ...listExistingCanonicalSkillSlugs(root)],
+            force,
+        });
     }
-    if (createStartupDocs) {
-        copySeedFile(seedLlms, path_1.default.join(root, "llms.txt"), force, stats);
-        copySeedFile(seedAgentStart, path_1.default.join(root, "AGENT_START.md"), force, stats);
-        copySeedFile(seedCliMatrix, path_1.default.join(root, "CLI_COMMAND_MATRIX.md"), force, stats);
+    const stats = {
+        created: 0,
+        skipped: 0,
+        createdPaths: [],
+        skippedPaths: [],
+        ignoreFilesUpdated: [],
+        manifestWritten: false,
+        registryRefreshed: false,
+        mirrorTargets: 0,
+        mirroredSkills: 0,
+    };
+    const mdkgDir = path_1.default.join(root, ".mdkg");
+    try {
+        fs_1.default.mkdirSync(mdkgDir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(mdkgDir, "work"), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(mdkgDir, "design"), { recursive: true });
+        copySeedFile(root, seedConfig, path_1.default.join(mdkgDir, "config.json"), force, stats);
+        copySeedFile(root, seedReadme, path_1.default.join(mdkgDir, "README.md"), force, stats);
+        copySeedDir(root, seedCore, path_1.default.join(mdkgDir, "core"), force, stats);
+        copySeedDir(root, seedTemplates, path_1.default.join(mdkgDir, "templates"), force, stats);
+        if (createAgents) {
+            copySeedFile(root, seedAgents, path_1.default.join(root, "AGENTS.md"), force, stats);
+        }
+        if (createClaude) {
+            copySeedFile(root, seedClaude, path_1.default.join(root, "CLAUDE.md"), force, stats);
+        }
+        if (createStartupDocs) {
+            copySeedFile(root, seedLlms, path_1.default.join(root, "llms.txt"), force, stats);
+            copySeedFile(root, seedAgentStart, path_1.default.join(root, "AGENT_START.md"), force, stats);
+            copySeedFile(root, seedCliMatrix, path_1.default.join(root, "CLI_COMMAND_MATRIX.md"), force, stats);
+        }
+        if (options.agent) {
+            const today = (0, date_1.formatDate)(new Date());
+            const soulPath = path_1.default.join(mdkgDir, "core", "SOUL.md");
+            const humanPath = path_1.default.join(mdkgDir, "core", "HUMAN.md");
+            const skillsDir = path_1.default.join(mdkgDir, "skills");
+            const registryPath = path_1.default.join(skillsDir, "registry.md");
+            const eventsDir = path_1.default.join(mdkgDir, "work", "events");
+            const eventsPath = path_1.default.join(eventsDir, "events.jsonl");
+            fs_1.default.mkdirSync(skillsDir, { recursive: true });
+            fs_1.default.mkdirSync(eventsDir, { recursive: true });
+            copySeedDir(root, seedDefaultSkills, skillsDir, force, stats);
+            if (!fs_1.default.existsSync(seedSoul)) {
+                writeFileIfMissing(root, soulPath, soulTemplate(today), force, stats);
+            }
+            if (!fs_1.default.existsSync(seedHuman)) {
+                writeFileIfMissing(root, humanPath, humanTemplate(today), force, stats);
+            }
+            writeFileIfMissing(root, registryPath, (0, skill_support_1.registryTemplate)(), force, stats);
+            if (!fs_1.default.existsSync(eventsPath) || force) {
+                writeFileIfMissing(root, eventsPath, seededInitEvent(new Date().toISOString()), force, stats);
+            }
+            const coreListPath = path_1.default.join(mdkgDir, "core", "core.md");
+            ensureCorePins(coreListPath, [SOUL_PIN_ID, HUMAN_PIN_ID]);
+            (0, skill_mirror_1.scaffoldMirrorRoots)(root);
+            const config = (0, config_1.loadConfig)(root);
+            (0, skill_support_1.refreshSkillsRegistry)(root, config);
+            stats.registryRefreshed = true;
+            const mirrorResult = (0, skill_mirror_1.syncSkillMirrors)({ root, config, createRoots: true, force });
+            stats.mirrorTargets = mirrorResult.targets;
+            stats.mirroredSkills = mirrorResult.synced;
+        }
+        (0, init_manifest_1.writeInitManifest)(path_1.default.join(mdkgDir, init_manifest_1.INIT_MANIFEST_FILE), seedManifest);
+        stats.manifestWritten = true;
     }
-    if (options.agent) {
-        const today = (0, date_1.formatDate)(new Date());
-        const soulPath = path_1.default.join(mdkgDir, "core", "SOUL.md");
-        const humanPath = path_1.default.join(mdkgDir, "core", "HUMAN.md");
-        const skillsDir = path_1.default.join(mdkgDir, "skills");
-        const registryPath = path_1.default.join(skillsDir, "registry.md");
-        const eventsDir = path_1.default.join(mdkgDir, "work", "events");
-        const eventsPath = path_1.default.join(eventsDir, "events.jsonl");
-        fs_1.default.mkdirSync(skillsDir, { recursive: true });
-        fs_1.default.mkdirSync(eventsDir, { recursive: true });
-        copySeedDir(seedDefaultSkills, skillsDir, force, stats);
-        writeFileIfMissing(soulPath, soulTemplate(today), force, stats);
-        writeFileIfMissing(humanPath, humanTemplate(today), force, stats);
-        writeFileIfMissing(registryPath, (0, skill_support_1.registryTemplate)(), force, stats);
-        if (!fs_1.default.existsSync(eventsPath) || force) {
-            writeFileIfMissing(eventsPath, seededInitEvent(new Date().toISOString()), force, stats);
+    catch (err) {
+        if (stats.created > 0 || stats.skipped > 0) {
+            emitPartialInitFailure(root, stats, err);
         }
-        const coreListPath = path_1.default.join(mdkgDir, "core", "core.md");
-        ensureCorePins(coreListPath, [SOUL_PIN_ID, HUMAN_PIN_ID]);
-        (0, skill_mirror_1.scaffoldMirrorRoots)(root);
-        const config = (0, config_1.loadConfig)(root);
-        (0, skill_support_1.refreshSkillsRegistry)(root, config);
-        (0, skill_mirror_1.syncSkillMirrors)({ root, config, createRoots: true, force });
+        throw err;
     }
-    (0, init_manifest_1.writeInitManifest)(path_1.default.join(mdkgDir, init_manifest_1.INIT_MANIFEST_FILE), seedManifest);
     const noUpdateIgnores = Boolean(options.noUpdateIgnores);
     const shouldUpdateGitignore = Boolean(options.updateGitignore || !noUpdateIgnores);
     const shouldUpdateNpmignore = Boolean(options.updateNpmignore || !noUpdateIgnores);
-    if (shouldUpdateGitignore) {
-        appendIgnoreEntries(path_1.default.join(root, ".gitignore"), [
-            ".mdkg/index/",
-            ".mdkg/pack/",
-        ]);
-    }
-    if (shouldUpdateNpmignore) {
-        appendIgnoreEntries(path_1.default.join(root, ".npmignore"), [".mdkg/", ".mdkg/index/", ".mdkg/pack/"]);
+    try {
+        if (shouldUpdateGitignore) {
+            if (appendIgnoreEntries(path_1.default.join(root, ".gitignore"), [
+                ".mdkg/index/*.json",
+                ".mdkg/index/*.tmp",
+                ".mdkg/index/*.lock",
+                ".mdkg/index/write.lock/",
+                ".mdkg/index/*.sqlite-wal",
+                ".mdkg/index/*.sqlite-shm",
+                ".mdkg/index/*.sqlite-journal",
+                ".mdkg/pack/",
+                ".mdkg/archive/**/source/",
+            ])) {
+                stats.ignoreFilesUpdated.push(".gitignore");
+            }
+        }
+        if (shouldUpdateNpmignore) {
+            if (appendIgnoreEntries(path_1.default.join(root, ".npmignore"), [".mdkg/", ".mdkg/index/", ".mdkg/pack/"])) {
+                stats.ignoreFilesUpdated.push(".npmignore");
+            }
+        }
+        if (options.updateDockerignore) {
+            if (appendIgnoreEntries(path_1.default.join(root, ".dockerignore"), [".mdkg/"])) {
+                stats.ignoreFilesUpdated.push(".dockerignore");
+            }
+        }
     }
-    if (options.updateDockerignore) {
-        appendIgnoreEntries(path_1.default.join(root, ".dockerignore"), [".mdkg/"]);
+    catch (err) {
+        if (stats.created > 0 || stats.skipped > 0) {
+            emitPartialInitFailure(root, stats, err);
+        }
+        throw err;
     }
     console.log(`mdkg init complete: ${stats.created} file(s) created, ${stats.skipped} skipped`);
+    if (stats.manifestWritten) {
+        console.log("managed manifest: .mdkg/init-manifest.json");
+    }
+    if (stats.ignoreFilesUpdated.length > 0) {
+        console.log(`ignore files updated: ${stats.ignoreFilesUpdated.join(", ")}`);
+    }
+    if (options.agent) {
+        console.log("agent bootstrap: AGENT_START.md, AGENTS.md, CLAUDE.md, llms.txt, CLI_COMMAND_MATRIX.md");
+        console.log("agent core pins: rule-soul, rule-human");
+        console.log("agent event log: .mdkg/work/events/events.jsonl");
+        console.log(`skill mirrors: ${stats.mirroredSkills} sync operation(s) across ${stats.mirrorTargets} target(s)`);
+        if (stats.registryRefreshed) {
+            console.log("skill registry: .mdkg/skills/registry.md");
+        }
+    }
     console.log("next:");
     if (createStartupDocs) {
         console.log("  read AGENT_START.md");

package/dist/commands/init_manifest.js

@@ -83,19 +83,32 @@ function seedSourcePath(seedRoot, file) {
     }
     return path_1.default.join(seedRoot, file.path);
 }
-function createInitManifest(seedRoot, mdkgVersion) {
+function createInitManifest(seedRoot, mdkgVersion, options = {
+    includeAgentDocs: true,
+    includeStartupDocs: true,
+    includeDefaultSkills: true,
+}) {
+    const includeAgentDocs = Boolean(options.includeAgentDocs);
+    const includeStartupDocs = Boolean(options.includeStartupDocs);
+    const includeDefaultSkills = Boolean(options.includeDefaultSkills);
     const files = [];
     addSeedFile(files, seedRoot, "config.json", ".mdkg/config.json", "config");
     addSeedFile(files, seedRoot, "README.md", ".mdkg/README.md", "mdkg_doc");
     addSeedDir(files, seedRoot, "core", ".mdkg/core", "core");
     addSeedDir(files, seedRoot, "templates", ".mdkg/templates", "template");
-    for (const doc of AGENT_DOCS) {
-        addSeedFile(files, seedRoot, doc, doc, "agent_doc");
+    if (includeAgentDocs) {
+        for (const doc of AGENT_DOCS) {
+            addSeedFile(files, seedRoot, doc, doc, "agent_doc");
+        }
+    }
+    if (includeStartupDocs) {
+        for (const doc of STARTUP_DOCS) {
+            addSeedFile(files, seedRoot, doc, doc, "startup_doc");
+        }
     }
-    for (const doc of STARTUP_DOCS) {
-        addSeedFile(files, seedRoot, doc, doc, "startup_doc");
+    if (includeDefaultSkills) {
+        addSeedDir(files, seedRoot, path_1.default.join("skills", "default"), ".mdkg/skills", "default_skill");
     }
-    addSeedDir(files, seedRoot, path_1.default.join("skills", "default"), ".mdkg/skills", "default_skill");
     return {
         schema_version: exports.INIT_MANIFEST_SCHEMA_VERSION,
         tool: "mdkg",

package/dist/commands/list.js

@@ -18,14 +18,14 @@ function normalizeWorkspace(value) {
 function runListCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedType = options.type?.toLowerCase();
     if (normalizedType === "skill") {
         throw new errors_1.UsageError("--type skill is no longer supported here; use `mdkg skill list`");
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -34,6 +34,9 @@ function runListCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     let epicQid;
     if (options.epic) {
         const resolved = (0, qid_1.resolveQid)(index, options.epic, ws);

package/dist/commands/new.js

@@ -16,6 +16,10 @@ const date_1 = require("../util/date");
 const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
 const id_1 = require("../util/id");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
+const sqlite_index_1 = require("../graph/sqlite_index");
+const reindex_1 = require("../graph/reindex");
 const event_support_1 = require("./event_support");
 const DEC_ID_RE = /^dec-[0-9]+$/;
 const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
@@ -97,6 +101,9 @@ function slugifyTitle(title) {
     return slug.length > maxLen ? slug.slice(0, maxLen).replace(/-+$/g, "") : slug;
 }
 function nextIdForPrefix(index, ws, prefix) {
+    return `${prefix}-${maxIdForPrefix(index, ws, prefix) + 1}`;
+}
+function maxIdForPrefix(index, ws, prefix) {
     let max = 0;
     const pattern = new RegExp(`^${prefix}-(\\d+)$`);
     for (const node of Object.values(index)) {
@@ -112,7 +119,7 @@ function nextIdForPrefix(index, ws, prefix) {
             max = parsed;
         }
     }
-    return `${prefix}-${max + 1}`;
+    return max;
 }
 function idPrefixForType(type) {
     if (type === "checkpoint") {
@@ -150,12 +157,15 @@ function ensureExists(index, value, ws, label) {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, value, resolved, ws));
     }
 }
-function runNewCommand(options) {
+function runNewCommandLocked(options) {
     const title = options.title.trim();
     if (!title) {
         throw new errors_1.UsageError("title cannot be empty");
     }
     const type = options.type.toLowerCase();
+    if (type === "archive") {
+        throw new errors_1.UsageError("use `mdkg archive add <file>` to create archive sidecars");
+    }
     if (!node_1.ALLOWED_TYPES.has(type)) {
         throw new errors_1.UsageError(`type must be one of ${Array.from(node_1.ALLOWED_TYPES).join(", ")}`);
     }
@@ -178,7 +188,15 @@ function runNewCommand(options) {
     const prefix = idPrefixForType(type);
     const id = options.id !== undefined
         ? normalizeAgentFileId(options.id)
-        : nextIdForPrefix(index.nodes, ws, prefix);
+        : (0, sqlite_index_1.isSqliteBackend)(config)
+            ? (0, sqlite_index_1.reserveSqliteNumericId)({
+                root: options.root,
+                config,
+                ws,
+                prefix,
+                currentMax: maxIdForPrefix(index.nodes, ws, prefix),
+            }) ?? nextIdForPrefix(index.nodes, ws, prefix)
+            : nextIdForPrefix(index.nodes, ws, prefix);
     if (index.nodes[`${ws}:${id}`]) {
         throw new errors_1.UsageError(`node already exists: ${ws}:${id}`);
     }
@@ -314,12 +332,19 @@ function runNewCommand(options) {
         created: today,
         updated: today,
     });
-    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
-    fs_1.default.writeFileSync(filePath, content, "utf8");
+    try {
+        (0, atomic_1.writeFileExclusive)(filePath, content);
+    }
+    catch (err) {
+        const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+        if (code === "EEXIST") {
+            throw new errors_1.UsageError(`node already exists: ${path_1.default.relative(options.root, filePath)}`);
+        }
+        throw err;
+    }
     if (config.index.auto_reindex && !noReindex) {
         const updatedIndex = (0, indexer_1.buildIndex)(options.root, config, { tolerant: config.index.tolerant });
-        const outputPath = path_1.default.resolve(options.root, config.index.global_index_path);
-        (0, index_cache_1.writeIndex)(outputPath, updatedIndex);
+        (0, reindex_1.writeDerivedIndexes)(options.root, config, updatedIndex);
     }
     (0, event_support_1.appendAutomaticEvent)({
         root: options.root,
@@ -351,3 +376,7 @@ function runNewCommand(options) {
     }
     console.log(`node created: ${receipt.qid} (${receipt.path})`);
 }
+function runNewCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runNewCommandLocked(options));
+}

package/dist/commands/next.js

@@ -21,6 +21,9 @@ function selectNextByPriority(index, ws, statusPreference, priorityMax) {
         if (ws && node.ws !== ws) {
             return false;
         }
+        if (node.source?.imported) {
+            return false;
+        }
         if (!NEXT_TYPES.has(node.type)) {
             return false;
         }
@@ -59,6 +62,10 @@ function runNextCommand(options) {
             throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
         }
         const node = index.nodes[resolved.qid];
+        if (node.source?.imported) {
+            console.error("no local next item: imported bundle nodes are read-only planning context");
+            return;
+        }
         const nextQid = node.edges.next;
         if (nextQid && index.nodes[nextQid]) {
             console.log((0, node_card_1.formatNodeCard)(index.nodes[nextQid]));

package/dist/commands/node_card.js

@@ -7,11 +7,14 @@ function formatStatusPriority(node) {
     return `${status}/${priority}`;
 }
 function formatNodeCard(node) {
+    const sourceLabel = node.source?.imported
+        ? ` | import:${node.source.import_alias}${node.source.stale ? ":stale" : ""} | read-only`
+        : "";
     return [
         node.qid,
         node.type,
         formatStatusPriority(node),
         node.title,
         node.path,
-    ].join(" | ");
+    ].join(" | ") + sourceLabel;
 }

package/dist/commands/pack.js

@@ -11,6 +11,7 @@ const index_cache_1 = require("../graph/index_cache");
 const frontmatter_1 = require("../graph/frontmatter");
 const skills_index_cache_1 = require("../graph/skills_index_cache");
 const node_1 = require("../graph/node");
+const visibility_1 = require("../graph/visibility");
 const budget_1 = require("../pack/budget");
 const export_json_1 = require("../pack/export_json");
 const export_md_1 = require("../pack/export_md");
@@ -217,6 +218,53 @@ function applyNodeCountLimit(pack, maxNodes) {
         nodes: included,
     };
 }
+function packNodeVisibility(node, index, config) {
+    const indexNode = index.nodes[node.qid];
+    if (indexNode) {
+        return (0, visibility_1.effectiveNodeVisibility)(indexNode, config);
+    }
+    return (0, visibility_1.normalizeVisibility)(config.workspaces[node.workspace]?.visibility, "workspace visibility");
+}
+function applyVisibilityFilter(pack, index, config, scope) {
+    if (scope === "private") {
+        return {
+            ...pack,
+            meta: {
+                ...pack.meta,
+                visibility: scope,
+            },
+        };
+    }
+    const includedNodes = pack.nodes.filter((node) => (0, visibility_1.isVisibleAt)(packNodeVisibility(node, index, config), scope));
+    if (includedNodes.length === 0 || includedNodes[0].qid !== pack.nodes[0]?.qid) {
+        throw new errors_1.ValidationError(`pack root ${pack.meta.root} is not visible at ${scope}`);
+    }
+    const includedQids = new Set(includedNodes.map((node) => node.qid));
+    const graphIncludedQids = new Set(includedNodes.filter((node) => Boolean(index.nodes[node.qid])).map((node) => node.qid));
+    const violations = (0, visibility_1.collectVisibilityViolations)(index, config, {
+        includedQids: graphIncludedQids,
+        scope,
+    });
+    if (violations.length > 0) {
+        throw new errors_1.ValidationError(`${scope} pack contains less-visible references:\n${(0, visibility_1.visibilityViolationMessages)(violations).join("\n")}`);
+    }
+    const dropped = pack.nodes
+        .filter((node) => !includedQids.has(node.qid))
+        .map((node) => node.qid);
+    return {
+        ...pack,
+        meta: {
+            ...pack.meta,
+            visibility: scope,
+            node_count: includedNodes.length,
+            truncated: {
+                ...pack.meta.truncated,
+                dropped: [...pack.meta.truncated.dropped, ...dropped],
+            },
+        },
+        nodes: includedNodes,
+    };
+}
 function writeJsonFile(outPath, payload) {
     fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
     fs_1.default.writeFileSync(outPath, JSON.stringify(payload, null, 2), "utf8");
@@ -243,6 +291,9 @@ function printDryRunSummary(pack, stats, format) {
     console.log(`root: ${pack.meta.root}`);
     console.log(`profile: ${pack.meta.profile ?? "standard"}`);
     console.log(`body_mode: ${pack.meta.body_mode ?? "full"}`);
+    if (pack.meta.visibility) {
+        console.log(`visibility: ${pack.meta.visibility}`);
+    }
     console.log(`format: ${format}`);
     console.log(`nodes: ${pack.nodes.length}`);
     if (pack.meta.latest_checkpoint_qid) {
@@ -267,10 +318,10 @@ function printDryRunSummary(pack, stats, format) {
 function runPackCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -279,6 +330,9 @@ function runPackCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
     if (resolved.status !== "ok") {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
@@ -291,6 +345,9 @@ function runPackCommand(options) {
     const edges = normalizeEdges([...config.pack.default_edges, ...extraEdges]);
     const skillsPolicy = resolveSkillsPolicy(options.skills);
     const skillsDepth = resolveSkillsDepth(options.skillsDepth);
+    const visibility = options.visibility
+        ? (0, visibility_1.normalizeVisibility)(options.visibility)
+        : undefined;
     let resolvedProfile;
     try {
         resolvedProfile = (0, profile_1.resolvePackProfile)({
@@ -350,6 +407,9 @@ function runPackCommand(options) {
         packWithSkills = appendSkillsToPack(packWithSkills, selectedEntries, skillsDepth, options.root);
         packWithSkills = applyNodeCountLimit(packWithSkills, config.pack.limits.max_nodes);
     }
+    if (visibility) {
+        packWithSkills = applyVisibilityFilter(packWithSkills, index, config, visibility);
+    }
     const templateHeadingMap = resolvedProfile.bodyMode === "summary"
         ? (0, headings_1.loadTemplateHeadingMap)(options.root, config, Array.from(node_1.ALLOWED_TYPES))
         : {};

package/dist/commands/query_output.js

@@ -36,6 +36,7 @@ function toNodeSummaryJson(node) {
             blocked_by: [...node.edges.blocked_by],
             blocks: [...node.edges.blocks],
         },
+        ...(node.source ? { source: node.source } : {}),
     };
 }
 function toNodeDetailJson(node, body) {