mdkg 0.1.0 → 0.1.2

package/dist/commands/bundle_import.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBundleImportAddCommand = runBundleImportAddCommand;
+exports.runBundleImportListCommand = runBundleImportListCommand;
+exports.runBundleImportRemoveCommand = runBundleImportRemoveCommand;
+exports.runBundleImportEnableCommand = runBundleImportEnableCommand;
+exports.runBundleImportDisableCommand = runBundleImportDisableCommand;
+exports.runBundleImportVerifyCommand = runBundleImportVerifyCommand;
+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 bundle_imports_1 = require("../graph/bundle_imports");
+const errors_1 = require("../util/errors");
+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("bundle import alias cannot be 'all'");
+    }
+    if (alias !== alias.toLowerCase() || !ALIAS_RE.test(alias)) {
+        throw new errors_1.UsageError("bundle import 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) {
+    fs_1.default.writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf8");
+}
+function getImports(raw) {
+    const imports = raw.bundle_imports;
+    if (imports === undefined) {
+        raw.bundle_imports = {};
+        return raw.bundle_imports;
+    }
+    if (typeof imports !== "object" || imports === null || Array.isArray(imports)) {
+        throw new errors_1.UsageError("config.bundle_imports must be an object");
+    }
+    return imports;
+}
+function receiptForHealth(action, health) {
+    return {
+        action,
+        import: health,
+    };
+}
+function healthByAlias(root, alias) {
+    const config = (0, config_1.loadConfig)(root);
+    const health = (0, bundle_imports_1.buildBundleImportsIndex)(root, config).index.imports.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    return health;
+}
+function runBundleImportAddCommand(options) {
+    const alias = normalizeAlias(options.alias);
+    const bundlePath = normalizeContained(options.bundlePath, "bundle import 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, "bundle import 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 imports = getImports(raw);
+    if (imports[alias]) {
+        throw new errors_1.UsageError(`bundle import already exists: ${alias}`);
+    }
+    const workspaces = raw.workspaces;
+    if (workspaces && workspaces[alias]) {
+        throw new errors_1.UsageError(`bundle import alias collides with workspace: ${alias}`);
+    }
+    imports[alias] = {
+        path: bundlePath,
+        enabled: true,
+        visibility,
+        expected_profile,
+        ...(source_path ? { source_path } : {}),
+        ...(options.sourceRepo ? { source_repo: options.sourceRepo } : {}),
+        ...(options.maxStaleSeconds !== undefined ? { max_stale_seconds: options.maxStaleSeconds } : {}),
+    };
+    raw.bundle_imports = imports;
+    const validated = (0, config_1.validateConfigSchema)(raw);
+    const health = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, validated).index.imports.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`bundle import not found after validation: ${alias}`);
+    }
+    if (health.error_count > 0) {
+        throw new errors_1.ValidationError(`bundle import ${alias} is invalid:\n${health.errors.join("\n")}`);
+    }
+    writeRawConfig(configPath, raw);
+    const receipt = receiptForHealth("added", health);
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`bundle import added: ${alias} (${bundlePath})`);
+    if (health.warning_count > 0) {
+        console.log(`warnings: ${health.warning_count}`);
+    }
+}
+function runBundleImportListCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const imports = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config).index.imports;
+    if (options.json) {
+        writeJson({ action: "list", count: imports.length, imports });
+        return;
+    }
+    if (imports.length === 0) {
+        console.log("no bundle imports configured");
+        return;
+    }
+    for (const item of imports) {
+        const status = item.enabled ? item.error_count > 0 ? "invalid" : item.stale ? "stale" : "ok" : "disabled";
+        console.log(`${item.alias} | ${status} | ${item.visibility} | ${item.path}`);
+    }
+}
+function runBundleImportRemoveCommand(options) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const imports = getImports(raw);
+    const existing = imports[alias];
+    if (!existing) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    delete imports[alias];
+    raw.bundle_imports = imports;
+    (0, config_1.validateConfigSchema)(raw);
+    writeRawConfig(configPath, raw);
+    const receipt = { action: "removed", import: { alias } };
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`bundle import removed: ${alias}`);
+}
+function setBundleImportEnabled(options, enabled) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const imports = getImports(raw);
+    const existing = imports[alias];
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    imports[alias] = { ...existing, enabled };
+    raw.bundle_imports = imports;
+    (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(`bundle import ${enabled ? "enabled" : "disabled"}: ${alias}`);
+}
+function runBundleImportEnableCommand(options) {
+    setBundleImportEnabled(options, true);
+}
+function runBundleImportDisableCommand(options) {
+    setBundleImportEnabled(options, false);
+}
+function runBundleImportVerifyCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const all = options.all || !options.alias;
+    const imports = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config).index.imports.filter((item) => all ? true : item.alias === options.alias);
+    if (!all && imports.length === 0) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${options.alias}`);
+    }
+    const ok = imports.every((item) => item.error_count === 0 && !item.stale);
+    const receipt = { action: "verified", ok, count: imports.length, imports };
+    if (options.json) {
+        writeJson(receipt);
+    }
+    else if (ok) {
+        console.log(`bundle imports verified: ${imports.length}`);
+    }
+    else {
+        console.log(`bundle import verify failed: ${imports.length}`);
+        for (const item of imports) {
+            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("bundle import verify failed");
+    }
+}

package/dist/commands/capability.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCapabilityListCommand = runCapabilityListCommand;
+exports.runCapabilitySearchCommand = runCapabilitySearchCommand;
+exports.runCapabilityShowCommand = runCapabilityShowCommand;
+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 errors_1 = require("../util/errors");
+function normalizeKind(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (capabilities_indexer_1.CAPABILITY_KINDS.includes(normalized)) {
+        return normalized;
+    }
+    throw new errors_1.UsageError(`--kind must be one of ${capabilities_indexer_1.CAPABILITY_KINDS.join(", ")}`);
+}
+function normalizeVisibility(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (capabilities_indexer_1.CAPABILITY_VISIBILITIES.includes(normalized)) {
+        return normalized;
+    }
+    throw new errors_1.UsageError(`--visibility must be one of ${capabilities_indexer_1.CAPABILITY_VISIBILITIES.join(", ")}`);
+}
+function loadRecords(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index, stale, rebuilt } = (0, capabilities_index_cache_1.loadCapabilitiesIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    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) {
+        console.error(`warning: ${warning}`);
+    }
+    return [...index.records, ...imported.records];
+}
+function applyFilters(records, options) {
+    const kind = normalizeKind(options.kind);
+    const visibility = normalizeVisibility(options.visibility);
+    return records.filter((record) => {
+        if (kind && record.kind !== kind) {
+            return false;
+        }
+        if (visibility && record.visibility !== visibility) {
+            return false;
+        }
+        return true;
+    });
+}
+function capabilitySearchText(record) {
+    return [
+        record.kind,
+        record.workspace,
+        record.visibility,
+        record.id,
+        record.qid,
+        record.slug,
+        record.name,
+        record.title,
+        record.description,
+        record.path,
+        ...record.tags,
+        ...record.refs,
+        ...record.aliases,
+        ...record.links,
+        ...record.headings.map((heading) => heading.text),
+        JSON.stringify(record.spec ?? {}),
+        JSON.stringify(record.work ?? {}),
+        JSON.stringify(record.skill ?? {}),
+    ]
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .join(" ")
+        .toLowerCase();
+}
+function matchesQuery(record, query) {
+    const terms = query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((term) => term.trim())
+        .filter(Boolean);
+    if (terms.length === 0) {
+        return true;
+    }
+    const text = capabilitySearchText(record);
+    return terms.every((term) => text.includes(term));
+}
+function printCapabilityList(records, json, query) {
+    if (json) {
+        console.log(JSON.stringify({
+            kind: "capability",
+            query,
+            count: records.length,
+            items: records,
+        }, null, 2));
+        return;
+    }
+    if (records.length === 0) {
+        console.log(query ? `no capabilities matched query "${query}"` : "no capabilities matched current filters");
+        return;
+    }
+    console.log(`capabilities: ${records.length}`);
+    for (const record of records) {
+        const label = record.slug ?? record.id;
+        console.log(`${record.qid} | ${record.kind} | ${record.visibility} | ${label} | ${record.title}`);
+    }
+}
+function resolveCapability(records, id) {
+    const normalized = id.toLowerCase();
+    const exact = records.find((record) => record.qid === id || record.id === id);
+    if (exact) {
+        return exact;
+    }
+    const matches = records.filter((record) => record.slug === normalized ||
+        record.id === normalized ||
+        record.qid.toLowerCase() === normalized ||
+        `skill:${record.slug}` === normalized);
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        throw new errors_1.UsageError(`capability reference is ambiguous: ${id}`);
+    }
+    throw new errors_1.NotFoundError(`capability not found: ${id}`);
+}
+function printCapability(record, json) {
+    if (json) {
+        console.log(JSON.stringify({ kind: "capability", item: record }, null, 2));
+        return;
+    }
+    console.log(`${record.qid} | ${record.kind} | ${record.visibility}`);
+    console.log(`title: ${record.title}`);
+    if (record.description) {
+        console.log(`description: ${record.description}`);
+    }
+    if (record.tags.length > 0) {
+        console.log(`tags: ${record.tags.join(", ")}`);
+    }
+    console.log(`path: ${record.path}`);
+}
+function runCapabilityListCommand(options) {
+    const records = applyFilters(loadRecords(options), options);
+    printCapabilityList(records, options.json);
+}
+function runCapabilitySearchCommand(options) {
+    const records = applyFilters(loadRecords(options), options).filter((record) => matchesQuery(record, options.query));
+    printCapabilityList(records, options.json, options.query);
+}
+function runCapabilityShowCommand(options) {
+    const records = loadRecords(options);
+    printCapability(resolveCapability(records, options.id), options.json);
+}

package/dist/commands/doctor.js

@@ -8,10 +8,14 @@ const fs_1 = __importDefault(require("fs"));
 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 node_1 = require("../graph/node");
 const template_schema_1 = require("../graph/template_schema");
+const visibility_1 = require("../graph/visibility");
 const errors_1 = require("../util/errors");
 const REQUIRED_NODE_MAJOR = 18;
+const ARCHIVE_RAW_ALLOWED_DIRS = new Set(["source"]);
 function parseNodeMajor(version) {
     const major = Number.parseInt(version.split(".")[0] ?? "", 10);
     if (!Number.isInteger(major)) {
@@ -42,6 +46,183 @@ function runNodeVersionCheck() {
         detail: `Node.js ${nodeVersion} (ok)`,
     };
 }
+function walkFiles(root) {
+    if (!fs_1.default.existsSync(root)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+        }
+        else if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function runArchiveStorageCheck(root) {
+    const archiveRoot = path_1.default.join(root, ".mdkg", "archive");
+    const files = walkFiles(archiveRoot);
+    const strayRaw = files
+        .filter((filePath) => {
+        const relative = path_1.default.relative(archiveRoot, filePath).split(path_1.default.sep);
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        if (ext === ".md" || ext === ".zip") {
+            return false;
+        }
+        return !relative.some((segment) => ARCHIVE_RAW_ALLOWED_DIRS.has(segment));
+    })
+        .map((filePath) => path_1.default.relative(root, filePath).split(path_1.default.sep).join("/"))
+        .sort();
+    if (strayRaw.length === 0) {
+        return {
+            name: "archive-storage",
+            ok: true,
+            detail: ".mdkg/archive has no stray raw files outside managed source directories",
+        };
+    }
+    return {
+        name: "archive-storage",
+        ok: true,
+        level: "warn",
+        detail: `stray uncompressed archive file(s) found without managed sidecars: ${strayRaw.join(", ")}; run \`mdkg archive add <file>\` or move raw files under a managed archive source directory`,
+    };
+}
+function runArchiveLargeCacheCheck(root, warningBytes) {
+    if (warningBytes === 0) {
+        return {
+            name: "archive-large-cache",
+            ok: true,
+            detail: "archive large-cache warning disabled",
+        };
+    }
+    const archiveRoot = path_1.default.join(root, ".mdkg", "archive");
+    const largeCaches = walkFiles(archiveRoot)
+        .filter((filePath) => filePath.endsWith(".zip"))
+        .map((filePath) => ({
+        path: path_1.default.relative(root, filePath).split(path_1.default.sep).join("/"),
+        size: fs_1.default.statSync(filePath).size,
+    }))
+        .filter((entry) => entry.size > warningBytes)
+        .sort((a, b) => a.path.localeCompare(b.path));
+    if (largeCaches.length === 0) {
+        return {
+            name: "archive-large-cache",
+            ok: true,
+            detail: `no archive ZIP cache exceeds ${warningBytes} bytes`,
+        };
+    }
+    return {
+        name: "archive-large-cache",
+        ok: true,
+        level: "warn",
+        detail: `archive ZIP cache(s) exceed ${warningBytes} bytes: ${largeCaches
+            .map((entry) => `${entry.path} (${entry.size} bytes)`)
+            .join(", ")}; keep large caches private or move bulky originals to repo policy-managed storage`,
+    };
+}
+function runBundleStorageCheck(root, outputDir) {
+    const bundleRoot = path_1.default.resolve(root, outputDir);
+    if (!fs_1.default.existsSync(bundleRoot)) {
+        return {
+            name: "bundle-storage",
+            ok: true,
+            detail: `no bundle directory found; run \`mdkg bundle create --profile private\` when a snapshot should be tracked`,
+        };
+    }
+    const bundles = walkFiles(bundleRoot)
+        .filter((filePath) => filePath.endsWith(".mdkg.zip"))
+        .map((filePath) => path_1.default.relative(root, filePath).split(path_1.default.sep).join("/"))
+        .sort();
+    if (bundles.length === 0) {
+        return {
+            name: "bundle-storage",
+            ok: true,
+            detail: `bundle directory has no .mdkg.zip files; run \`mdkg bundle create --profile private\` when a snapshot should be tracked`,
+        };
+    }
+    return {
+        name: "bundle-storage",
+        ok: true,
+        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) {
+        return [
+            {
+                name: "bundle-imports",
+                ok: true,
+                detail: "no bundle imports configured",
+            },
+        ];
+    }
+    return projection.index.imports.map((item) => {
+        if (!item.enabled) {
+            return {
+                name: `bundle-import:${item.alias}`,
+                ok: true,
+                level: "warn",
+                detail: `disabled import at ${item.path}`,
+            };
+        }
+        if (item.error_count > 0) {
+            return {
+                name: `bundle-import:${item.alias}`,
+                ok: false,
+                detail: item.errors.join("; "),
+            };
+        }
+        if (item.stale || item.warning_count > 0) {
+            return {
+                name: `bundle-import:${item.alias}`,
+                ok: true,
+                level: "warn",
+                detail: `import is stale or has warnings; run \`mdkg bundle import verify ${item.alias}\` (${item.warnings.join("; ")})`,
+            };
+        }
+        return {
+            name: `bundle-import:${item.alias}`,
+            ok: true,
+            detail: `import loaded from ${item.path}`,
+        };
+    });
+}
+function runVisibilityPolicyCheck(root, config, options) {
+    try {
+        const { index } = (0, index_cache_1.loadIndex)({
+            root,
+            config,
+            useCache: !options.noCache,
+            allowReindex: !options.noReindex,
+        });
+        const messages = (0, visibility_1.visibilityViolationMessages)((0, visibility_1.collectVisibilityViolations)(index, config));
+        if (messages.length === 0) {
+            return {
+                name: "visibility-policy",
+                ok: true,
+                detail: "public/internal records do not reference less-visible mdkg records",
+            };
+        }
+        return {
+            name: "visibility-policy",
+            ok: false,
+            detail: `${messages.length} violation(s): ${messages.join("; ")}`,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            name: "visibility-policy",
+            ok: false,
+            detail: message,
+        };
+    }
+}
 function runDoctorCommand(options) {
     const results = [];
     results.push(runNodeVersionCheck());
@@ -78,13 +259,26 @@ function runDoctorCommand(options) {
         });
     }
     if (config) {
+        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(runVisibilityPolicyCheck(options.root, config, options));
         try {
-            (0, template_schema_1.loadTemplateSchemas)(options.root, config, node_1.ALLOWED_TYPES);
+            const templateSchemaInfo = (0, template_schema_1.loadTemplateSchemasWithInfo)(options.root, config, node_1.ALLOWED_TYPES);
             results.push({
                 name: "templates",
                 ok: true,
                 detail: "template schema set loaded",
             });
+            if (templateSchemaInfo.fallbackTypes.length > 0) {
+                results.push({
+                    name: "local-templates",
+                    ok: true,
+                    level: "warn",
+                    detail: `missing local template schema(s) covered by bundled fallback: ${templateSchemaInfo.fallbackTypes.join(", ")}; run \`mdkg upgrade --apply\` to vendor them`,
+                });
+            }
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -131,6 +325,43 @@ function runDoctorCommand(options) {
                 detail: message,
             });
         }
