mdkg 0.1.2 → 0.1.4

package/dist/commands/bundle.js

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const config_1 = require("../core/config");
 const capabilities_indexer_1 = require("../graph/capabilities_indexer");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const subgraphs_1 = require("../graph/subgraphs");
 const indexer_1 = require("../graph/indexer");
 const skills_indexer_1 = require("../graph/skills_indexer");
 const zip_1 = require("../util/zip");
@@ -386,11 +386,11 @@ function collectStringValues(value, out) {
         }
     }
 }
-function publicImportReferenceErrors(config, index, includedQids) {
-    const privateImportAliases = new Set(Object.entries(config.bundle_imports)
+function publicSubgraphReferenceErrors(config, index, includedQids) {
+    const privateSubgraphAliases = new Set(Object.entries(config.subgraphs)
         .filter(([, entry]) => entry.enabled && entry.visibility !== "public")
         .map(([alias]) => alias));
-    if (privateImportAliases.size === 0) {
+    if (privateSubgraphAliases.size === 0) {
         return [];
     }
     const errors = [];
@@ -404,8 +404,8 @@ function publicImportReferenceErrors(config, index, includedQids) {
         values.push(...node.links, ...node.artifacts, ...node.refs, ...node.aliases);
         for (const value of values) {
             const [alias] = value.split(":");
-            if (alias && privateImportAliases.has(alias)) {
-                errors.push(`${node.qid} references private bundle import ${value}`);
+            if (alias && privateSubgraphAliases.has(alias)) {
+                errors.push(`${node.qid} references private subgraph ${value}`);
             }
         }
     }
@@ -465,7 +465,7 @@ function buildBundle(options) {
     const filteredIndex = filterIndex(index, config, selectedSet, profile);
     if (profile === "public") {
         const includedQids = new Set(Object.keys(filteredIndex.nodes));
-        const mergedIndex = (0, bundle_imports_1.mergeBundleImportsIntoIndex)(index, (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config));
+        const mergedIndex = (0, subgraphs_1.mergeSubgraphsIntoIndex)(index, (0, subgraphs_1.buildSubgraphsIndex)(options.root, config));
         const errors = (0, visibility_1.visibilityViolationMessages)((0, visibility_1.collectVisibilityViolations)(mergedIndex, config, {
             includedQids,
             scope: "public",

package/dist/commands/capability.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCapabilityListCommand = runCapabilityListCommand;
 exports.runCapabilitySearchCommand = runCapabilitySearchCommand;
 exports.runCapabilityShowCommand = runCapabilityShowCommand;
+exports.runCapabilityResolveCommand = runCapabilityResolveCommand;
 const config_1 = require("../core/config");
 const capabilities_indexer_1 = require("../graph/capabilities_indexer");
 const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const subgraphs_1 = require("../graph/subgraphs");
 const errors_1 = require("../util/errors");
 function normalizeKind(value) {
     if (value === undefined) {
@@ -39,11 +40,11 @@ function loadRecords(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: capabilities index is stale; run mdkg index to refresh");
     }
-    const imported = (0, bundle_imports_1.buildImportedCapabilityRecords)(options.root, config);
-    for (const warning of imported.warnings) {
+    const subgraph = (0, subgraphs_1.buildSubgraphCapabilityRecords)(options.root, config);
+    for (const warning of subgraph.warnings) {
         console.error(`warning: ${warning}`);
     }
-    return [...index.records, ...imported.records];
+    return [...index.records, ...subgraph.records];
 }
 function applyFilters(records, options) {
     const kind = normalizeKind(options.kind);
@@ -95,6 +96,89 @@ function matchesQuery(record, query) {
     const text = capabilitySearchText(record);
     return terms.every((term) => text.includes(term));
 }
+function recordSource(record) {
+    const source = record.source;
+    return source ?? {};
+}
+function isStale(record) {
+    return recordSource(record).stale === true;
+}
+function hasReadPermission(record) {
+    const permissions = recordSource(record).permissions;
+    return !Array.isArray(permissions) || permissions.includes("read");
+}
+function requirementMatch(record, required) {
+    if (!required) {
+        return 0;
+    }
+    const normalized = required.toLowerCase();
+    const haystack = [
+        ...record.refs,
+        ...record.tags,
+        JSON.stringify(record.spec ?? {}),
+        JSON.stringify(record.work ?? {}),
+        JSON.stringify(record.skill ?? {}),
+    ]
+        .join(" ")
+        .toLowerCase();
+    return haystack.includes(normalized) ? 1 : 0;
+}
+function linkageScore(record) {
+    let score = 0;
+    if (record.kind === "work") {
+        score += 2;
+    }
+    if (record.kind === "spec") {
+        score += 1;
+    }
+    if (record.work || record.spec) {
+        score += 1;
+    }
+    return score;
+}
+function resolveScore(record, options) {
+    let score = 0;
+    if (record.workspace === "root") {
+        score += 1000;
+    }
+    if (!isStale(record)) {
+        score += 500;
+    }
+    if (hasReadPermission(record)) {
+        score += 100;
+    }
+    if (options.query && matchesQuery(record, options.query)) {
+        score += 50;
+    }
+    score += requirementMatch(record, options.requires) * 25;
+    score += linkageScore(record);
+    return score;
+}
+function resolveCapabilities(records, options) {
+    const filtered = records.filter((record) => {
+        if (options.freshOnly && isStale(record)) {
+            return false;
+        }
+        if (options.query && !matchesQuery(record, options.query)) {
+            return false;
+        }
+        if (options.requires && requirementMatch(record, options.requires) === 0) {
+            return false;
+        }
+        return true;
+    });
+    return filtered.sort((a, b) => {
+        const scoreDelta = resolveScore(b, options) - resolveScore(a, options);
+        if (scoreDelta !== 0) {
+            return scoreDelta;
+        }
+        const qidDelta = a.qid.localeCompare(b.qid);
+        if (qidDelta !== 0) {
+            return qidDelta;
+        }
+        return a.path.localeCompare(b.path);
+    });
+}
 function printCapabilityList(records, json, query) {
     if (json) {
         console.log(JSON.stringify({
@@ -160,3 +244,33 @@ function runCapabilityShowCommand(options) {
     const records = loadRecords(options);
     printCapability(resolveCapability(records, options.id), options.json);
 }
+function runCapabilityResolveCommand(options) {
+    const records = applyFilters(loadRecords(options), options);
+    const items = resolveCapabilities(records, options).map((record, rank) => ({
+        rank: rank + 1,
+        score: resolveScore(record, options),
+        stale: isStale(record),
+        item: record,
+    }));
+    if (options.json) {
+        console.log(JSON.stringify({
+            kind: "capability.resolve",
+            query: options.query,
+            requires: options.requires,
+            fresh_only: options.freshOnly === true,
+            count: items.length,
+            items,
+        }, null, 2));
+        return;
+    }
+    if (items.length === 0) {
+        console.log("no capabilities resolved");
+        return;
+    }
+    console.log(`resolved capabilities: ${items.length}`);
+    for (const result of items) {
+        const record = result.item;
+        const stale = result.stale ? " stale" : "";
+        console.log(`${result.rank}. ${record.qid} | score ${result.score}${stale} | ${record.kind} | ${record.title}`);
+    }
+}

package/dist/commands/checkpoint.js

@@ -13,6 +13,9 @@ const loader_1 = require("../templates/loader");
 const date_1 = require("../util/date");
 const errors_1 = require("../util/errors");
 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 event_support_1 = require("./event_support");
 function parseCsvList(raw) {
     if (!raw) {
@@ -38,6 +41,9 @@ function normalizeIdRef(value, key) {
     return normalized;
 }
 function nextCheckpointId(index, ws) {
+    return `chk-${maxCheckpointId(index, ws) + 1}`;
+}
+function maxCheckpointId(index, ws) {
     let max = 0;
     for (const node of Object.values(index.nodes)) {
         if (node.ws !== ws) {
@@ -52,7 +58,7 @@ function nextCheckpointId(index, ws) {
             max = parsed;
         }
     }
-    return `chk-${max + 1}`;
+    return max;
 }
 function slugifyTitle(title) {
     const slug = title
@@ -77,7 +83,7 @@ function normalizeWorkspace(value) {
     }
     return normalized;
 }
-function createCheckpoint(options) {
+function createCheckpointLocked(options) {
     const title = options.title.trim();
     if (!title) {
         throw new errors_1.UsageError("checkpoint title cannot be empty");
@@ -99,7 +105,15 @@ function createCheckpoint(options) {
         throw new errors_1.UsageError(`--priority must be between ${priorityMin} and ${priorityMax}`);
     }
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const id = nextCheckpointId(index, ws);
+    const id = (0, sqlite_index_1.isSqliteBackend)(config)
+        ? (0, sqlite_index_1.reserveSqliteNumericId)({
+            root: options.root,
+            config,
+            ws,
+            prefix: "chk",
+            currentMax: maxCheckpointId(index, ws),
+        }) ?? nextCheckpointId(index, ws)
+        : nextCheckpointId(index, ws);
     const slug = slugifyTitle(title);
     const fileName = `${id}-${slug}.md`;
     const wsEntry = config.workspaces[ws];
@@ -129,8 +143,16 @@ function createCheckpoint(options) {
         relates,
         scope,
     });
-    fs_1.default.mkdirSync(workDir, { 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(`checkpoint file already exists: ${path_1.default.relative(options.root, filePath)}`);
+        }
+        throw err;
+    }
     (0, event_support_1.appendAutomaticEvent)({
         root: options.root,
         ws,
@@ -148,6 +170,10 @@ function createCheckpoint(options) {
         path: path_1.default.relative(options.root, filePath),
     };
 }
+function createCheckpoint(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => createCheckpointLocked(options));
+}
 function runCheckpointNewCommand(options) {
     const checkpoint = createCheckpoint(options);
     if (options.json) {

package/dist/commands/doctor.js

@@ -9,35 +9,41 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
 const index_cache_1 = require("../graph/index_cache");
 const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const subgraphs_1 = require("../graph/subgraphs");
 const node_1 = require("../graph/node");
 const template_schema_1 = require("../graph/template_schema");
 const visibility_1 = require("../graph/visibility");
+const sqlite_index_1 = require("../graph/sqlite_index");
 const errors_1 = require("../util/errors");
-const REQUIRED_NODE_MAJOR = 18;
+const REQUIRED_NODE_MAJOR = 24;
+const REQUIRED_NODE_MINOR = 15;
 const ARCHIVE_RAW_ALLOWED_DIRS = new Set(["source"]);
-function parseNodeMajor(version) {
-    const major = Number.parseInt(version.split(".")[0] ?? "", 10);
-    if (!Number.isInteger(major)) {
+function parseNodeVersion(version) {
+    const [majorRaw, minorRaw, patchRaw] = version.split(".");
+    const major = Number.parseInt(majorRaw ?? "", 10);
+    const minor = Number.parseInt(minorRaw ?? "", 10);
+    const patch = Number.parseInt(patchRaw ?? "", 10);
+    if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch)) {
         return null;
     }
-    return major;
+    return { major, minor, patch };
 }
 function runNodeVersionCheck() {
     const nodeVersion = process.versions.node;
-    const major = parseNodeMajor(nodeVersion);
-    if (major === null) {
+    const parsed = parseNodeVersion(nodeVersion);
+    if (parsed === null) {
         return {
             name: "node-version",
             ok: false,
             detail: `unable to parse Node.js version: ${nodeVersion}`,
         };
     }
-    if (major < REQUIRED_NODE_MAJOR) {
+    if (parsed.major < REQUIRED_NODE_MAJOR ||
+        (parsed.major === REQUIRED_NODE_MAJOR && parsed.minor < REQUIRED_NODE_MINOR)) {
         return {
             name: "node-version",
             ok: false,
-            detail: `Node.js ${nodeVersion} is unsupported (requires >=${REQUIRED_NODE_MAJOR})`,
+            detail: `Node.js ${nodeVersion} is unsupported (requires >=${REQUIRED_NODE_MAJOR}.${REQUIRED_NODE_MINOR}.0)`,
         };
     }
     return {
@@ -46,6 +52,36 @@ function runNodeVersionCheck() {
         detail: `Node.js ${nodeVersion} (ok)`,
     };
 }
+function runSqliteCheck(root, config) {
+    if (!(0, sqlite_index_1.isSqliteBackend)(config)) {
+        return {
+            name: "sqlite-cache",
+            ok: true,
+            detail: "SQLite backend disabled; JSON cache backend active",
+        };
+    }
+    const health = (0, sqlite_index_1.sqliteHealth)(root, config);
+    if (health.errors.length > 0) {
+        return {
+            name: "sqlite-cache",
+            ok: false,
+            detail: health.errors.join("; "),
+        };
+    }
+    if (health.warnings.length > 0) {
+        return {
+            name: "sqlite-cache",
+            ok: true,
+            level: "warn",
+            detail: health.warnings.join("; "),
+        };
+    }
+    return {
+        name: "sqlite-cache",
+        ok: true,
+        detail: `.mdkg SQLite cache ok (${health.size} bytes)`,
+    };
+}
 function walkFiles(root) {
     if (!fs_1.default.existsSync(root)) {
         return [];
@@ -150,45 +186,45 @@ function runBundleStorageCheck(root, outputDir) {
         detail: `${bundles.length} bundle(s) found; run \`mdkg bundle verify <path>\` to check freshness before handoff`,
     };
 }
-function runBundleImportChecks(root, config) {
-    const projection = (0, bundle_imports_1.buildBundleImportsIndex)(root, config);
-    if (projection.index.imports.length === 0) {
+function runSubgraphChecks(root, config) {
+    const projection = (0, subgraphs_1.buildSubgraphsIndex)(root, config);
+    if (projection.index.subgraphs.length === 0) {
         return [
             {
-                name: "bundle-imports",
+                name: "subgraphs",
                 ok: true,
-                detail: "no bundle imports configured",
+                detail: "no subgraphs configured",
             },
         ];
     }
-    return projection.index.imports.map((item) => {
+    return projection.index.subgraphs.map((item) => {
         if (!item.enabled) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: true,
                 level: "warn",
-                detail: `disabled import at ${item.path}`,
+                detail: "disabled subgraph",
             };
         }
         if (item.error_count > 0) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: false,
                 detail: item.errors.join("; "),
             };
         }
         if (item.stale || item.warning_count > 0) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: true,
                 level: "warn",
-                detail: `import is stale or has warnings; run \`mdkg bundle import verify ${item.alias}\` (${item.warnings.join("; ")})`,
+                detail: `subgraph is stale or has warnings; run \`mdkg subgraph verify ${item.alias}\` (${item.warnings.join("; ")})`,
             };
         }
         return {
-            name: `bundle-import:${item.alias}`,
+            name: `subgraph:${item.alias}`,
             ok: true,
-            detail: `import loaded from ${item.path}`,
+            detail: `subgraph loaded from ${item.sources.map((source) => source.path).join(", ")}`,
         };
     });
 }
@@ -262,7 +298,8 @@ function runDoctorCommand(options) {
         results.push(runArchiveStorageCheck(options.root));
         results.push(runArchiveLargeCacheCheck(options.root, config.archive.large_cache_warning_bytes));
         results.push(runBundleStorageCheck(options.root, config.bundles.output_dir));
-        results.push(...runBundleImportChecks(options.root, config));
+        results.push(runSqliteCheck(options.root, config));
+        results.push(...runSubgraphChecks(options.root, config));
         results.push(runVisibilityPolicyCheck(options.root, config, options));
         try {
             const templateSchemaInfo = (0, template_schema_1.loadTemplateSchemasWithInfo)(options.root, config, node_1.ALLOWED_TYPES);

package/dist/commands/index.js

@@ -6,29 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runIndexCommand = runIndexCommand;
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
-const indexer_1 = require("../graph/indexer");
-const index_cache_1 = require("../graph/index_cache");
-const skills_index_cache_1 = require("../graph/skills_index_cache");
-const skills_indexer_1 = require("../graph/skills_indexer");
-const capabilities_indexer_1 = require("../graph/capabilities_indexer");
-const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const reindex_1 = require("../graph/reindex");
+const lock_1 = require("../util/lock");
 function runIndexCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
-    const nodeIndex = (0, indexer_1.buildIndex)(options.root, config, { tolerant: options.tolerant });
-    const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
-    const capabilitiesIndex = (0, capabilities_indexer_1.buildCapabilitiesIndex)(options.root, config, nodeIndex);
-    const importsIndex = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config);
-    const nodesOutputPath = path_1.default.resolve(options.root, config.index.global_index_path);
-    const skillsOutputPath = (0, skills_indexer_1.resolveSkillsIndexPath)(options.root);
-    const capabilitiesOutputPath = (0, capabilities_indexer_1.resolveCapabilitiesIndexPath)(options.root, config);
-    const importsOutputPath = (0, bundle_imports_1.resolveBundleImportsIndexPath)(options.root);
-    (0, index_cache_1.writeIndex)(nodesOutputPath, nodeIndex);
-    (0, skills_index_cache_1.writeSkillsIndex)(skillsOutputPath, skillsIndex);
-    (0, capabilities_index_cache_1.writeCapabilitiesIndex)(capabilitiesOutputPath, capabilitiesIndex);
-    (0, bundle_imports_1.writeBundleImportsIndex)(importsOutputPath, importsIndex.index);
-    console.log(`index written: ${path_1.default.relative(options.root, nodesOutputPath)}`);
-    console.log(`skills index written: ${path_1.default.relative(options.root, skillsOutputPath)}`);
-    console.log(`capabilities index written: ${path_1.default.relative(options.root, capabilitiesOutputPath)}`);
-    console.log(`bundle imports index written: ${path_1.default.relative(options.root, importsOutputPath)}`);
+    (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => {
+        const result = (0, reindex_1.writeDerivedIndexes)(options.root, config, undefined, { tolerant: options.tolerant });
+        console.log(`index written: ${path_1.default.relative(options.root, result.paths.nodes)}`);
+        console.log(`skills index written: ${path_1.default.relative(options.root, result.paths.skills)}`);
+        console.log(`capabilities index written: ${path_1.default.relative(options.root, result.paths.capabilities)}`);
+        console.log(`subgraphs index written: ${path_1.default.relative(options.root, result.paths.subgraphs)}`);
+        if (result.paths.sqlite) {
+            console.log(`sqlite index written: ${path_1.default.relative(options.root, result.paths.sqlite)}`);
+        }
+    });
 }

package/dist/commands/init.js

@@ -409,7 +409,13 @@ function runInitCommand(options) {
     try {
         if (shouldUpdateGitignore) {
             if (appendIgnoreEntries(path_1.default.join(root, ".gitignore"), [
-                ".mdkg/index/",
+                ".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/",
             ])) {

package/dist/commands/list.js

@@ -18,7 +18,7 @@ function normalizeWorkspace(value) {
 function runListCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
+    if (ws && !config.workspaces[ws] && !config.subgraphs[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedType = options.type?.toLowerCase();

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,7 +157,7 @@ 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");
@@ -181,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}`);
     }
@@ -317,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,
@@ -354,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

@@ -63,7 +63,7 @@ function runNextCommand(options) {
         }
         const node = index.nodes[resolved.qid];
         if (node.source?.imported) {
-            console.error("no local next item: imported bundle nodes are read-only planning context");
+            console.error("no local next item: subgraph nodes are read-only planning context");
             return;
         }
         const nextQid = node.edges.next;

package/dist/commands/node_card.js

@@ -8,7 +8,7 @@ function formatStatusPriority(node) {
 }
 function formatNodeCard(node) {
     const sourceLabel = node.source?.imported
-        ? ` | import:${node.source.import_alias}${node.source.stale ? ":stale" : ""} | read-only`
+        ? ` | subgraph:${node.source.subgraph_alias}${node.source.stale ? ":stale" : ""} | read-only`
         : "";
     return [
         node.qid,

package/dist/commands/pack.js

@@ -318,7 +318,7 @@ 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] && !config.bundle_imports[ws]) {
+    if (ws && !config.workspaces[ws] && !config.subgraphs[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({

package/dist/commands/search.js

@@ -54,7 +54,7 @@ function runSearchCommand(options) {
     }
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
+    if (ws && !config.workspaces[ws] && !config.subgraphs[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedType = options.type?.toLowerCase();

package/dist/commands/show.js

@@ -29,7 +29,7 @@ function formatAttributeLine(key, value) {
 function runShowCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
+    if (ws && !config.workspaces[ws] && !config.subgraphs[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedId = options.id.toLowerCase();