mdkg 0.1.2 → 0.1.4

package/dist/commands/subgraph.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSubgraphAddCommand = runSubgraphAddCommand;
+exports.runSubgraphListCommand = runSubgraphListCommand;
+exports.runSubgraphShowCommand = runSubgraphShowCommand;
+exports.runSubgraphRemoveCommand = runSubgraphRemoveCommand;
+exports.runSubgraphEnableCommand = runSubgraphEnableCommand;
+exports.runSubgraphDisableCommand = runSubgraphDisableCommand;
+exports.runSubgraphVerifyCommand = runSubgraphVerifyCommand;
+exports.runSubgraphRefreshCommand = runSubgraphRefreshCommand;
+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 workspace_path_1 = require("../core/workspace_path");
+const subgraphs_1 = require("../graph/subgraphs");
+const reindex_1 = require("../graph/reindex");
+const errors_1 = require("../util/errors");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
+const ALIAS_RE = /^[a-z][a-z0-9_]*$/;
+function writeJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function normalizeAlias(alias) {
+    if (alias === "all") {
+        throw new errors_1.UsageError("subgraph alias cannot be 'all'");
+    }
+    if (alias !== alias.toLowerCase() || !ALIAS_RE.test(alias)) {
+        throw new errors_1.UsageError("subgraph alias must be lowercase and use [a-z0-9_]");
+    }
+    return alias;
+}
+function normalizeVisibility(value) {
+    const normalized = (value ?? "private").toLowerCase();
+    if (normalized === "private" || normalized === "internal" || normalized === "public") {
+        return normalized;
+    }
+    throw new errors_1.UsageError("--visibility must be private, internal, or public");
+}
+function normalizeProfile(value) {
+    const normalized = (value ?? "private").toLowerCase();
+    if (normalized === "private" || normalized === "public") {
+        return normalized;
+    }
+    throw new errors_1.UsageError("--profile must be private or public");
+}
+function normalizeContained(value, label) {
+    try {
+        return (0, workspace_path_1.normalizeContainedWorkspacePath)(value, label);
+    }
+    catch (err) {
+        throw new errors_1.UsageError(err instanceof Error ? err.message : String(err));
+    }
+}
+function readRawConfig(root) {
+    const configPath = path_1.default.join(root, ".mdkg", "config.json");
+    if (!fs_1.default.existsSync(configPath)) {
+        throw new errors_1.NotFoundError(`config not found at ${configPath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch (err) {
+        throw new errors_1.UsageError(`failed to read config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const migrated = (0, migrate_1.migrateConfig)(parsed).config;
+    (0, config_1.validateConfigSchema)(migrated);
+    if (typeof migrated !== "object" || migrated === null || Array.isArray(migrated)) {
+        throw new errors_1.UsageError("config must be a JSON object");
+    }
+    return { configPath, raw: migrated };
+}
+function writeRawConfig(configPath, raw) {
+    (0, atomic_1.atomicWriteFile)(configPath, `${JSON.stringify(raw, null, 2)}\n`);
+}
+function getSubgraphs(raw) {
+    if (raw.bundle_imports !== undefined) {
+        throw new errors_1.UsageError("config uses legacy bundle_imports; run `mdkg upgrade --apply` before editing subgraphs");
+    }
+    const subgraphs = raw.subgraphs;
+    if (subgraphs === undefined) {
+        raw.subgraphs = {};
+        return raw.subgraphs;
+    }
+    if (typeof subgraphs !== "object" || subgraphs === null || Array.isArray(subgraphs)) {
+        throw new errors_1.UsageError("config.subgraphs must be an object");
+    }
+    return subgraphs;
+}
+function receiptForHealth(action, health) {
+    return {
+        action,
+        subgraph: health,
+    };
+}
+function healthByAlias(root, alias) {
+    const config = (0, config_1.loadConfig)(root);
+    const health = (0, subgraphs_1.buildSubgraphsIndex)(root, config).index.subgraphs.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`subgraph not found: ${alias}`);
+    }
+    return health;
+}
+function withSubgraphLock(root, fn) {
+    const config = (0, config_1.loadConfig)(root);
+    return (0, lock_1.withMutationLock)(root, config.index.lock_timeout_ms, fn);
+}
+function runSubgraphAddCommandLocked(options) {
+    const alias = normalizeAlias(options.alias);
+    const bundlePath = normalizeContained(options.bundlePath, "subgraph bundle path");
+    const visibility = normalizeVisibility(options.visibility);
+    const expected_profile = normalizeProfile(options.profile);
+    if (visibility !== "private" && expected_profile !== "public") {
+        throw new errors_1.UsageError("--profile public is required when --visibility is public or internal");
+    }
+    const source_path = options.sourcePath
+        ? normalizeContained(options.sourcePath, "subgraph source path")
+        : undefined;
+    if (options.maxStaleSeconds !== undefined && (!Number.isInteger(options.maxStaleSeconds) || options.maxStaleSeconds <= 0)) {
+        throw new errors_1.UsageError("--max-stale-seconds must be a positive integer");
+    }
+    const { configPath, raw } = readRawConfig(options.root);
+    const subgraphs = getSubgraphs(raw);
+    if (subgraphs[alias]) {
+        throw new errors_1.UsageError(`subgraph already exists: ${alias}`);
+    }
+    const workspaces = raw.workspaces;
+    if (workspaces && workspaces[alias]) {
+        throw new errors_1.UsageError(`subgraph alias collides with workspace: ${alias}`);
+    }
+    subgraphs[alias] = {
+        enabled: true,
+        visibility,
+        permissions: ["read"],
+        max_stale_seconds: options.maxStaleSeconds ?? 3600,
+        ...(source_path ? { source_path } : {}),
+        ...(options.sourceRepo ? { source_repo: options.sourceRepo } : {}),
+        sources: [
+            {
+                path: bundlePath,
+                enabled: true,
+                expected_profile,
+            },
+        ],
+    };
+    raw.subgraphs = subgraphs;
+    const validated = (0, config_1.validateConfigSchema)(raw);
+    const health = (0, subgraphs_1.buildSubgraphsIndex)(options.root, validated).index.subgraphs.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`subgraph not found after validation: ${alias}`);
+    }
+    if (health.error_count > 0) {
+        throw new errors_1.ValidationError(`subgraph ${alias} is invalid:\n${health.errors.join("\n")}`);
+    }
+    writeRawConfig(configPath, raw);
+    const receipt = receiptForHealth("added", health);
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`subgraph added: ${alias} (${bundlePath})`);
+    if (health.warning_count > 0) {
+        console.log(`warnings: ${health.warning_count}`);
+    }
+}
+function runSubgraphAddCommand(options) {
+    return withSubgraphLock(options.root, () => runSubgraphAddCommandLocked(options));
+}
+function runSubgraphListCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const subgraphs = (0, subgraphs_1.buildSubgraphsIndex)(options.root, config).index.subgraphs;
+    if (options.json) {
+        writeJson({ action: "list", count: subgraphs.length, subgraphs });
+        return;
+    }
+    if (subgraphs.length === 0) {
+        console.log("no subgraphs configured");
+        return;
+    }
+    for (const item of subgraphs) {
+        const status = item.enabled ? item.error_count > 0 ? "invalid" : item.stale ? "stale" : "ok" : "disabled";
+        const sourcePaths = item.sources.map((source) => source.path).join(",");
+        console.log(`${item.alias} | ${status} | ${item.visibility} | ${sourcePaths}`);
+    }
+}
+function runSubgraphShowCommand(options) {
+    const alias = normalizeAlias(options.alias);
+    const health = healthByAlias(options.root, alias);
+    if (options.json) {
+        writeJson(receiptForHealth("show", health));
+        return;
+    }
+    console.log(`${health.alias} | ${health.enabled ? "enabled" : "disabled"} | ${health.visibility}`);
+    console.log(`permissions: ${health.permissions.join(",")}`);
+    console.log(`max source count: ${health.sources.length}`);
+    for (const source of health.sources) {
+        const status = source.enabled ? source.error_count > 0 ? "invalid" : source.stale ? "stale" : "ok" : "disabled";
+        console.log(`source: ${source.path} | ${status} | ${source.expected_profile}`);
+    }
+}
+function runSubgraphRemoveCommandLocked(options) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const subgraphs = getSubgraphs(raw);
+    const existing = subgraphs[alias];
+    if (!existing) {
+        throw new errors_1.NotFoundError(`subgraph not found: ${alias}`);
+    }
+    delete subgraphs[alias];
+    raw.subgraphs = subgraphs;
+    (0, config_1.validateConfigSchema)(raw);
+    writeRawConfig(configPath, raw);
+    const receipt = { action: "removed", subgraph: { alias } };
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`subgraph removed: ${alias}`);
+}
+function runSubgraphRemoveCommand(options) {
+    return withSubgraphLock(options.root, () => runSubgraphRemoveCommandLocked(options));
+}
+function setSubgraphEnabledLocked(options, enabled) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const subgraphs = getSubgraphs(raw);
+    const existing = subgraphs[alias];
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+        throw new errors_1.NotFoundError(`subgraph not found: ${alias}`);
+    }
+    subgraphs[alias] = { ...existing, enabled };
+    raw.subgraphs = subgraphs;
+    (0, config_1.validateConfigSchema)(raw);
+    writeRawConfig(configPath, raw);
+    const health = healthByAlias(options.root, alias);
+    const receipt = receiptForHealth(enabled ? "enabled" : "disabled", health);
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`subgraph ${enabled ? "enabled" : "disabled"}: ${alias}`);
+}
+function runSubgraphEnableCommand(options) {
+    withSubgraphLock(options.root, () => setSubgraphEnabledLocked(options, true));
+}
+function runSubgraphDisableCommand(options) {
+    withSubgraphLock(options.root, () => setSubgraphEnabledLocked(options, false));
+}
+function selectHealth(items, alias, all) {
+    const includeAll = all || !alias;
+    const selected = items.filter((item) => includeAll ? true : item.alias === alias);
+    if (!includeAll && selected.length === 0) {
+        throw new errors_1.NotFoundError(`subgraph not found: ${alias}`);
+    }
+    return selected;
+}
+function runSubgraphVerifyCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const subgraphs = selectHealth((0, subgraphs_1.buildSubgraphsIndex)(options.root, config).index.subgraphs, options.alias, options.all);
+    const ok = subgraphs.every((item) => item.error_count === 0 && !item.stale);
+    const receipt = { action: "verified", ok, count: subgraphs.length, subgraphs };
+    if (options.json) {
+        writeJson(receipt);
+    }
+    else if (ok) {
+        console.log(`subgraphs verified: ${subgraphs.length}`);
+    }
+    else {
+        console.log(`subgraph verify failed: ${subgraphs.length}`);
+        for (const item of subgraphs) {
+            for (const warning of item.warnings) {
+                console.log(`warning: ${item.alias}: ${warning}`);
+            }
+            for (const error of item.errors) {
+                console.log(`error: ${item.alias}: ${error}`);
+            }
+        }
+    }
+    if (!ok) {
+        throw new errors_1.ValidationError("subgraph verify failed");
+    }
+}
+function runSubgraphRefreshCommand(options) {
+    withSubgraphLock(options.root, () => {
+        const config = (0, config_1.loadConfig)(options.root);
+        const result = (0, reindex_1.writeDerivedIndexes)(options.root, config);
+        const subgraphs = selectHealth((0, subgraphs_1.buildSubgraphsIndex)(options.root, config).index.subgraphs, options.alias, options.all);
+        const ok = subgraphs.every((item) => item.error_count === 0);
+        const receipt = {
+            action: "refreshed",
+            ok,
+            count: subgraphs.length,
+            paths: result.paths,
+            subgraphs,
+        };
+        if (options.json) {
+            writeJson(receipt);
+        }
+        else {
+            console.log(`subgraphs refreshed: ${subgraphs.length}`);
+            console.log(`index: ${path_1.default.relative(options.root, result.paths.subgraphs)}`);
+        }
+        if (!ok) {
+            throw new errors_1.ValidationError("subgraph refresh failed");
+        }
+    });
+}

