mdkg 0.1.6 → 0.1.8

package/dist/commands/init.js

@@ -11,6 +11,7 @@ const migrate_1 = require("../core/migrate");
 const errors_1 = require("../util/errors");
 const date_1 = require("../util/date");
 const version_1 = require("../core/version");
+const project_db_1 = require("../core/project_db");
 const init_manifest_1 = require("./init_manifest");
 const skill_support_1 = require("./skill_support");
 const skill_mirror_1 = require("./skill_mirror");
@@ -416,8 +417,10 @@ function runInitCommand(options) {
                 ".mdkg/index/*.sqlite-wal",
                 ".mdkg/index/*.sqlite-shm",
                 ".mdkg/index/*.sqlite-journal",
+                ...project_db_1.PROJECT_DB_GITIGNORE_ENTRIES,
                 ".mdkg/state/",
                 ".mdkg/pack/",
+                ".mdkg/subgraphs/",
                 ".mdkg/archive/**/source/",
             ])) {
                 stats.ignoreFilesUpdated.push(".gitignore");

package/dist/commands/new.js

@@ -16,6 +16,7 @@ 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 refs_1 = require("../util/refs");
 const atomic_1 = require("../util/atomic");
 const lock_1 = require("../util/lock");
 const sqlite_index_1 = require("../graph/sqlite_index");
@@ -44,7 +45,7 @@ function normalizeId(value, key) {
 }
 function normalizeIdRef(value, key) {
     const normalized = value.toLowerCase();
-    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
+    if (!(0, id_1.isPortableIdRef)(normalized)) {
         throw new errors_1.UsageError(`${key} entries must match <id> or <ws>:<id>: ${value}`);
     }
     return normalized;
@@ -65,6 +66,16 @@ function normalizeLowercaseList(raw) {
 function normalizeIdList(raw, key) {
     return parseCsvList(raw).map((value) => normalizeId(value, key));
 }
+function normalizeRef(value, key) {
+    const normalized = value.includes("://") ? value : value.toLowerCase();
+    if (!(0, refs_1.validatePortableOrUriRef)(normalized)) {
+        throw new errors_1.UsageError(`${key} entries must be portable ids, qids, or URI refs: ${value}`);
+    }
+    return normalized;
+}
+function normalizeRefList(raw, key) {
+    return parseCsvList(raw).map((value) => normalizeRef(value, key));
+}
 function normalizeIdRefList(raw, key) {
     return parseCsvList(raw).map((value) => normalizeIdRef(value, key));
 }
@@ -156,6 +167,10 @@ function ensureExists(index, value, ws, label) {
     if (resolved.status !== "ok") {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, value, resolved, ws));
     }
+    const node = index.nodes[resolved.qid];
+    if (["epic", "parent", "prev", "next"].includes(label) && node?.source?.imported) {
+        throw new errors_1.UsageError(`${label} cannot target read-only subgraph node ${node.qid}`);
+    }
 }
 function runNewCommandLocked(options) {
     const title = options.title.trim();
@@ -259,7 +274,7 @@ function runNewCommandLocked(options) {
     const relates = normalizeIdRefList(options.relates, "--relates");
     const blockedBy = normalizeIdRefList(options.blockedBy, "--blocked-by");
     const blocks = normalizeIdRefList(options.blocks, "--blocks");
-    const refs = normalizeIdList(options.refs, "--refs");
+    const refs = normalizeRefList(options.refs, "--refs");
     const aliases = normalizeLowercaseList(options.aliases);
     const tags = normalizeLowercaseList(options.tags);
     const owners = normalizeLowercaseList(options.owners);

package/dist/commands/subgraph.js

@@ -11,8 +11,11 @@ exports.runSubgraphEnableCommand = runSubgraphEnableCommand;
 exports.runSubgraphDisableCommand = runSubgraphDisableCommand;
 exports.runSubgraphVerifyCommand = runSubgraphVerifyCommand;
 exports.runSubgraphRefreshCommand = runSubgraphRefreshCommand;
+exports.runSubgraphSyncCommand = runSubgraphSyncCommand;
+exports.runSubgraphMaterializeCommand = runSubgraphMaterializeCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
 const config_1 = require("../core/config");
 const migrate_1 = require("../core/migrate");
 const workspace_path_1 = require("../core/workspace_path");
@@ -21,6 +24,7 @@ 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 bundle_1 = require("./bundle");
 const ALIAS_RE = /^[a-z][a-z0-9_]*$/;
 function writeJson(value) {
     console.log(JSON.stringify(value, null, 2));
@@ -56,6 +60,25 @@ function normalizeContained(value, label) {
         throw new errors_1.UsageError(err instanceof Error ? err.message : String(err));
     }
 }
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function relativeToRoot(root, filePath) {
+    return toPosixPath(path_1.default.relative(root, filePath));
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPackageVersion() {
+    const packagePath = path_1.default.resolve(__dirname, "..", "..", "package.json");
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(packagePath, "utf8"));
+        return typeof raw.version === "string" ? raw.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 function readRawConfig(root) {
     const configPath = path_1.default.join(root, ".mdkg", "config.json");
     if (!fs_1.default.existsSync(configPath)) {
@@ -106,6 +129,19 @@ function healthByAlias(root, alias) {
     }
     return health;
 }
+function selectAliases(config, alias, all) {
+    if (alias && all) {
+        throw new errors_1.UsageError("choose either an alias or --all, not both");
+    }
+    if (alias) {
+        const normalized = normalizeAlias(alias);
+        if (!config.subgraphs[normalized]) {
+            throw new errors_1.NotFoundError(`subgraph not found: ${normalized}`);
+        }
+        return [normalized];
+    }
+    return Object.keys(config.subgraphs).sort();
+}
 function withSubgraphLock(root, fn) {
     const config = (0, config_1.loadConfig)(root);
     return (0, lock_1.withMutationLock)(root, config.index.lock_timeout_ms, fn);
@@ -310,3 +346,383 @@ function runSubgraphRefreshCommand(options) {
         }
     });
 }
+function gitRun(cwd, args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+    return {
+        ok: result.status === 0,
+        stdout: result.stdout.replace(/\r?\n$/, ""),
+        stderr: result.stderr.trim(),
+    };
+}
+function sameRealPath(a, b) {
+    try {
+        return fs_1.default.realpathSync(a) === fs_1.default.realpathSync(b);
+    }
+    catch {
+        return path_1.default.resolve(a) === path_1.default.resolve(b);
+    }
+}
+function isPathWithin(parent, child) {
+    const relative = path_1.default.relative(path_1.default.resolve(parent), path_1.default.resolve(child));
+    return relative === "" || (!relative.startsWith("..") && !path_1.default.isAbsolute(relative));
+}
+function inspectSourcePath(root, alias, subgraph, allowDirty) {
+    if (!subgraph.source_path) {
+        throw new errors_1.UsageError(`subgraph ${alias} is missing source_path`);
+    }
+    const sourcePath = normalizeContained(subgraph.source_path, `subgraphs.${alias}.source_path`);
+    const sourceRoot = path_1.default.resolve(root, sourcePath);
+    if (!fs_1.default.existsSync(sourceRoot) || !fs_1.default.statSync(sourceRoot).isDirectory()) {
+        throw new errors_1.NotFoundError(`subgraph ${alias} source_path does not exist: ${sourcePath}`);
+    }
+    const gitTop = gitRun(sourceRoot, ["rev-parse", "--show-toplevel"]);
+    const gitTopPath = gitTop.stdout.trim();
+    if (!gitTop.ok || !gitTopPath) {
+        throw new errors_1.UsageError(`subgraph ${alias} source_path is not a Git repo: ${sourcePath}`);
+    }
+    if (!sameRealPath(gitTopPath, sourceRoot)) {
+        throw new errors_1.UsageError(`subgraph ${alias} source_path must be the child Git repo root: ${sourcePath}`);
+    }
+    const mdkgDir = path_1.default.join(sourceRoot, ".mdkg");
+    if (!fs_1.default.existsSync(mdkgDir) || !fs_1.default.statSync(mdkgDir).isDirectory()) {
+        throw new errors_1.NotFoundError(`subgraph ${alias} source_path is missing .mdkg: ${sourcePath}`);
+    }
+    const head = gitRun(sourceRoot, ["rev-parse", "HEAD"]);
+    const headValue = head.stdout.trim();
+    if (!head.ok || !headValue) {
+        throw new errors_1.UsageError(`subgraph ${alias} source Git HEAD could not be read`);
+    }
+    const branchResult = gitRun(sourceRoot, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branchValue = branchResult.stdout.trim();
+    const branch = branchResult.ok && branchValue && branchValue !== "HEAD"
+        ? branchValue
+        : "detached";
+    const status = gitRun(sourceRoot, ["status", "--porcelain", "--untracked-files=no"]);
+    if (!status.ok) {
+        throw new errors_1.UsageError(`subgraph ${alias} tracked dirty state could not be read`);
+    }
+    const dirtyTrackedPaths = status.stdout
+        ? status.stdout.split(/\r?\n/).map((line) => line.slice(3)).filter(Boolean).sort()
+        : [];
+    if (dirtyTrackedPaths.length > 0 && !allowDirty) {
+        throw new errors_1.UsageError(`subgraph ${alias} source_path has dirty tracked changes: ${dirtyTrackedPaths.join(", ")}`);
+    }
+    return {
+        sourceRoot,
+        branch,
+        head: headValue,
+        sourceRepo: `${branch}@${headValue}`,
+        dirtyTracked: dirtyTrackedPaths.length > 0,
+        dirtyTrackedPaths,
+    };
+}
+function existingBundleHash(bundlePath) {
+    if (!fs_1.default.existsSync(bundlePath)) {
+        return undefined;
+    }
+    try {
+        return (0, bundle_1.parseBundle)(bundlePath).manifest.bundle_hash;
+    }
+    catch {
+        return undefined;
+    }
+}
+function enabledSources(subgraph) {
+    return subgraph.sources.filter((source) => source.enabled);
+}
+function syncOneAlias(options) {
+    const warnings = [];
+    const errors = [];
+    const sources = [];
+    const receipt = {
+        alias: options.alias,
+        enabled: options.subgraph.enabled,
+        dry_run: options.dryRun,
+        source_path: options.subgraph.source_path,
+        old_source_repo: options.subgraph.source_repo,
+        updated: false,
+        skipped: false,
+        warnings,
+        errors,
+        sources,
+    };
+    if (!options.subgraph.enabled) {
+        receipt.skipped = true;
+        warnings.push("subgraph is disabled");
+        return receipt;
+    }
+    let gitState;
+    try {
+        gitState = inspectSourcePath(options.root, options.alias, options.subgraph, options.allowDirty);
+        receipt.new_source_repo = gitState.sourceRepo;
+        receipt.source_git_head = gitState.head;
+        receipt.dirty_tracked = gitState.dirtyTracked;
+        receipt.dirty_tracked_paths = gitState.dirtyTrackedPaths;
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+        return receipt;
+    }
+    const activeSources = enabledSources(options.subgraph);
+    if (activeSources.length === 0) {
+        errors.push(`subgraph ${options.alias} has no enabled sources`);
+        return receipt;
+    }
+    const planned = [];
+    for (const source of activeSources) {
+        const outputPath = path_1.default.resolve(options.root, source.path);
+        const sourceReceipt = {
+            label: source.label,
+            path: source.path,
+            enabled: source.enabled,
+            expected_profile: source.expected_profile,
+            old_bundle_hash: existingBundleHash(outputPath),
+            old_zip_sha256: fs_1.default.existsSync(outputPath) ? (0, bundle_1.sha256Buffer)(fs_1.default.readFileSync(outputPath)) : undefined,
+            warnings: [],
+            errors: [],
+        };
+        sources.push(sourceReceipt);
+        if (isPathWithin(gitState.sourceRoot, outputPath)) {
+            sourceReceipt.errors.push(`bundle path must be root-owned and outside source_path: ${source.path}`);
+            errors.push(`source ${source.path}: ${sourceReceipt.errors[sourceReceipt.errors.length - 1]}`);
+            continue;
+        }
+        try {
+            const built = (0, bundle_1.buildBundle)({
+                root: gitState.sourceRoot,
+                profile: source.expected_profile,
+                output: outputPath,
+            });
+            sourceReceipt.new_bundle_hash = built.manifest.bundle_hash;
+            sourceReceipt.new_zip_sha256 = built.zipSha256;
+            planned.push({
+                source,
+                outputPath,
+                zip: built.zip,
+                newBundleHash: built.manifest.bundle_hash,
+                newZipSha256: built.zipSha256,
+            });
+        }
+        catch (err) {
+            sourceReceipt.errors.push(err instanceof Error ? err.message : String(err));
+            errors.push(`source ${source.path}: ${sourceReceipt.errors[sourceReceipt.errors.length - 1]}`);
+        }
+    }
+    if (errors.length > 0) {
+        return receipt;
+    }
+    if (options.dryRun) {
+        receipt.skipped = true;
+        return receipt;
+    }
+    for (const item of planned) {
+        const sourceReceipt = sources.find((source) => source.path === item.source.path);
+        try {
+            (0, atomic_1.atomicWriteFile)(item.outputPath, item.zip);
+            const verify = (0, bundle_1.verifyBundle)(gitState.sourceRoot, item.outputPath);
+            sourceReceipt.verified = verify.ok;
+            if (!verify.ok) {
+                sourceReceipt.errors.push(...verify.errors, ...verify.stale_paths.map((stale) => `stale: ${stale}`));
+                errors.push(`source ${item.source.path}: bundle verify failed`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sourceReceipt.errors.push(message);
+            errors.push(`source ${item.source.path}: ${message}`);
+        }
+    }
+    if (errors.length === 0) {
+        const raw = options.rawSubgraphs[options.alias];
+        if (isObject(raw)) {
+            options.rawSubgraphs[options.alias] = { ...raw, source_repo: gitState.sourceRepo };
+        }
+        receipt.updated = true;
+    }
+    return receipt;
+}
+function runSubgraphSyncCommand(options) {
+    const dryRun = Boolean(options.dryRun);
+    const allowDirty = Boolean(options.allowDirty);
+    withSubgraphLock(options.root, () => {
+        const config = (0, config_1.loadConfig)(options.root);
+        const aliases = selectAliases(config, options.alias, options.all);
+        const { configPath, raw } = readRawConfig(options.root);
+        const rawSubgraphs = getSubgraphs(raw);
+        const results = aliases.map((alias) => syncOneAlias({
+            root: options.root,
+            alias,
+            subgraph: config.subgraphs[alias],
+            rawSubgraphs,
+            dryRun,
+            allowDirty,
+        }));
+        const ok = results.every((item) => item.errors.length === 0);
+        let indexPaths;
+        if (!dryRun && results.some((item) => item.updated)) {
+            raw.subgraphs = rawSubgraphs;
+            (0, config_1.validateConfigSchema)(raw);
+            writeRawConfig(configPath, raw);
+            indexPaths = (0, reindex_1.writeDerivedIndexes)(options.root, (0, config_1.loadConfig)(options.root)).paths;
+        }
+        const receipt = {
+            action: dryRun ? "sync_dry_run" : "synced",
+            ok,
+            count: results.length,
+            updated: results.filter((item) => item.updated).map((item) => item.alias),
+            skipped: results.filter((item) => item.skipped).map((item) => item.alias),
+            errors: results.flatMap((item) => item.errors.map((error) => `${item.alias}: ${error}`)),
+            warnings: results.flatMap((item) => item.warnings.map((warning) => `${item.alias}: ${warning}`)),
+            ...(indexPaths ? { paths: indexPaths } : {}),
+            subgraphs: results,
+        };
+        if (options.json) {
+            writeJson(receipt);
+        }
+        else {
+            console.log(`${dryRun ? "subgraph sync dry-run" : "subgraphs synced"}: ${results.length}`);
+            for (const item of results) {
+                const status = item.errors.length > 0 ? "error" : item.updated ? "updated" : item.skipped ? "skipped" : "ok";
+                console.log(`${item.alias} | ${status} | ${item.new_source_repo ?? item.old_source_repo ?? "unknown"}`);
+            }
+        }
+        if (!ok) {
+            throw new errors_1.ValidationError("subgraph sync failed");
+        }
+    });
+}
+function safeZipEntryPath(entryName) {
+    const normalized = entryName.replace(/\\/g, "/");
+    const parts = normalized.split("/");
+    if (path_1.default.isAbsolute(normalized) || parts.some((part) => part === "..") || parts.some((part) => part.length === 0)) {
+        throw new errors_1.ValidationError(`unsafe bundle entry path: ${entryName}`);
+    }
+    return normalized;
+}
+function writeMaterializeGitignore(targetRoot) {
+    const gitignorePath = path_1.default.join(targetRoot, ".gitignore");
+    const required = ["*", "!.gitignore"];
+    const existing = fs_1.default.existsSync(gitignorePath)
+        ? fs_1.default.readFileSync(gitignorePath, "utf8").split(/\r?\n/)
+        : [];
+    const lines = existing.filter((line) => line.length > 0);
+    for (const line of required) {
+        if (!lines.includes(line)) {
+            lines.push(line);
+        }
+    }
+    (0, atomic_1.atomicWriteFile)(gitignorePath, `${lines.join("\n")}\n`);
+}
+function materializeOneAlias(options) {
+    const enabled = enabledSources(options.subgraph);
+    const errors = [];
+    const warnings = [];
+    const outputDir = path_1.default.join(options.targetRoot, options.alias);
+    if (enabled.length !== 1) {
+        errors.push(`materialize requires exactly one enabled source for ${options.alias}; found ${enabled.length}`);
+        return { alias: options.alias, ok: false, output_path: relativeToRoot(options.root, outputDir), warnings, errors };
+    }
+    const source = enabled[0];
+    const bundlePath = path_1.default.resolve(options.root, source.path);
+    if (!fs_1.default.existsSync(bundlePath)) {
+        errors.push(`bundle not found: ${source.path}`);
+        return { alias: options.alias, ok: false, output_path: relativeToRoot(options.root, outputDir), warnings, errors };
+    }
+    if (fs_1.default.existsSync(outputDir)) {
+        const marker = path_1.default.join(outputDir, ".mdkg-materialized.json");
+        if (!options.clean) {
+            errors.push(`materialized directory already exists: ${relativeToRoot(options.root, outputDir)}; use --clean`);
+            return { alias: options.alias, ok: false, output_path: relativeToRoot(options.root, outputDir), warnings, errors };
+        }
+        if (!fs_1.default.existsSync(marker)) {
+            errors.push(`refusing to clean non-materialized directory: ${relativeToRoot(options.root, outputDir)}`);
+            return { alias: options.alias, ok: false, output_path: relativeToRoot(options.root, outputDir), warnings, errors };
+        }
+    }
+    const tempDir = path_1.default.join(options.targetRoot, `.${options.alias}.${process.pid}.${Date.now()}.tmp`);
+    fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    try {
+        const parsed = (0, bundle_1.parseBundle)(bundlePath);
+        fs_1.default.mkdirSync(tempDir, { recursive: true });
+        for (const [entryName, data] of parsed.entries.entries()) {
+            const safeName = safeZipEntryPath(entryName);
+            const target = path_1.default.join(tempDir, safeName);
+            fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+            fs_1.default.writeFileSync(target, data);
+        }
+        const marker = {
+            tool: "mdkg",
+            kind: "subgraph_materialization",
+            alias: options.alias,
+            bundle_path: source.path,
+            bundle_hash: parsed.manifest.bundle_hash,
+            zip_sha256: (0, bundle_1.sha256Buffer)(fs_1.default.readFileSync(bundlePath)),
+            profile: parsed.manifest.profile,
+            source_repo: options.subgraph.source_repo ?? parsed.manifest.source.repo,
+            source_git_head: parsed.manifest.source.git_head,
+            generated_at: new Date().toISOString(),
+            mdkg_version: readPackageVersion(),
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, ".mdkg-materialized.json"), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+        if (fs_1.default.existsSync(outputDir)) {
+            fs_1.default.rmSync(outputDir, { recursive: true, force: true });
+        }
+        fs_1.default.mkdirSync(path_1.default.dirname(outputDir), { recursive: true });
+        fs_1.default.renameSync(tempDir, outputDir);
+        return {
+            alias: options.alias,
+            ok: true,
+            output_path: relativeToRoot(options.root, outputDir),
+            bundle_path: source.path,
+            bundle_hash: parsed.manifest.bundle_hash,
+            profile: parsed.manifest.profile,
+            warnings,
+            errors,
+        };
+    }
+    catch (err) {
+        fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        errors.push(err instanceof Error ? err.message : String(err));
+        return { alias: options.alias, ok: false, output_path: relativeToRoot(options.root, outputDir), warnings, errors };
+    }
+}
+function runSubgraphMaterializeCommand(options) {
+    withSubgraphLock(options.root, () => {
+        const config = (0, config_1.loadConfig)(options.root);
+        const aliases = selectAliases(config, options.alias, options.all);
+        const targetRoot = path_1.default.resolve(options.root, normalizeContained(options.target, "--target"));
+        const results = aliases.map((alias) => materializeOneAlias({
+            root: options.root,
+            alias,
+            subgraph: config.subgraphs[alias],
+            targetRoot,
+            clean: Boolean(options.clean),
+        }));
+        if (options.gitignore) {
+            fs_1.default.mkdirSync(targetRoot, { recursive: true });
+            writeMaterializeGitignore(targetRoot);
+        }
+        const ok = results.every((item) => item.ok === true);
+        const receipt = {
+            action: "materialized",
+            ok,
+            count: results.length,
+            target: relativeToRoot(options.root, targetRoot),
+            results,
+            errors: results.flatMap((item) => (item.errors ?? []).map((error) => `${item.alias}: ${error}`)),
+            warnings: results.flatMap((item) => (item.warnings ?? []).map((warning) => `${item.alias}: ${warning}`)),
+        };
+        if (options.json) {
+            writeJson(receipt);
+        }
+        else {
+            console.log(`subgraphs materialized: ${results.length}`);
+            for (const item of results) {
+                console.log(`${item.alias} | ${item.ok ? "ok" : "error"} | ${item.output_path}`);
+            }
+        }
+        if (!ok) {
+            throw new errors_1.ValidationError("subgraph materialize failed");
+        }
+    });
+}

package/dist/commands/upgrade.js

@@ -11,6 +11,7 @@ const migrate_1 = require("../core/migrate");
 const config_1 = require("../core/config");
 const paths_1 = require("../core/paths");
 const version_1 = require("../core/version");
+const project_db_1 = require("../core/project_db");
 const errors_1 = require("../util/errors");
 const init_manifest_1 = require("./init_manifest");
 const skill_support_1 = require("./skill_support");
@@ -18,7 +19,12 @@ const skill_mirror_1 = require("./skill_mirror");
 const DEFAULT_SEED_SUBDIR = path_1.default.resolve(__dirname, "..", "init");
 const PROTECTED_CORE_DOCS = new Set([".mdkg/core/SOUL.md", ".mdkg/core/HUMAN.md"]);
 const CREATE_ONLY_PRESERVED = new Set([".mdkg/core/core.md"]);
-const LOCAL_STATE_IGNORE_ENTRIES = [".mdkg/state/", ".mdkg/archive/**/source/"];
+const LOCAL_STATE_IGNORE_ENTRIES = [
+    ".mdkg/state/",
+    ".mdkg/subgraphs/",
+    ".mdkg/archive/**/source/",
+    ...project_db_1.PROJECT_DB_GITIGNORE_ENTRIES,
+];
 function seededInitEvent(nowIso) {
     const event = {
         ts: nowIso,
@@ -215,23 +221,53 @@ function migrateLegacyBundleImportsConfig(input) {
     delete raw.bundle_imports;
     return { config: raw, changed: true };
 }
+function migrateProjectDbConfig(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return { config: input, changed: false };
+    }
+    const raw = { ...input };
+    if (raw.db !== undefined) {
+        return { config: raw, changed: false };
+    }
+    raw.db = {
+        enabled: false,
+        schema_version: project_db_1.PROJECT_DB_CONFIG_SCHEMA_VERSION,
+        root_path: project_db_1.PROJECT_DB_RELATIVE_DIR,
+        schema_path: project_db_1.PROJECT_DB_SCHEMA_DIR,
+        migrations_path: project_db_1.PROJECT_DB_MIGRATIONS_DIR,
+        runtime_path: project_db_1.PROJECT_DB_RUNTIME_FILE,
+        state_path: project_db_1.PROJECT_DB_STATE_FILE,
+        receipts_path: project_db_1.PROJECT_DB_RECEIPTS_DIR,
+        migration_table: project_db_1.PROJECT_DB_MIGRATION_TABLE,
+    };
+    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);
-    const nextConfig = migrateLegacyBundleImportsConfig(migrated.config);
+    const bundleConfig = migrateLegacyBundleImportsConfig(migrated.config);
+    const nextConfig = migrateProjectDbConfig(bundleConfig.config);
     (0, config_1.validateConfigSchema)(nextConfig.config);
-    if (migrated.from === migrated.to && !nextConfig.changed) {
+    if (migrated.from === migrated.to && !bundleConfig.changed && !nextConfig.changed) {
         summary.unchanged += 1;
         return;
     }
+    const reasons = [];
+    if (bundleConfig.changed) {
+        reasons.push("config subgraphs migration");
+    }
+    if (nextConfig.changed) {
+        reasons.push("project db config defaults");
+    }
+    if (migrated.from !== migrated.to) {
+        reasons.push(`schema_version ${migrated.from} -> ${migrated.to}`);
+    }
     record(summary, changes, {
         path: ".mdkg/config.json",
         category: "config",
         action: "migrate",
-        reason: nextConfig.changed
-            ? `config subgraphs migration${migrated.from === migrated.to ? "" : ` and schema_version ${migrated.from} -> ${migrated.to}`}`
-            : `config schema_version ${migrated.from} -> ${migrated.to}`,
+        reason: reasons.join(" and "),
     });
     if (!dryRun) {
         writeFile(cfgPath, `${JSON.stringify(nextConfig.config, null, 2)}\n`);
@@ -316,7 +352,7 @@ function ensureArchiveIgnorePolicy(root, dryRun, summary, changes) {
         path: ".gitignore",
         category: "ignore_policy",
         action: fs_1.default.existsSync(ignorePath) ? "update" : "create",
-        reason: "ignore local mdkg state and raw archive source copies while keeping authored graph records commit-eligible",
+        reason: "ignore local mdkg state, project DB runtime files, and raw archive source copies while keeping authored graph records commit-eligible",
     });
     if (!dryRun) {
         const suffix = raw.length === 0 || raw.endsWith("\n") ? "" : "\n";