mdkg 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to mdkg are documented here.
 
 This project follows a pragmatic changelog style inspired by Keep a Changelog. Versions use npm package versions.
 
+## 0.1.1 - 2026-05-12
+
+### Added
+
+- Added bundled template schema fallback so older workspaces can keep using graph inspection while missing newly introduced built-in templates.
+- Added `safe_to_apply`, `will_write_paths`, `preserved_customizations`, `blocking_conflicts`, and `apply_side_effects` fields to `mdkg upgrade --json`.
+
+### Changed
+
+- `mdkg new <built-in-type>` can use the installed package template when the workspace has not yet vendored that local template.
+- `mdkg doctor` and `mdkg validate` warn, rather than fail, when packaged fallback schemas cover missing local built-in templates.
+- `mdkg upgrade` human output now states whether the receipt is safe to apply and what paths would be written.
+- `mdkg upgrade` skips ignored event logs and points users to `mdkg event enable` instead of creating ignored `.mdkg/work/events/events.jsonl` files.
+
 ## 0.1.0 - 2026-05-12
 
 ### Added

package/README.md

@@ -13,7 +13,7 @@ mdkg stays deliberately boring:
 - zero runtime dependencies
 - no sqlite, daemon, hosted index, or vector DB
 
-Current package version in source: `0.1.0`
+Current package version in source: `0.1.1`
 
 ## The product shape
 
@@ -70,7 +70,9 @@ Apply only after reviewing the receipt:
 mdkg upgrade --apply
 ```
 
-Upgrade is intentionally conservative. It creates missing managed startup docs and updates unchanged mdkg seed assets, but preserves customized docs, templates, skills, and core files as reported conflicts. Agent-enabled workspaces also get safe default skill upgrades and skill mirror refreshes; non-agent workspaces do not gain skills, events, or mirrors implicitly.
+Upgrade is intentionally conservative. It creates missing managed startup docs and templates, updates unchanged mdkg seed assets, and preserves customized docs, templates, skills, and core files as reported preserved customizations. Review `safe_to_apply`, `will_write_paths`, and `apply_side_effects` in the JSON receipt before applying. Agent-enabled workspaces can receive safe default skill upgrades and skill mirror refreshes; ignored event logs are skipped with guidance to run `mdkg event enable` if provenance should be restored.
+
+Older workspaces can continue to inspect and validate current graph nodes before applying an upgrade. When local templates are missing for newly introduced built-in mdkg types, mdkg uses the installed package's bundled templates as a read-only schema fallback and warns that `mdkg upgrade --apply` can vendor the missing templates.
 
 Create a task:
 

package/dist/cli.js

@@ -108,7 +108,9 @@ function printUpgradeHelp(log) {
     log("  --json                Emit machine-readable upgrade receipt");
     log("\nNotes:");
     log("  - preserves customized docs, templates, skills, and core files");
+    log("  - json receipts include safe_to_apply, will_write_paths, and apply_side_effects");
     log("  - upgrades default mdkg skills only when they match managed seed fingerprints");
+    log("  - skips ignored event logs; run mdkg event enable if provenance should be restored");
     log("  - run without flags first, then rerun with --apply when the receipt looks right");
     printGlobalOptions(log);
 }

package/dist/commands/doctor.js

@@ -79,12 +79,20 @@ function runDoctorCommand(options) {
     }
     if (config) {
         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);
@@ -143,7 +151,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}`);
         }
     }

package/dist/commands/new.js

@@ -286,6 +286,9 @@ function runNewCommand(options) {
     }
     const today = (0, date_1.formatDate)(options.now ?? new Date());
     const template = (0, loader_1.loadTemplate)(options.root, config, type, options.template);