package/dist/commands/task.js

@@ -11,12 +11,15 @@ 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 reindex_1 = require("../graph/reindex");
 const frontmatter_1 = require("../graph/frontmatter");
 const skills_indexer_1 = require("../graph/skills_indexer");
 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 event_support_1 = require("./event_support");
 const checkpoint_1 = require("./checkpoint");
 const MUTABLE_TASK_TYPES = new Set(["task", "bug", "test"]);
@@ -93,8 +96,7 @@ function maybeReindex(root, config) {
     if (!config.index.auto_reindex) {
         return;
     }
-    const outputPath = path_1.default.resolve(root, config.index.global_index_path);
-    (0, index_cache_1.writeIndex)(outputPath, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+    (0, reindex_1.writeDerivedIndexes)(root, config, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
 }
 function loadMutableTaskNode(root, idOrQid, wsHint) {
     const config = (0, config_1.loadConfig)(root);
@@ -108,7 +110,7 @@ function loadMutableTaskNode(root, idOrQid, wsHint) {
         throw new errors_1.NotFoundError(`task not found: ${idOrQid}`);
     }
     if (node.source?.imported) {
-        throw new errors_1.UsageError(`cannot mutate read-only imported node ${node.qid}; update the source workspace for bundle import ${node.source.import_alias}`);
+        throw new errors_1.UsageError(`cannot mutate read-only subgraph node ${node.qid}; update the source workspace for subgraph ${node.source.subgraph_alias}`);
     }
     if (!MUTABLE_TASK_TYPES.has(node.type)) {
         throw new errors_1.UsageError(`mdkg task only supports task, bug, and test nodes; use markdown editing for ${node.type}:${node.id}`);
@@ -132,7 +134,7 @@ function writeNodeFile(root, filePath, frontmatter, body) {
     const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter, frontmatter_1.DEFAULT_FRONTMATTER_KEY_ORDER);
     const frontmatterBlock = ["---", ...lines, "---"].join("\n");
     const content = body.length > 0 ? `${frontmatterBlock}\n${body}` : frontmatterBlock;
-    fs_1.default.writeFileSync(filePath, content, "utf8");
+    (0, atomic_1.atomicWriteFile)(filePath, content);
 }
 function ensureStatusAllowed(config, statusRaw, flag = "--status") {
     const normalized = statusRaw.trim().toLowerCase();
@@ -202,7 +204,7 @@ function printTaskMutationReceipt(action, root, loaded, json, checkpoint) {
     }
     console.log(`task ${action}: ${loaded.qid}`);
 }
-function runTaskStartCommand(options) {
+function runTaskStartCommandLocked(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
     const now = options.now ?? new Date();
     loaded.frontmatter.status = ensureStatusAllowed(loaded.config, "progress");
@@ -222,7 +224,7 @@ function runTaskStartCommand(options) {
     maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
     printTaskMutationReceipt("started", options.root, loaded, options.json);
 }
-function runTaskUpdateCommand(options) {
+function runTaskUpdateCommandLocked(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
     const now = options.now ?? new Date();
     if (options.status) {
@@ -264,7 +266,7 @@ function runTaskUpdateCommand(options) {
     });
     printTaskMutationReceipt("updated", options.root, loaded, options.json);
 }
-function runTaskDoneCommand(options) {
+function runTaskDoneCommandLocked(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
     const now = options.now ?? new Date();
     const nextLinks = appendUnique(toStringList(loaded.frontmatter.links), parseCsvList(options.addLinks));
@@ -316,3 +318,15 @@ function runTaskDoneCommand(options) {
     maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
     printTaskMutationReceipt("done", options.root, loaded, options.json, checkpoint);
 }
+function runTaskStartCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runTaskStartCommandLocked(options));
+}
+function runTaskUpdateCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runTaskUpdateCommandLocked(options));
+}
+function runTaskDoneCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runTaskDoneCommandLocked(options));
+}

package/dist/commands/upgrade.js

@@ -171,12 +171,57 @@ function planSeedFile(options) {
     });
     return false;
 }
