mdkg 0.1.0 → 0.1.2

package/dist/commands/pack.js

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

package/dist/commands/query_output.js

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

package/dist/commands/search.js

@@ -54,14 +54,14 @@ function runSearchCommand(options) {
     }
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedType = options.type?.toLowerCase();
     if (normalizedType === "skill") {
         throw new errors_1.UsageError("--type skill is no longer supported here; use `mdkg skill search`");
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -70,6 +70,9 @@ function runSearchCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
     const nodeResults = (0, filter_1.filterNodes)(Object.values(index.nodes), {
         ws,

package/dist/commands/show.js

@@ -1,14 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runShowCommand = runShowCommand;
-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 frontmatter_1 = require("../graph/frontmatter");
+const node_body_1 = require("../graph/node_body");
 const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
 const node_card_1 = require("./node_card");
@@ -34,14 +29,14 @@ 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]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedId = options.id.toLowerCase();
     if (normalizedId.startsWith("skill:") || normalizedId.startsWith("root:skill:")) {
         throw new errors_1.UsageError(`generic skill show is no longer supported; use \`mdkg skill show ${options.id.replace(/^root:skill:|^skill:/i, "")}\``);
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -50,19 +45,17 @@ function runShowCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
     if (resolved.status !== "ok") {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
     }
     const node = index.nodes[resolved.qid];
-    const filePath = path_1.default.resolve(options.root, node.path);
     let body = "";
     if (!options.metaOnly) {
-        if (!fs_1.default.existsSync(filePath)) {
-            throw new errors_1.NotFoundError(`file not found for ${node.qid}: ${node.path}`);
-        }
-        const content = fs_1.default.readFileSync(filePath, "utf8");
-        body = (0, frontmatter_1.parseFrontmatter)(content, filePath).body.trimEnd();
+        body = (0, node_body_1.readNodeBody)(options.root, node);
     }
     const format = options.format ?? (options.json ? "json" : undefined);
     if (format) {

package/dist/commands/skill_mirror.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncSkillMirrors = syncSkillMirrors;
+exports.preflightSkillMirrorTargets = preflightSkillMirrorTargets;
 exports.shouldMaintainSkillMirrors = shouldMaintainSkillMirrors;
 exports.auditSkillMirrors = auditSkillMirrors;
 exports.scaffoldMirrorRoots = scaffoldMirrorRoots;
@@ -271,6 +272,27 @@ function syncSkillMirrors(options) {
     }
     return { synced, pruned, targets: touchedTargets };
 }
+function preflightSkillMirrorTargets(options) {
+    if (options.force) {
+        return;
+    }
+    const slugs = Array.from(new Set(options.slugs.map((value) => value.trim().toLowerCase()).filter(Boolean)));
+    if (slugs.length === 0) {
+        return;
+    }
+    for (const target of resolveMirrorTargets(options.root)) {
+        if (!fs_1.default.existsSync(target.rootDir) && !fs_1.default.existsSync(target.skillsRoot)) {
+            continue;
+        }
+        const managed = readManifest(target);
+        for (const slug of slugs) {
+            const destDir = path_1.default.join(target.skillsRoot, slug);
+            if (fs_1.default.existsSync(destDir) && !managed.has(slug)) {
+                throw new errors_1.UsageError(`${path_1.default.relative(options.root, destDir)} already exists and is not mdkg-managed; rerun \`mdkg init --agent --force\` or \`mdkg skill sync --force\` to replace it`);
+            }
+        }
+    }
+}
 function shouldMaintainSkillMirrors(root) {
     return shouldCreateMirrorRoots(root);
 }

package/dist/commands/task.js

@@ -107,6 +107,9 @@ function loadMutableTaskNode(root, idOrQid, wsHint) {
     if (!node) {
         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}`);
+    }
     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}`);
     }

package/dist/commands/upgrade.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runUpgradeCommand = runUpgradeCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
 const migrate_1 = require("../core/migrate");
 const config_1 = require("../core/config");
 const paths_1 = require("../core/paths");
@@ -17,6 +18,7 @@ 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 ARCHIVE_RAW_IGNORE_ENTRIES = [".mdkg/archive/**/source/"];
 function seededInitEvent(nowIso) {
     const event = {
         ts: nowIso,
@@ -85,6 +87,9 @@ function record(summary, changes, change) {
             summary.skipped += 1;
             summary.conflicted += 1;
             break;
+        case "skip":
+            summary.skipped += 1;
+            break;
     }
 }
 function buildKnownHashes(manifests) {
@@ -103,7 +108,7 @@ function buildKnownHashes(manifests) {
     return hashes;
 }
 function shouldIncludeFile(file, agentWorkspace) {
-    if (file.category === "default_skill") {
+    if (file.category === "agent_doc" || file.category === "startup_doc" || file.category === "default_skill") {
         return agentWorkspace;
     }
     return file.category !== "config";
@@ -185,11 +190,59 @@ function migrateConfigIfNeeded(root, dryRun, summary, changes) {
         writeFile(cfgPath, `${JSON.stringify(migrated.config, null, 2)}\n`);
     }
 }
+function isIgnoredBySimpleGitignore(root, relativePath) {
+    const ignorePath = path_1.default.join(root, ".gitignore");
+    if (!fs_1.default.existsSync(ignorePath)) {
+        return false;
+    }
+    const normalized = relativePath.replace(/\\/g, "/");
+    const lines = fs_1.default.readFileSync(ignorePath, "utf8").split(/\r?\n/);
+    let ignored = false;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const negated = line.startsWith("!");
+        const pattern = negated ? line.slice(1) : line;
+        const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\/+/, "");
+        const matches = normalizedPattern === normalized ||
+            (normalizedPattern.endsWith("/") && normalized.startsWith(normalizedPattern)) ||
+            (normalizedPattern.endsWith("/*") && normalized.startsWith(normalizedPattern.slice(0, -1)));
+        if (matches) {
+            ignored = !negated;
+        }
+    }
+    return ignored;
+}
+function isGitIgnored(root, relativePath) {
+    const result = (0, child_process_1.spawnSync)("git", ["check-ignore", "--quiet", "--", relativePath], {
+        cwd: root,
+        stdio: "ignore",
+    });
+    if (result.status === 0) {
+        return true;
+    }
+    if (result.status === 1) {
+        return false;
+    }
+    return isIgnoredBySimpleGitignore(root, relativePath);
+}
 function ensureAgentRuntimeFiles(root, dryRun, summary, changes) {
     const eventsPath = path_1.default.join(root, ".mdkg", "work", "events", "events.jsonl");
+    const relEventsPath = ".mdkg/work/events/events.jsonl";
     if (!fs_1.default.existsSync(eventsPath)) {
+        if (isGitIgnored(root, relEventsPath)) {
+            record(summary, changes, {
+                path: relEventsPath,
+                category: "event_log",
+                action: "skip",
+                reason: "event log path is ignored; run `mdkg event enable` if local event provenance should be restored",
+            });
+            return;
+        }
         record(summary, changes, {
-            path: ".mdkg/work/events/events.jsonl",
+            path: relEventsPath,
             category: "event_log",
             action: "create",
             reason: "agent workspace is missing event log",
@@ -202,9 +255,71 @@ function ensureAgentRuntimeFiles(root, dryRun, summary, changes) {
         summary.unchanged += 1;
     }
 }
+function ensureArchiveIgnorePolicy(root, dryRun, summary, changes) {
+    const ignorePath = path_1.default.join(root, ".gitignore");
+    const raw = fs_1.default.existsSync(ignorePath) ? fs_1.default.readFileSync(ignorePath, "utf8") : "";
+    const lines = raw.split(/\r?\n/);
+    const existing = new Set(lines.map((line) => line.trim()).filter(Boolean));
+    const additions = ARCHIVE_RAW_IGNORE_ENTRIES.filter((entry) => !existing.has(entry));
+    if (additions.length === 0) {
+        summary.unchanged += 1;
+        return;
+    }
+    record(summary, changes, {
+        path: ".gitignore",
+        category: "ignore_policy",
+        action: fs_1.default.existsSync(ignorePath) ? "update" : "create",
+        reason: "ignore raw local archive source copies while keeping sidecars and zip caches commit-eligible",
+    });
+    if (!dryRun) {
+        const suffix = raw.length === 0 || raw.endsWith("\n") ? "" : "\n";
+        writeFile(ignorePath, `${raw}${suffix}${additions.join("\n")}\n`);
+    }
+}
+function isWritableChange(change) {
+    return change.action === "create" || change.action === "update" || change.action === "migrate" || change.action === "sync";
+}
+function buildApplySideEffects(options) {
+    const hasDirectWrites = options.changes.some(isWritableChange);
+    if (!hasDirectWrites && options.existingManifest) {
+        return [];
+    }
+    const effects = [
+        {
+            path: ".mdkg/init-manifest.json",
+            category: "init_manifest",
+            action: options.existingManifest ? "update" : "create",
+            reason: "records managed init asset fingerprints after apply",
+        },
+    ];
+    if (options.agentWorkspace) {
+        effects.push({
+            path: ".mdkg/skills/registry.md",
+            category: "skill_registry",
+            action: "update",
+            reason: "refreshes canonical skill registry after apply",
+        }, {
+            path: ".agents/skills,.claude/skills",
+            category: "skill_mirror",
+            action: "sync",
+            reason: "syncs managed skill mirrors after apply",
+        });
+    }
+    return effects;
+}
 function emitHumanReceipt(receipt) {
     const mode = receipt.dry_run ? "dry-run" : "apply";
     console.log(`mdkg upgrade ${mode}: ${receipt.summary.created} create, ${receipt.summary.updated} update, ${receipt.summary.migrated} migrate, ${receipt.summary.synced} sync, ${receipt.summary.conflicted} conflict`);
+    console.log(`safe to apply: ${receipt.safe_to_apply ? "yes" : "no"}`);
+    if (receipt.will_write_paths.length > 0) {
+        console.log(`will write: ${receipt.will_write_paths.join(", ")}`);
+    }
+    if (receipt.preserved_customizations.length > 0) {
+        console.log(`preserved customizations: ${receipt.preserved_customizations.length}`);
+    }
+    if (receipt.blocking_conflicts.length > 0) {
+        console.log(`blocking conflicts: ${receipt.blocking_conflicts.length}`);
+    }
     if (receipt.changes.length === 0) {
         console.log("no upgrade changes pending");
     }
@@ -213,8 +328,18 @@ function emitHumanReceipt(receipt) {
             console.log(`  ${change.action}: ${change.path} (${change.reason})`);
         }
     }
-    if (receipt.dry_run && receipt.changes.some((change) => change.action !== "conflict")) {
-        console.log("next: mdkg upgrade --apply");
+    if (receipt.apply_side_effects.length > 0) {
+        for (const effect of receipt.apply_side_effects) {
+            console.log(`  apply-side-effect: ${effect.path} (${effect.reason})`);
+        }
+    }
+    if (receipt.dry_run && receipt.will_write_paths.length > 0) {
+        if (receipt.safe_to_apply) {
+            console.log("next: mdkg upgrade --apply (writes only safe managed paths; preserves customized files)");
+        }
+        else {
+            console.log("next: resolve blocking conflicts before running mdkg upgrade --apply");
+        }
     }
 }
 function runUpgradeCommand(options) {
@@ -250,30 +375,43 @@ function runUpgradeCommand(options) {
     if (agentWorkspace) {
         ensureAgentRuntimeFiles(root, dryRun, summary, changes);
     }
+    ensureArchiveIgnorePolicy(root, dryRun, summary, changes);
+    const applySideEffects = buildApplySideEffects({
+        existingManifest,
+        agentWorkspace,
+        changes,
+    });
+    for (const effect of applySideEffects) {
+        record(summary, changes, effect);
+    }
     if (!dryRun) {
         const appliedManifest = {
             ...currentManifest,
             files: managedCurrentFiles.sort((a, b) => a.path.localeCompare(b.path)),
         };
-        (0, init_manifest_1.writeInitManifest)(path_1.default.join(root, ".mdkg", init_manifest_1.INIT_MANIFEST_FILE), appliedManifest);
-        if (agentWorkspace) {
+        if (applySideEffects.length > 0) {
+            (0, init_manifest_1.writeInitManifest)(path_1.default.join(root, ".mdkg", init_manifest_1.INIT_MANIFEST_FILE), appliedManifest);
+        }
+        if (agentWorkspace && applySideEffects.length > 0) {
             const config = (0, config_1.validateConfigSchema)((0, migrate_1.migrateConfig)(JSON.parse(fs_1.default.readFileSync((0, paths_1.configPath)(root), "utf8"))).config);
             (0, skill_support_1.refreshSkillsRegistry)(root, config);
             (0, skill_mirror_1.scaffoldMirrorRoots)(root);
-            const result = (0, skill_mirror_1.syncSkillMirrors)({ root, config, createRoots: true });
-            record(summary, changes, {
-                path: ".agents/skills,.claude/skills",
-                category: "skill_mirror",
-                action: "sync",
-                reason: `${result.synced} mirrored skill(s), ${result.pruned} stale mirror(s) pruned`,
-            });
+            (0, skill_mirror_1.syncSkillMirrors)({ root, config, createRoots: true });
         }
     }
+    const preservedCustomizations = changes.filter((change) => change.action === "conflict");
+    const blockingConflicts = [];
+    const willWritePaths = changes.filter(isWritableChange).map((change) => change.path);
     const receipt = {
         action: "upgrade",
         dry_run: dryRun,
         version,
+        safe_to_apply: blockingConflicts.length === 0,
         summary,
+        will_write_paths: Array.from(new Set(willWritePaths)),
+        preserved_customizations: preservedCustomizations,
+        blocking_conflicts: blockingConflicts,
+        apply_side_effects: applySideEffects,
         changes,
     };
     if (options.json) {

package/dist/commands/validate.js

@@ -12,6 +12,8 @@ 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 visibility_1 = require("../graph/visibility");
 const errors_1 = require("../util/errors");
 const skill_mirror_1 = require("./skill_mirror");
 const RECOMMENDED_HEADINGS = {
@@ -200,10 +202,14 @@ function validateEventsJsonl(root, config, errors) {
 }
 function runValidateCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
-    const templateSchemas = (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);
+    const templateSchemas = templateSchemaInfo.schemas;
     const filesByAlias = (0, workspace_files_1.listWorkspaceDocFilesByAlias)(options.root, config);
     const errors = [];
     const warnings = [];
+    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`);
+    }
     const nodes = {};
     const idsByWorkspace = {};
     for (const [alias, files] of Object.entries(filesByAlias)) {
@@ -264,6 +270,16 @@ function runValidateCommand(options) {
         nodes,
         reverse_edges: {},
     };
+    const importProjection = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config);
+    for (const item of importProjection.index.imports) {
+        for (const warning of item.warnings) {
+            warnings.push(`bundle import ${item.alias}: ${warning}`);
+        }
+        for (const error of item.errors) {
+            errors.push(`bundle import ${item.alias}: ${error}`);
+        }
+    }
+    const validationIndex = (0, bundle_imports_1.mergeBundleImportsIntoIndex)(index, importProjection);
     let knownSkills = new Set();
     try {
         const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
@@ -280,11 +296,12 @@ function runValidateCommand(options) {
         const message = err instanceof Error ? err.message : "unknown skill validation error";
         errors.push(message);
     }
-    const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, {
+    const graphErrors = (0, validate_graph_1.collectGraphErrors)(validationIndex, {
         allowMissing: false,
         knownSkillSlugs: knownSkills,
     });
     errors.push(...graphErrors);
+    errors.push(...(0, visibility_1.visibilityViolationMessages)((0, visibility_1.collectVisibilityViolations)(validationIndex, config)).map((message) => `visibility: ${message}`));
     const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(options.root, config);
     for (const dirPath of listDirectories(skillsRoot)) {
         const canonicalPath = path_1.default.join(dirPath, "SKILL.md");