+    if (template.source === "bundled") {
+        console.error(`warning: using bundled template fallback for ${type}; run \`mdkg upgrade --apply\` to vendor missing local templates`);
+    }
     const content = (0, loader_1.renderTemplate)(template, {
         id,
         type,

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");
@@ -85,6 +86,9 @@ function record(summary, changes, change) {
             summary.skipped += 1;
             summary.conflicted += 1;
             break;
+        case "skip":
+            summary.skipped += 1;
+            break;
     }
 }
 function buildKnownHashes(manifests) {
@@ -185,11 +189,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 +254,50 @@ function ensureAgentRuntimeFiles(root, dryRun, summary, changes) {
         summary.unchanged += 1;
     }
 }
+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 +306,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 +353,42 @@ function runUpgradeCommand(options) {
     if (agentWorkspace) {
         ensureAgentRuntimeFiles(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

@@ -200,10 +200,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)) {

package/dist/graph/template_schema.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadTemplateSchemas = loadTemplateSchemas;
+exports.loadTemplateSchemasWithInfo = loadTemplateSchemasWithInfo;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const frontmatter_1 = require("./frontmatter");
+const builtin_1 = require("../templates/builtin");
 function listMarkdownFiles(dir) {
     if (!fs_1.default.existsSync(dir)) {
         return [];
@@ -45,9 +47,12 @@ function addKeyToSchema(schema, key, kind, filePath) {
     }
 }
 function loadTemplateSchemas(root, config, requiredTypes) {
+    return loadTemplateSchemasWithInfo(root, config, requiredTypes).schemas;
+}
+function loadTemplateSchemasWithInfo(root, config, requiredTypes) {
     const templateRoot = path_1.default.resolve(root, config.templates.root_path, config.templates.default_set);
     const files = listMarkdownFiles(templateRoot);
-    if (files.length === 0) {
+    if (files.length === 0 && !requiredTypes) {
         throw new Error(`no templates found at ${templateRoot}`);
     }
     const schemas = {};
@@ -75,12 +80,35 @@ function loadTemplateSchemas(root, config, requiredTypes) {
             addKeyToSchema(schema, key, kind, filePath);
         }
     }
+    const fallbackTypes = [];
     if (requiredTypes) {
         const required = Array.from(requiredTypes, (value) => value.toLowerCase());
-        const missing = required.filter((value) => !schemas[value]);
-        if (missing.length > 0) {
-            throw new Error(`template schema missing for type(s): ${missing.join(", ")}`);
+        for (const missingType of required.filter((value) => !schemas[value])) {
+            const bundledPath = (0, builtin_1.requireBundledTemplatePath)(missingType);
+            const content = fs_1.default.readFileSync(bundledPath, "utf8");
+            const { frontmatter } = (0, frontmatter_1.parseFrontmatter)(content, bundledPath);
+            const typeValue = frontmatter.type;
+            if (typeValue !== missingType) {
+                throw new Error(`bundled template fallback type mismatch for ${missingType}: ${bundledPath}`);
+            }
+            const schema = {
+                type: missingType,
+                allowedKeys: new Set(),
+                keyKinds: {},
+                listKeys: new Set(),
+            };
+            schemas[missingType] = schema;
+            for (const [key, value] of Object.entries(frontmatter)) {
+                const kind = getValueKind(value);
+                addKeyToSchema(schema, key, kind, bundledPath);
+            }
+            fallbackTypes.push(missingType);
         }
     }
-    return schemas;
+    return {
+        schemas,
+        templateRoot,
+        bundledTemplateRoot: (0, builtin_1.resolveBundledTemplateRoot)(),
+        fallbackTypes,
+    };
 }

package/dist/init/CLI_COMMAND_MATRIX.md

@@ -68,7 +68,9 @@ Agent bootstrap:
 Upgrade:
 - `mdkg upgrade` previews safe scaffold updates and writes nothing by default
 - `mdkg upgrade --apply` updates only managed or unchanged init assets
+- JSON receipts include `safe_to_apply`, `will_write_paths`, `preserved_customizations`, `blocking_conflicts`, and `apply_side_effects`
 - customized docs, templates, skills, and core files are preserved and reported
+- ignored event logs are skipped with guidance to run `mdkg event enable`
 
 Skill discovery:
 - `mdkg skill list --tags stage:plan --json`

package/dist/init/README.md

@@ -56,4 +56,4 @@ mdkg init --update-gitignore --update-npmignore
 
 `mdkg upgrade` previews safe scaffold updates for existing workspaces and writes nothing by default.
 
-Use `mdkg upgrade --apply` only after reviewing the receipt. Local customizations are preserved and reported instead of overwritten.
+Use `mdkg upgrade --apply` only after reviewing `safe_to_apply`, `will_write_paths`, and `apply_side_effects` in the receipt. Local customizations are preserved and reported instead of overwritten. Missing built-in templates can be loaded from the installed package as a read-only fallback until you vendor them with upgrade.

package/dist/init/core/rule-6-templates-and-schemas.md

@@ -187,4 +187,6 @@ Body headings are strongly recommended for agent usability but should not be har
 - Node -> skill references in `skills: [...]` are validated against `.mdkg/skills/<slug>/SKILL.md`.
 - `.mdkg/work/events/events.jsonl` is optional; when present, records are schema-validated by `mdkg validate`.
 - If a template is missing:
-  - `mdkg new` must fail with a helpful error (exit code 3).
+  - built-in mdkg node types may use the installed package's bundled default template as a read-only schema fallback.
+  - commands should warn when bundled fallback is used and recommend `mdkg upgrade --apply` to vendor missing templates.
+  - missing non-built-in templates or missing packaged fallback assets must fail with a helpful error.

package/dist/init/init-manifest.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "tool": "mdkg",
-  "mdkg_version": "0.1.0",
+  "mdkg_version": "0.1.1",
   "files": [
     {
       "path": ".mdkg/config.json",
@@ -51,7 +51,7 @@
     {
       "path": ".mdkg/core/rule-6-templates-and-schemas.md",
       "category": "core",
-      "sha256": "0d6da477c12e3492f43c571a6e4daa373bf05005ef703ad5166b7c8786e553b0"
+      "sha256": "7f0a92ccd35f378b487969f06820a61790b02a59aeb14755fe506278f056fd59"
     },
     {
       "path": ".mdkg/core/SOUL.md",
@@ -61,7 +61,7 @@
     {
       "path": ".mdkg/README.md",
       "category": "mdkg_doc",
-      "sha256": "26e99be382b48682b7841f14404576f79bf6876b64a90aefa6c99c2440701d2a"
+      "sha256": "f4078fef50e6866d6f7e3a40351e72fc15d3e1abd334e7119d89c696bc4a9100"
     },
     {
       "path": ".mdkg/skills/build-pack-and-execute-task/SKILL.md",
@@ -186,7 +186,7 @@
     {
       "path": "CLI_COMMAND_MATRIX.md",
       "category": "startup_doc",
-      "sha256": "eb441dd11b31270ddb31f0a77c75fc744671754cffac3aa8ac6f60e30a1f324f"
+      "sha256": "5ac721d2569c4da2a3b7f18e62c816eb3898e8deb06429f17f0615f4a8da2183"
     },
     {
       "path": "llms.txt",

package/dist/templates/builtin.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_TEMPLATE_SET = void 0;
+exports.templateNameForType = templateNameForType;
+exports.resolveLocalTemplatePath = resolveLocalTemplatePath;
+exports.resolveBundledTemplateRoot = resolveBundledTemplateRoot;
+exports.resolveBundledTemplatePath = resolveBundledTemplatePath;
+exports.requireBundledTemplatePath = requireBundledTemplatePath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.BUILTIN_TEMPLATE_SET = "default";
+function templateNameForType(type) {
+    const normalized = type.toLowerCase();
+    if (normalized === "checkpoint") {
+        return "chk";
+    }
+    return normalized;
+}
+function resolveLocalTemplatePath(root, config, type, templateSet) {
+    const setName = (templateSet ?? config.templates.default_set).toLowerCase();
+    return path_1.default.resolve(root, config.templates.root_path, setName, `${templateNameForType(type)}.md`);
+}
+function resolveBundledTemplateRoot() {
+    return path_1.default.resolve(__dirname, "..", "init", "templates", exports.BUILTIN_TEMPLATE_SET);
+}
+function resolveBundledTemplatePath(type) {
+    return path_1.default.join(resolveBundledTemplateRoot(), `${templateNameForType(type)}.md`);
+}
+function requireBundledTemplatePath(type) {
+    const templatePath = resolveBundledTemplatePath(type);
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new Error(`bundled template fallback missing for type ${type}: ${templatePath} (try reinstalling mdkg)`);
+    }
+    return templatePath;
+}

package/dist/templates/loader.js

@@ -6,26 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadTemplate = loadTemplate;
 exports.renderTemplate = renderTemplate;
 const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const frontmatter_1 = require("../graph/frontmatter");
 const errors_1 = require("../util/errors");
-function templateNameForType(type) {
-    const normalized = type.toLowerCase();
-    if (normalized === "checkpoint") {
-        return "chk";
-    }
-    return normalized;
-}
+const builtin_1 = require("./builtin");
 function loadTemplate(root, config, type, templateSet) {
-    const setName = (templateSet ?? config.templates.default_set).toLowerCase();
-    const templateName = templateNameForType(type);
-    const templatePath = path_1.default.resolve(root, config.templates.root_path, setName, `${templateName}.md`);
-    if (!fs_1.default.existsSync(templatePath)) {
-        throw new errors_1.NotFoundError(`template not found: ${setName}/${templateName}.md`);
+    const templatePath = (0, builtin_1.resolveLocalTemplatePath)(root, config, type, templateSet);
+    if (!fs_1.default.existsSync(templatePath) && templateSet !== undefined) {
+        throw new errors_1.NotFoundError(`template not found: ${templateSet.toLowerCase()}/${(0, builtin_1.templateNameForType)(type)}.md`);
     }
-    const content = fs_1.default.readFileSync(templatePath, "utf8");
-    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, templatePath);
-    return { templatePath, frontmatter, body };
+    const source = fs_1.default.existsSync(templatePath) ? "local" : "bundled";
+    const resolvedPath = source === "local" ? templatePath : (0, builtin_1.requireBundledTemplatePath)(type);
+    const content = fs_1.default.readFileSync(resolvedPath, "utf8");
+    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, resolvedPath);
+    return { templatePath: resolvedPath, source, frontmatter, body };
 }
 function isTokenPlaceholder(value) {
     return typeof value === "string" && /^\{\{[a-z0-9_]+\}\}$/.test(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdkg",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Markdown Knowledge Graph",
   "license": "MIT",
   "bin": {