+        try {
+            const { rebuilt, stale } = (0, capabilities_index_cache_1.loadCapabilitiesIndex)({
+                root: options.root,
+                config,
+                useCache: !options.noCache,
+                allowReindex: !options.noReindex,
+            });
+            if (rebuilt) {
+                results.push({
+                    name: "capabilities-index",
+                    ok: true,
+                    detail: "capabilities cache rebuilt and loaded",
+                });
+            }
+            else if (stale) {
+                results.push({
+                    name: "capabilities-index",
+                    ok: true,
+                    detail: "capabilities cache is stale (run mdkg index to refresh)",
+                });
+            }
+            else {
+                results.push({
+                    name: "capabilities-index",
+                    ok: true,
+                    detail: "capabilities cache loaded",
+                });
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push({
+                name: "capabilities-index",
+                ok: false,
+                detail: message,
+            });
+        }
     }
     const failures = results.filter((result) => !result.ok);
     if (options.json) {
@@ -143,7 +374,7 @@ function runDoctorCommand(options) {
     }
     else {
         for (const result of results) {
-            const prefix = result.ok ? "ok" : "fail";
+            const prefix = result.ok ? result.level ?? "ok" : "fail";
             console.log(`${prefix}: ${result.name} - ${result.detail}`);
         }
     }