+function migrateLegacyBundleImportsConfig(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return { config: input, changed: false };
+    }
+    const raw = { ...input };
+    if (raw.bundle_imports === undefined) {
+        if (raw.subgraphs === undefined) {
+            raw.subgraphs = {};
+            return { config: raw, changed: true };
+        }
+        return { config: raw, changed: false };
+    }
+    if (raw.subgraphs !== undefined) {
+        return { config: raw, changed: false };
+    }
+    const subgraphs = {};
+    const legacy = raw.bundle_imports;
+    if (legacy && typeof legacy === "object" && !Array.isArray(legacy)) {
+        for (const [alias, value] of Object.entries(legacy)) {
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                continue;
+            }
+            const entry = value;
+            subgraphs[alias] = {
+                enabled: entry.enabled ?? true,
+                visibility: entry.visibility ?? "private",
+                permissions: ["read"],
+                max_stale_seconds: entry.max_stale_seconds ?? 3600,
+                ...(entry.source_path ? { source_path: entry.source_path } : {}),
+                ...(entry.source_repo ? { source_repo: entry.source_repo } : {}),
+                sources: [
+                    {
+                        path: entry.path,
+                        enabled: true,
+                        expected_profile: entry.expected_profile ?? "private",
+                    },
+                ],
+            };
+        }
+    }
+    raw.subgraphs = subgraphs;
+    delete raw.bundle_imports;
+    return { config: raw, changed: true };
+}
 function migrateConfigIfNeeded(root, dryRun, summary, changes) {
     const cfgPath = (0, paths_1.configPath)(root);
     const raw = JSON.parse(fs_1.default.readFileSync(cfgPath, "utf8"));
     const migrated = (0, migrate_1.migrateConfig)(raw);
-    (0, config_1.validateConfigSchema)(migrated.config);
-    if (migrated.from === migrated.to) {
+    const nextConfig = migrateLegacyBundleImportsConfig(migrated.config);
+    (0, config_1.validateConfigSchema)(nextConfig.config);
+    if (migrated.from === migrated.to && !nextConfig.changed) {
         summary.unchanged += 1;
         return;
     }
@@ -184,10 +229,12 @@ function migrateConfigIfNeeded(root, dryRun, summary, changes) {
         path: ".mdkg/config.json",
         category: "config",
         action: "migrate",
-        reason: `config schema_version ${migrated.from} -> ${migrated.to}`,
+        reason: nextConfig.changed
+            ? `config subgraphs migration${migrated.from === migrated.to ? "" : ` and schema_version ${migrated.from} -> ${migrated.to}`}`
+            : `config schema_version ${migrated.from} -> ${migrated.to}`,
     });
     if (!dryRun) {
-        writeFile(cfgPath, `${JSON.stringify(migrated.config, null, 2)}\n`);
+        writeFile(cfgPath, `${JSON.stringify(nextConfig.config, null, 2)}\n`);
     }
 }
 function isIgnoredBySimpleGitignore(root, relativePath) {

package/dist/commands/validate.js

@@ -12,8 +12,9 @@ const node_1 = require("../graph/node");
 const skills_indexer_1 = require("../graph/skills_indexer");
 const workspace_files_1 = require("../graph/workspace_files");
 const validate_graph_1 = require("../graph/validate_graph");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const subgraphs_1 = require("../graph/subgraphs");
 const visibility_1 = require("../graph/visibility");
+const sqlite_index_1 = require("../graph/sqlite_index");
 const errors_1 = require("../util/errors");
 const skill_mirror_1 = require("./skill_mirror");
 const RECOMMENDED_HEADINGS = {
@@ -207,6 +208,11 @@ function runValidateCommand(options) {
     const filesByAlias = (0, workspace_files_1.listWorkspaceDocFilesByAlias)(options.root, config);
     const errors = [];
     const warnings = [];
+    if ((0, sqlite_index_1.isSqliteBackend)(config)) {
+        const health = (0, sqlite_index_1.sqliteHealth)(options.root, config);
+        warnings.push(...health.warnings);
+        errors.push(...health.errors);
+    }
     if (templateSchemaInfo.fallbackTypes.length > 0) {
         warnings.push(`using bundled template schema fallback for missing local type(s): ${templateSchemaInfo.fallbackTypes.join(", ")}; run \`mdkg upgrade --apply\` to vendor built-in templates`);
     }
@@ -270,16 +276,16 @@ function runValidateCommand(options) {
         nodes,
         reverse_edges: {},
     };
-    const importProjection = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config);
-    for (const item of importProjection.index.imports) {
+    const subgraphProjection = (0, subgraphs_1.buildSubgraphsIndex)(options.root, config);
+    for (const item of subgraphProjection.index.subgraphs) {
         for (const warning of item.warnings) {
-            warnings.push(`bundle import ${item.alias}: ${warning}`);
+            warnings.push(`subgraph ${item.alias}: ${warning}`);
         }
         for (const error of item.errors) {
-            errors.push(`bundle import ${item.alias}: ${error}`);
+            errors.push(`subgraph ${item.alias}: ${error}`);
         }
     }
-    const validationIndex = (0, bundle_imports_1.mergeBundleImportsIntoIndex)(index, importProjection);
+    const validationIndex = (0, subgraphs_1.mergeSubgraphsIntoIndex)(index, subgraphProjection);
     let knownSkills = new Set();
     try {
         const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);

package/dist/commands/work.js

@@ -15,12 +15,15 @@ const config_1 = require("../core/config");
 const frontmatter_1 = require("../graph/frontmatter");
 const indexer_1 = require("../graph/indexer");
 const index_cache_1 = require("../graph/index_cache");
+const reindex_1 = require("../graph/reindex");
 const agent_file_types_1 = require("../graph/agent_file_types");
 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 qid_1 = require("../util/qid");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
 const event_support_1 = require("./event_support");
 const archive_1 = require("./archive");
 const PRICING_MODELS = new Set(["free", "included", "quoted", "fixed", "metered", "subscription"]);
@@ -90,8 +93,7 @@ function maybeReindex(root, config) {
     if (!config.index.auto_reindex) {
         return;
     }
-    const outputPath = path_1.default.resolve(root, config.index.global_index_path);
-    (0, index_cache_1.writeIndex)(outputPath, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+    (0, reindex_1.writeDerivedIndexes)(root, config, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
 }
 function findNodeById(index, ws, id, type) {
     const node = index.nodes[`${ws}:${id}`];
@@ -123,7 +125,7 @@ function nodeReceipt(root, node) {
 function writeFrontmatterFile(filePath, frontmatter, body) {
     const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter, frontmatter_1.DEFAULT_FRONTMATTER_KEY_ORDER);
     const content = ["---", ...lines, "---", body.trimStart()].join("\n");
-    fs_1.default.writeFileSync(filePath, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+    (0, atomic_1.atomicWriteFile)(filePath, content.endsWith("\n") ? content : `${content}\n`);
 }
 function createAgentWorkflowNode(options) {
     const config = (0, config_1.loadConfig)(options.root);
@@ -149,8 +151,16 @@ function createAgentWorkflowNode(options) {
         updated: today,
         ...options.overrides,
     });
-    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;
+    }
     maybeReindex(options.root, config);
     (0, event_support_1.appendAutomaticEvent)({
         root: options.root,
@@ -180,7 +190,7 @@ function resolveWorkNode(index, idOrQid, ws, allowedTypes, label) {
         throw new errors_1.NotFoundError(`${label} not found: ${idOrQid}`);
     }
     if (node.source?.imported) {
-        throw new errors_1.UsageError(`cannot mutate read-only imported node ${node.qid}; update the source workspace for bundle import ${node.source.import_alias}`);
+        throw new errors_1.UsageError(`cannot mutate read-only subgraph node ${node.qid}; update the source workspace for subgraph ${node.source.subgraph_alias}`);
     }
     return node;
 }
@@ -200,7 +210,7 @@ function printReceipt(action, receipt, json) {
     }
     console.log(`work ${action}: ${receipt.qid} (${receipt.path})`);
 }
-function runWorkContractNewCommand(options) {
+function runWorkContractNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
@@ -226,7 +236,7 @@ function runWorkContractNewCommand(options) {
     });
     printReceipt("contract created", receipt, options.json);
 }
-function runWorkOrderNewCommand(options) {
+function runWorkOrderNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
@@ -255,7 +265,7 @@ function runWorkOrderNewCommand(options) {
     });
     printReceipt("order created", receipt, options.json);
 }
-function runWorkOrderUpdateCommand(options) {
+function runWorkOrderUpdateCommandLocked(options) {
     const loaded = loadMutableAgentNode(options.root, options.id, options.ws, "work_order");
     if (options.status) {
         loaded.frontmatter.order_status = normalizeEnum(options.status, "--status", ORDER_STATUSES);
@@ -267,7 +277,7 @@ function runWorkOrderUpdateCommand(options) {
     maybeReindex(options.root, loaded.config);
     printReceipt("order updated", nodeReceipt(options.root, loaded.node), options.json);
 }
-function runWorkReceiptNewCommand(options) {
+function runWorkReceiptNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
@@ -295,7 +305,7 @@ function runWorkReceiptNewCommand(options) {
     });
     printReceipt("receipt created", receipt, options.json);
 }
-function runWorkReceiptUpdateCommand(options) {
+function runWorkReceiptUpdateCommandLocked(options) {
     const loaded = loadMutableAgentNode(options.root, options.id, options.ws, "receipt");
     if (options.receiptStatus) {
         loaded.frontmatter.receipt_status = normalizeEnum(options.receiptStatus, "--receipt-status", RECEIPT_STATUSES);
@@ -308,7 +318,7 @@ function runWorkReceiptUpdateCommand(options) {
     maybeReindex(options.root, loaded.config);
     printReceipt("receipt updated", nodeReceipt(options.root, loaded.node), options.json);
 }
-function runWorkArtifactAddCommand(options) {
+function runWorkArtifactAddCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
@@ -363,3 +373,25 @@ function runWorkArtifactAddCommand(options) {
     }
     console.log(`work artifact registered: ${target.qid} -> ${archiveUri}`);
 }
+function withWorkLock(root, fn) {
+    const config = (0, config_1.loadConfig)(root);
+    return (0, lock_1.withMutationLock)(root, config.index.lock_timeout_ms, fn);
+}
+function runWorkContractNewCommand(options) {
+    return withWorkLock(options.root, () => runWorkContractNewCommandLocked(options));
+}
+function runWorkOrderNewCommand(options) {
+    return withWorkLock(options.root, () => runWorkOrderNewCommandLocked(options));
+}
+function runWorkOrderUpdateCommand(options) {
+    return withWorkLock(options.root, () => runWorkOrderUpdateCommandLocked(options));
+}
+function runWorkReceiptNewCommand(options) {
+    return withWorkLock(options.root, () => runWorkReceiptNewCommandLocked(options));
+}
+function runWorkReceiptUpdateCommand(options) {
+    return withWorkLock(options.root, () => runWorkReceiptUpdateCommandLocked(options));
+}
+function runWorkArtifactAddCommand(options) {
+    return withWorkLock(options.root, () => runWorkArtifactAddCommandLocked(options));
+}