@bartolli/kmd 0.1.0

package/dist/kmd.mjs

@@ -0,0 +1,1596 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../db/src/database.ts
+import { DatabaseSync } from "node:sqlite";
+function openDatabase(dbPath) {
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec(SCHEMA);
+  return db;
+}
+var SCHEMA;
+var init_database = __esm({
+  "../db/src/database.ts"() {
+    "use strict";
+    SCHEMA = `
+CREATE TABLE IF NOT EXISTS pages (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    path         TEXT UNIQUE NOT NULL,
+    title        TEXT NOT NULL,
+    kind         TEXT NOT NULL,
+    scope        TEXT,
+    topic        TEXT,
+    status       TEXT NOT NULL DEFAULT 'draft',
+    summary      TEXT,
+    tags         TEXT,
+    updated      TEXT,
+    body         TEXT,
+    content_hash TEXT,
+    meta         TEXT
+);
+
+CREATE INDEX IF NOT EXISTS pages_scope_kind ON pages(scope, kind, status);
+CREATE INDEX IF NOT EXISTS pages_topic_kind ON pages(topic, kind, status);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts USING fts5(
+    title, summary, body,
+    content='pages',
+    content_rowid='id'
+);
+
+CREATE TABLE IF NOT EXISTS links (
+    source_path TEXT NOT NULL,
+    target_path TEXT NOT NULL,
+    link_text   TEXT,
+    PRIMARY KEY (source_path, target_path)
+);
+
+CREATE INDEX IF NOT EXISTS links_source ON links(source_path);
+CREATE INDEX IF NOT EXISTS links_target ON links(target_path);
+
+CREATE TABLE IF NOT EXISTS events (
+    id        INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts        TEXT DEFAULT (datetime('now')),
+    scope     TEXT,
+    operation TEXT NOT NULL,
+    path      TEXT,
+    note      TEXT
+);
+
+CREATE INDEX IF NOT EXISTS events_scope_ts ON events(scope, ts DESC);
+`;
+  }
+});
+
+// ../cli/src/config.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { z } from "zod";
+async function loadVaultConfig(vaultRoot2) {
+  const path = join(vaultRoot2, "vault.yaml");
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    throw new Error(`vault.yaml not found at ${path}`, { cause: err });
+  }
+  const parsed = VaultConfigSchema.safeParse(parse(raw));
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new Error(`Invalid vault.yaml at ${path}:
+${issues}`);
+  }
+  return parsed.data;
+}
+var ScopeSchema, VaultConfigSchema;
+var init_config = __esm({
+  "../cli/src/config.ts"() {
+    "use strict";
+    ScopeSchema = z.object({
+      repo: z.string().optional(),
+      methodology: z.enum(["sdd", "tdd", "hybrid"]).optional(),
+      status: z.string()
+    });
+    VaultConfigSchema = z.object({
+      scopes: z.record(z.string(), ScopeSchema),
+      kinds: z.array(z.string()),
+      statuses: z.array(z.string()),
+      methodologies: z.array(z.string()),
+      tags: z.object({
+        canonical: z.array(z.string()),
+        aliases: z.record(z.string(), z.string())
+      })
+    });
+  }
+});
+
+// ../cli/src/frontmatter.ts
+import { parse as parseYaml } from "yaml";
+function parseFrontmatter(raw) {
+  const match = FRONTMATTER_RE.exec(raw);
+  if (!match) {
+    return { data: {}, content: raw };
+  }
+  const yamlText = match[1] ?? "";
+  const content = raw.slice(match[0].length);
+  if (yamlText.trim() === "") {
+    return { data: {}, content };
+  }
+  const parsed = parseYaml(yamlText);
+  const data = parsed !== null && typeof parsed === "object" ? parsed : {};
+  return { data, content };
+}
+var FRONTMATTER_RE;
+var init_frontmatter = __esm({
+  "../cli/src/frontmatter.ts"() {
+    "use strict";
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n?/;
+  }
+});
+
+// ../cli/src/sync.ts
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { readdir, readFile as readFile2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2, relative, sep } from "node:path";
+import { z as z2 } from "zod";
+function loadEnv() {
+  const parsed = EnvSchema.safeParse({
+    WIKI_VAULT: process.env.WIKI_VAULT
+  });
+  if (!parsed.success) {
+    console.error("invalid env:");
+    console.error(parsed.error.format());
+    process.exit(1);
+  }
+  return parsed.data;
+}
+async function walkMarkdown(root, domain) {
+  const out = [];
+  async function recurse(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (!entries) return;
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isDirectory()) {
+        await recurse(join2(dir, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        out.push(join2(dir, entry.name));
+      }
+    }
+  }
+  await recurse(join2(root, domain));
+  return out;
+}
+function toRelativePath(root, absolute) {
+  return relative(root, absolute).split(sep).join("/");
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function extractWikilinks(body) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of body.matchAll(WIKILINK_RE)) {
+    const rawTarget = match[1]?.trim() ?? "";
+    if (!rawTarget) continue;
+    const hasExt = /\.[a-zA-Z0-9]+$/.test(rawTarget);
+    const target = hasExt ? rawTarget : `${rawTarget}.md`;
+    const text = match[2]?.trim() ?? null;
+    const key = `${target}|${text ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    links.push({ target, text });
+  }
+  return links;
+}
+function deriveLocation(relPath) {
+  const segments = relPath.split("/");
+  const domain = segments[0];
+  if (domain === "projects" && segments.length >= 2 && segments[1]) {
+    return { scope: segments[1], topic: null };
+  }
+  if (domain === "research" && segments.length >= 2 && segments[1]) {
+    return { scope: null, topic: segments[1] };
+  }
+  return { scope: null, topic: null };
+}
+function buildPageFields(relPath, raw, parsed, knownScopes) {
+  const fm = parsed.data;
+  if (!fm.title) {
+    return null;
+  }
+  let kind = fm.kind;
+  if (!kind) {
+    if (relPath.startsWith("notes/")) {
+      kind = "note";
+    } else {
+      console.warn(`  skip: ${relPath} \u2014 has title but missing kind`);
+      return null;
+    }
+  }
+  const { scope, topic } = deriveLocation(relPath);
+  if (scope !== null && !knownScopes.has(scope)) {
+    throw new Error(
+      `unknown scope "${scope}" for ${relPath} \u2014 add it to vault.yaml or remove the page`
+    );
+  }
+  const updated = fm.updated instanceof Date ? fm.updated.toISOString().slice(0, 10) : typeof fm.updated === "string" ? fm.updated.slice(0, 10) : null;
+  const metaEntries = Object.entries(parsed.data).filter(
+    ([k]) => !INDEXED_FRONTMATTER_KEYS.has(k)
+  );
+  const meta = metaEntries.length > 0 ? Object.fromEntries(metaEntries) : null;
+  return {
+    path: relPath,
+    title: fm.title,
+    kind,
+    scope,
+    topic,
+    status: fm.status ?? (kind === "note" ? "active" : "draft"),
+    summary: fm.summary ?? null,
+    tags: Array.isArray(fm.tags) ? fm.tags : null,
+    updated,
+    body: parsed.content,
+    hash: sha256(raw),
+    meta
+  };
+}
+function syncPage(db, fields) {
+  const existing = db.prepare("SELECT content_hash FROM pages WHERE path = ?").get(fields.path);
+  if (existing?.content_hash === fields.hash) {
+    return "unchanged";
+  }
+  const upsert = db.prepare(
+    `INSERT INTO pages (path, title, kind, scope, topic, status, summary, tags, updated, body, content_hash, meta)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT (path) DO UPDATE SET
+       title        = EXCLUDED.title,
+       kind         = EXCLUDED.kind,
+       scope        = EXCLUDED.scope,
+       topic        = EXCLUDED.topic,
+       status       = EXCLUDED.status,
+       summary      = EXCLUDED.summary,
+       tags         = EXCLUDED.tags,
+       updated      = EXCLUDED.updated,
+       body         = EXCLUDED.body,
+       content_hash = EXCLUDED.content_hash,
+       meta         = EXCLUDED.meta`
+  );
+  upsert.run(
+    fields.path,
+    fields.title,
+    fields.kind,
+    fields.scope,
+    fields.topic,
+    fields.status,
+    fields.summary,
+    fields.tags ? JSON.stringify(fields.tags) : null,
+    fields.updated,
+    fields.body,
+    fields.hash,
+    fields.meta ? JSON.stringify(fields.meta) : null
+  );
+  db.prepare("DELETE FROM links WHERE source_path = ?").run(fields.path);
+  const insertLink = db.prepare(
+    `INSERT INTO links (source_path, target_path, link_text)
+     VALUES (?, ?, ?)
+     ON CONFLICT (source_path, target_path) DO NOTHING`
+  );
+  for (const link of extractWikilinks(fields.body)) {
+    insertLink.run(fields.path, link.target, link.text);
+  }
+  return "changed";
+}
+async function runSync() {
+  const env = loadEnv();
+  const dbDir = join2(homedir(), ".kmd", "db");
+  const dbPath = join2(dbDir, "index.db");
+  console.log(`sync: ${env.WIKI_VAULT} \u2192 ${dbPath}`);
+  const vaultConfig = await loadVaultConfig(env.WIKI_VAULT);
+  const scopes = new Set(Object.keys(vaultConfig.scopes));
+  mkdirSync(dbDir, { recursive: true });
+  const db = openDatabase(dbPath);
+  try {
+    const files = [];
+    for (const domain of SCAN_DOMAINS) {
+      files.push(...await walkMarkdown(env.WIKI_VAULT, domain));
+    }
+    const indexedPaths = [];
+    let changed = 0;
+    let unchanged = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const path = toRelativePath(env.WIKI_VAULT, file);
+      const raw = await readFile2(file, "utf8");
+      const parsed = parseFrontmatter(raw);
+      const fields = buildPageFields(path, raw, parsed, scopes);
+      if (!fields) {
+        skipped++;
+        continue;
+      }
+      const result = syncPage(db, fields);
+      if (result === "changed") {
+        changed++;
+      } else {
+        unchanged++;
+      }
+      indexedPaths.push(path);
+    }
+    let pagesDeleted = 0;
+    let linksDeleted = 0;
+    if (indexedPaths.length > 0) {
+      const placeholders = indexedPaths.map(() => "?").join(", ");
+      const pageResult = db.prepare(`DELETE FROM pages WHERE path NOT IN (${placeholders})`).run(...indexedPaths);
+      pagesDeleted = Number(pageResult.changes);
+      const linkResult = db.prepare("DELETE FROM links WHERE source_path NOT IN (SELECT path FROM pages)").run();
+      linksDeleted = Number(linkResult.changes);
+    } else {
+      console.warn("no indexable pages found; skipping orphan deletion (safety)");
+    }
+    db.exec("INSERT INTO pages_fts(pages_fts) VALUES('rebuild')");
+    console.log(
+      `done: ${changed} changed, ${unchanged} unchanged, ${skipped} skipped, ${pagesDeleted} pages deleted, ${linksDeleted} link orphans cleared`
+    );
+  } finally {
+    db.close();
+  }
+}
+var EnvSchema, SCAN_DOMAINS, WIKILINK_RE, INDEXED_FRONTMATTER_KEYS;
+var init_sync = __esm({
+  "../cli/src/sync.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_frontmatter();
+    EnvSchema = z2.object({
+      WIKI_VAULT: z2.string().min(1)
+    });
+    SCAN_DOMAINS = ["projects", "research", "notes"];
+    WIKILINK_RE = /\[\[([^\]|#^]+)(?:[#^][^\]|]*)?(?:\|([^\]]+))?\]\]/g;
+    INDEXED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+      "title",
+      "kind",
+      "status",
+      "summary",
+      "tags",
+      "updated",
+      "scope",
+      "topic"
+    ]);
+  }
+});
+
+// ../cli/src/validate.ts
+import { readFile as readFile3 } from "node:fs/promises";
+function isIndexed(relPath, data) {
+  if (typeof data.title !== "string" || data.title.trim() === "") return false;
+  if (typeof data.kind === "string" && data.kind !== "") return true;
+  return relPath.startsWith("notes/");
+}
+function isPrimer(relPath) {
+  return relPath === "primer.md" || relPath.endsWith("/primer.md");
+}
+function checkRequiredFields(relPath, data) {
+  const kind = typeof data.kind === "string" && data.kind !== "" ? data.kind : relPath.startsWith("notes/") ? "note" : void 0;
+  const required = kind ? REQUIRED_FIELDS[kind] : void 0;
+  if (!required) return [];
+  const findings = [];
+  for (const field of required) {
+    if (!Object.hasOwn(data, field)) {
+      findings.push({
+        path: relPath,
+        rule: "required-fields",
+        severity: "error",
+        message: `missing required field "${field}" for kind "${kind}"`
+      });
+    }
+  }
+  return findings;
+}
+function checkTagsRequired(relPath, data) {
+  const kind = typeof data.kind === "string" && data.kind !== "" ? data.kind : relPath.startsWith("notes/") ? "note" : void 0;
+  if (kind && TAG_OPTIONAL_KINDS.has(kind)) return [];
+  if (Array.isArray(data.tags) && data.tags.length > 0) return [];
+  return [
+    {
+      path: relPath,
+      rule: "tags-required",
+      severity: "error",
+      message: "tags must be present and non-empty (tags are open \u2014 any values, every content page tagged)"
+    }
+  ];
+}
+function checkFolderSlug(relPath, data) {
+  const kind = data.kind;
+  const pattern = typeof kind === "string" ? FOLDER_PATTERNS[kind] : void 0;
+  if (!pattern || pattern.test(relPath)) return [];
+  return [
+    {
+      path: relPath,
+      rule: "folder-slug",
+      severity: "error",
+      message: `path does not match the "${kind}" slug pattern ${pattern.source}`
+    }
+  ];
+}
+function checkVocabulary(relPath, data, cfg) {
+  const findings = [];
+  const kind = data.kind;
+  if (typeof kind === "string" && !cfg.kinds.includes(kind)) {
+    findings.push({
+      path: relPath,
+      rule: "kind-vocabulary",
+      severity: "error",
+      message: `kind "${kind}" is not in vault.yaml`
+    });
+  }
+  const status = data.status;
+  if (typeof status === "string" && !cfg.statuses.includes(status)) {
+    findings.push({
+      path: relPath,
+      rule: "status-vocabulary",
+      severity: "error",
+      message: `status "${status}" is not in vault.yaml`
+    });
+  }
+  const { scope } = deriveLocation(relPath);
+  if (scope !== null && !Object.hasOwn(cfg.scopes, scope)) {
+    findings.push({
+      path: relPath,
+      rule: "scope-vocabulary",
+      severity: "error",
+      message: `scope "${scope}" is not in vault.yaml`
+    });
+  }
+  const methodology = data.methodology;
+  if (typeof methodology === "string" && !cfg.methodologies.includes(methodology)) {
+    findings.push({
+      path: relPath,
+      rule: "methodology-vocabulary",
+      severity: "error",
+      message: `methodology "${methodology}" is not in vault.yaml`
+    });
+  }
+  return findings;
+}
+function checkScopePath(relPath, data) {
+  const { scope, topic } = deriveLocation(relPath);
+  const findings = [];
+  if (scope !== null && typeof data.scope === "string" && data.scope !== "" && data.scope !== scope) {
+    findings.push({
+      path: relPath,
+      rule: "path-authority",
+      severity: "error",
+      message: `frontmatter scope "${data.scope}" disagrees with path scope "${scope}"`
+    });
+  }
+  if (topic !== null && typeof data.topic === "string" && data.topic !== "" && data.topic !== topic) {
+    findings.push({
+      path: relPath,
+      rule: "path-authority",
+      severity: "error",
+      message: `frontmatter topic "${data.topic}" disagrees with path topic "${topic}"`
+    });
+  }
+  return findings;
+}
+function refTarget(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : basename(trimmed);
+}
+function refTargets(value) {
+  if (Array.isArray(value)) {
+    return value.map(refTarget).filter((t) => t !== null);
+  }
+  const single = refTarget(value);
+  return single === null ? [] : [single];
+}
+function stripCode(body) {
+  return body.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "");
+}
+function checkBodyLinks(relPath, body, refIndex) {
+  const findings = [];
+  for (const link of extractWikilinks(stripCode(body))) {
+    if (!link.target.endsWith(".md")) continue;
+    if (!refIndex.has(basename(link.target))) {
+      findings.push({
+        path: relPath,
+        rule: "dangling-link",
+        severity: "error",
+        message: `wikilink target "${link.target}" does not resolve`
+      });
+    }
+  }
+  return findings;
+}
+function checkReferences(relPath, data, body, refIndex) {
+  const findings = checkBodyLinks(relPath, body, refIndex);
+  const fieldRefs = [];
+  const parent = refTarget(data.parent);
+  if (parent !== null) fieldRefs.push(parent);
+  for (const field of ["supersedes", "superseded_by", "blocked_by"]) {
+    fieldRefs.push(...refTargets(data[field]));
+  }
+  for (const target of fieldRefs) {
+    if (!refIndex.has(target)) {
+      findings.push({
+        path: relPath,
+        rule: "ref-resolves",
+        severity: "error",
+        message: `frontmatter reference "${target}" does not resolve`
+      });
+    }
+  }
+  return findings;
+}
+function checkTags(relPath, data, cfg) {
+  if (!Array.isArray(data.tags)) return [];
+  const findings = [];
+  for (const tag of data.tags) {
+    if (typeof tag === "string" && Object.hasOwn(cfg.tags.aliases, tag)) {
+      findings.push({
+        path: relPath,
+        rule: "tag-alias",
+        severity: "warning",
+        message: `tag "${tag}" is an alias; use canonical "${cfg.tags.aliases[tag]}"`
+      });
+    }
+  }
+  return findings;
+}
+function checkSupersededLink(relPath, data) {
+  if (data.status === "superseded" && refTargets(data.superseded_by).length === 0) {
+    return [
+      {
+        path: relPath,
+        rule: "superseded-needs-link",
+        severity: "error",
+        message: 'status is "superseded" but superseded_by is empty'
+      }
+    ];
+  }
+  return [];
+}
+function checkIndexedPage(relPath, data, body, cfg, refIndex) {
+  if (!isIndexed(relPath, data)) return [];
+  return [
+    ...checkRequiredFields(relPath, data),
+    ...checkTagsRequired(relPath, data),
+    ...checkFolderSlug(relPath, data),
+    ...checkVocabulary(relPath, data, cfg),
+    ...checkScopePath(relPath, data),
+    ...checkReferences(relPath, data, body, refIndex),
+    ...checkSupersededLink(relPath, data),
+    ...checkTags(relPath, data, cfg)
+  ];
+}
+function validatePage(relPath, raw, cfg, refIndex) {
+  let parsed;
+  try {
+    parsed = parseFrontmatter(raw);
+  } catch (err) {
+    return [
+      {
+        path: relPath,
+        rule: "frontmatter-parse",
+        severity: "error",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    ];
+  }
+  if (isPrimer(relPath)) {
+    return checkBodyLinks(relPath, parsed.content, refIndex);
+  }
+  return checkIndexedPage(relPath, parsed.data, parsed.content, cfg, refIndex);
+}
+function hasErrors(findings) {
+  return findings.some((f) => f.severity === "error");
+}
+function basename(relPath) {
+  const last = relPath.split("/").pop() ?? relPath;
+  return last.replace(/\.md$/, "");
+}
+function validateSupersession(pages) {
+  const adrs = /* @__PURE__ */ new Map();
+  for (const { path, data } of pages) {
+    if (data.kind !== "adr") continue;
+    adrs.set(basename(path), {
+      path,
+      supersedes: refTargets(data.supersedes),
+      supersededBy: refTargets(data.superseded_by)
+    });
+  }
+  const findings = [];
+  for (const [name, adr] of adrs) {
+    for (const target of adr.supersededBy) {
+      const other = adrs.get(target);
+      if (other && !other.supersedes.includes(name)) {
+        findings.push({
+          path: adr.path,
+          rule: "supersession-reciprocal",
+          severity: "error",
+          message: `superseded_by "${target}" which does not declare supersedes "${name}"`
+        });
+      }
+    }
+    for (const target of adr.supersedes) {
+      const other = adrs.get(target);
+      if (other && !other.supersededBy.includes(name)) {
+        findings.push({
+          path: adr.path,
+          rule: "supersession-reciprocal",
+          severity: "error",
+          message: `supersedes "${target}" which does not declare superseded_by "${name}"`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function locationKey(relPath) {
+  const seg = relPath.split("/");
+  if ((seg[0] === "projects" || seg[0] === "research") && seg[1]) {
+    return `${seg[0]}/${seg[1]}`;
+  }
+  return null;
+}
+function validateAmbiguousLinks(pages, basenameToPaths) {
+  const findings = [];
+  for (const { path, body } of pages) {
+    const here = locationKey(path);
+    for (const link of extractWikilinks(stripCode(body))) {
+      if (!link.target.endsWith(".md") || link.target.includes("/")) continue;
+      const base = basename(link.target);
+      const owners = basenameToPaths.get(base);
+      if (!owners || owners.length < 2) continue;
+      if (here !== null && owners.some((p) => locationKey(p) === here)) continue;
+      findings.push({
+        path,
+        rule: "ambiguous-link",
+        severity: "warning",
+        message: `bare link "[[${base}]]" is ambiguous \u2014 basename owned by ${owners.length} files, none in this scope`
+      });
+    }
+  }
+  return findings;
+}
+async function validateVault(root) {
+  const cfg = await loadVaultConfig(root);
+  const all = (await walkMarkdown(root, ".")).map((abs) => ({
+    relPath: toRelativePath(root, abs),
+    abs
+  }));
+  const basenameToPaths = /* @__PURE__ */ new Map();
+  for (const f of all) {
+    const b = basename(f.relPath);
+    const owners = basenameToPaths.get(b);
+    if (owners) owners.push(f.relPath);
+    else basenameToPaths.set(b, [f.relPath]);
+  }
+  const refIndex = new Set(basenameToPaths.keys());
+  const files = all.filter((f) => SCAN_DOMAINS.some((d) => f.relPath.startsWith(`${d}/`)));
+  const findings = [];
+  const pages = [];
+  const linkPages = [];
+  for (const { relPath, abs } of files) {
+    const raw = await readFile3(abs, "utf8");
+    findings.push(...validatePage(relPath, raw, cfg, refIndex));
+    try {
+      const parsed = parseFrontmatter(raw);
+      pages.push({ path: relPath, data: parsed.data });
+      linkPages.push({ path: relPath, body: parsed.content });
+    } catch {
+    }
+  }
+  findings.push(...validateSupersession(pages));
+  findings.push(...validateAmbiguousLinks(linkPages, basenameToPaths));
+  return findings;
+}
+var REQUIRED_FIELDS, TAG_OPTIONAL_KINDS, FOLDER_PATTERNS;
+var init_validate = __esm({
+  "../cli/src/validate.ts"() {
+    "use strict";
+    init_config();
+    init_frontmatter();
+    init_sync();
+    REQUIRED_FIELDS = {
+      project: [
+        "title",
+        "kind",
+        "scope",
+        "status",
+        "summary",
+        "updated",
+        "methodology",
+        "phase",
+        "repo"
+      ],
+      spec: ["title", "kind", "scope", "status", "summary", "updated", "sources"],
+      adr: ["title", "kind", "scope", "status", "updated"],
+      plan: ["title", "kind", "scope", "status", "summary", "updated"],
+      ops: ["title", "kind", "scope", "status", "summary", "updated"],
+      story: [
+        "title",
+        "kind",
+        "scope",
+        "status",
+        "updated",
+        "parent",
+        "triage_state",
+        "category",
+        "blocked_by",
+        "sources"
+      ],
+      topic: ["title", "kind", "status", "summary", "updated", "confidence"],
+      article: ["title", "kind", "status", "updated"],
+      src: ["title", "kind", "topic", "status", "summary", "updated"],
+      note: ["title", "updated"]
+    };
+    TAG_OPTIONAL_KINDS = /* @__PURE__ */ new Set(["artifact", "prompt", "glossary-entry", "pso-roster"]);
+    FOLDER_PATTERNS = {
+      spec: /^projects\/[^/]+\/spec\/spec-[^/]+\.md$/,
+      adr: /^projects\/[^/]+\/adr\/adr-[^/]+\.md$/,
+      ops: /^projects\/[^/]+\/ops\/ops-[^/]+\.md$/,
+      plan: /^projects\/[^/]+\/plan\/plan-[^/]+\.md$/,
+      story: /^projects\/[^/]+\/plan\/[^/]+\/story-[^/]+\.md$/,
+      project: /^projects\/[^/]+\/index\.md$/,
+      topic: /^research\/[^/]+\/index\.md$/,
+      src: /^research\/[^/]+\/src-[^/]+\.md$/
+    };
+  }
+});
+
+// ../cli/src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main,
+  resolveCli: () => resolveCli,
+  runSyncCommand: () => runSyncCommand,
+  runValidate: () => runValidate,
+  vaultRoot: () => vaultRoot
+});
+import { parseArgs } from "node:util";
+function resolveCli(argv) {
+  const { positionals: positionals2 } = parseArgs({ args: argv, allowPositionals: true, strict: false });
+  const command2 = positionals2[0];
+  if (command2 === "sync") {
+    return { kind: "run", command: "sync" };
+  }
+  if (command2 === "validate") {
+    return { kind: "run", command: "validate" };
+  }
+  if (command2 === void 0) {
+    return { kind: "error", message: "usage: wiki <sync|validate>" };
+  }
+  return { kind: "error", message: `unknown command: ${command2}` };
+}
+function vaultRoot() {
+  const root = process.env.WIKI_VAULT;
+  if (!root) {
+    console.error("WIKI_VAULT is not set");
+    process.exit(1);
+  }
+  return root;
+}
+function reportFindings(findings) {
+  for (const f of findings) {
+    console.error(`${f.severity}: ${f.path} [${f.rule}] ${f.message}`);
+  }
+}
+async function runValidate() {
+  const findings = await validateVault(vaultRoot());
+  reportFindings(findings);
+  console.log(`validate: ${findings.length} finding(s)`);
+  process.exit(hasErrors(findings) ? 1 : 0);
+}
+async function runSyncCommand() {
+  const findings = await validateVault(vaultRoot());
+  reportFindings(findings);
+  if (hasErrors(findings)) {
+    const errors = findings.filter((f) => f.severity === "error").length;
+    console.error(`sync aborted: ${errors} validation error(s); no database writes`);
+    process.exit(1);
+  }
+  await runSync();
+}
+async function main() {
+  const resolution = resolveCli(process.argv.slice(2));
+  if (resolution.kind === "error") {
+    console.error(resolution.message);
+    process.exit(1);
+  }
+  if (resolution.command === "sync") {
+    await runSyncCommand();
+  } else {
+    await runValidate();
+  }
+}
+var init_cli = __esm({
+  "../cli/src/cli.ts"() {
+    "use strict";
+    init_sync();
+    init_validate();
+  }
+});
+
+// ../mcp/src/config.ts
+import { z as z3 } from "zod";
+function loadConfig(env = process.env) {
+  const parsed = EnvSchema2.safeParse(env);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new Error(`Invalid environment configuration:
+${issues}`);
+  }
+  return {
+    wikiVault: parsed.data.WIKI_VAULT,
+    logLevel: parsed.data.LOG_LEVEL,
+    serverName: parsed.data.SERVER_NAME,
+    serverVersion: parsed.data.SERVER_VERSION
+  };
+}
+var EnvSchema2;
+var init_config2 = __esm({
+  "../mcp/src/config.ts"() {
+    "use strict";
+    EnvSchema2 = z3.object({
+      WIKI_VAULT: z3.string().min(1).describe("Absolute path to the Obsidian vault root"),
+      LOG_LEVEL: z3.enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"]).default("info").describe("Pino log level. Logs go to stderr to keep the stdio JSON-RPC stream clean."),
+      SERVER_NAME: z3.string().default("wiki-mcp"),
+      SERVER_VERSION: z3.string().default("0.0.0")
+    });
+  }
+});
+
+// ../mcp/src/db.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+function createDatabase() {
+  const dbDir = join3(homedir2(), ".kmd", "db");
+  const dbPath = join3(dbDir, "index.db");
+  mkdirSync2(dbDir, { recursive: true });
+  return openDatabase(dbPath);
+}
+var init_db = __esm({
+  "../mcp/src/db.ts"() {
+    "use strict";
+    init_database();
+  }
+});
+
+// ../mcp/src/lib/diag.ts
+import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+function diag(msg, data) {
+  try {
+    const line = data ? `${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} ${msg} ${JSON.stringify(data)}
+` : `${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} ${msg}
+`;
+    appendFileSync(DIAG_LOG_PATH, line);
+  } catch {
+  }
+}
+var DIAG_DIR, DIAG_LOG_PATH;
+var init_diag = __esm({
+  "../mcp/src/lib/diag.ts"() {
+    "use strict";
+    DIAG_DIR = join4(homedir3(), ".local", "state", "wiki-mcp");
+    DIAG_LOG_PATH = join4(DIAG_DIR, "server.log");
+    try {
+      mkdirSync3(DIAG_DIR, { recursive: true });
+    } catch {
+    }
+  }
+});
+
+// ../mcp/src/lib/logger.ts
+import pino from "pino";
+function createLogger(level, name) {
+  const streams = [
+    { level, stream: pino.destination(2) },
+    {
+      level,
+      stream: pino.destination({ dest: DIAG_LOG_PATH, sync: false, mkdir: true })
+    }
+  ];
+  return pino({ name, level, base: { pid: process.pid } }, pino.multistream(streams));
+}
+var init_logger = __esm({
+  "../mcp/src/lib/logger.ts"() {
+    "use strict";
+    init_diag();
+  }
+});
+
+// ../mcp/src/resources/templates.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function registerTemplateResources(mcp, vaultRoot2) {
+  const dir = join5(vaultRoot2, "templates");
+  for (const tmpl of TEMPLATES) {
+    mcp.registerResource(
+      tmpl.name,
+      tmpl.uri,
+      { description: tmpl.description, mimeType: "text/markdown" },
+      async (uri) => {
+        const text = await readFile4(join5(dir, tmpl.file), "utf8");
+        return {
+          contents: [
+            {
+              uri: uri.toString(),
+              mimeType: "text/markdown",
+              text
+            }
+          ]
+        };
+      }
+    );
+  }
+}
+var TEMPLATES;
+var init_templates = __esm({
+  "../mcp/src/resources/templates.ts"() {
+    "use strict";
+    TEMPLATES = [
+      {
+        uri: "wiki://template/project/index",
+        name: "Project index",
+        file: "project-index.md",
+        description: "Identity card for a project. Frontmatter-heavy: methodology, phase, repo, scope, summary, tags. Short body."
+      },
+      {
+        uri: "wiki://template/project/primer",
+        name: "Project primer",
+        file: "project-primer.md",
+        description: "Human-authored narrative context for a project. Free-form body. Inlined into the prime tool response."
+      },
+      {
+        uri: "wiki://template/project/spec",
+        name: "Project spec",
+        file: "project-spec.md",
+        description: "Specification page \u2014 how a system or feature works (state of the world, not decision)."
+      },
+      {
+        uri: "wiki://template/project/adr",
+        name: "Project ADR",
+        file: "project-adr.md",
+        description: "Architecture Decision Record \u2014 pinned moment of choice. Sections: Status, Context, Decision, Rationale, Consequences."
+      },
+      {
+        uri: "wiki://template/project/plan",
+        name: "Project plan",
+        file: "project-plan.md",
+        description: "Plan for a phase or initiative. Sections: Goal, Scope, Milestones, Dependencies, Status Log."
+      },
+      {
+        uri: "wiki://template/project/ops",
+        name: "Project ops",
+        file: "project-ops.md",
+        description: "Operational runbook \u2014 how to run or operate a system. Procedural."
+      },
+      {
+        uri: "wiki://template/project/story",
+        name: "Project story",
+        file: "project-story.md",
+        description: "User story with Gherkin scenarios and inline implementation slices. Lives at plan/{plan-name}/story-N-{slug}.md. Frontmatter carries triage_state, category, blocked_by, parent."
+      },
+      {
+        uri: "wiki://template/research/index",
+        name: "Research index",
+        file: "research-index.md",
+        description: "Topic identity card for a research area. Frontmatter: confidence, source_count, summary, tags."
+      },
+      {
+        uri: "wiki://template/research/article",
+        name: "Research article",
+        file: "research-article.md",
+        description: "Wikipedia-style article about a concept, entity, or system. Original synthesis with sources."
+      },
+      {
+        uri: "wiki://template/research/src",
+        name: "Research source",
+        file: "research-src.md",
+        description: "Summary of an external source (paper, talk, doc) with citation. The only `src-` prefix in research."
+      },
+      {
+        uri: "wiki://template/note",
+        name: "Note",
+        file: "note.md",
+        description: "Low-ceremony everyday note. Capture fast, sort later."
+      }
+    ];
+  }
+});
+
+// ../mcp/src/frontmatter.ts
+import { parse as parseYaml2 } from "yaml";
+function parseFrontmatter2(raw) {
+  const match = FRONTMATTER_RE2.exec(raw);
+  if (!match) {
+    return { data: {}, content: raw };
+  }
+  const yamlText = match[1] ?? "";
+  const content = raw.slice(match[0].length);
+  if (yamlText.trim() === "") {
+    return { data: {}, content };
+  }
+  const parsed = parseYaml2(yamlText);
+  const data = parsed !== null && typeof parsed === "object" ? parsed : {};
+  return { data, content };
+}
+var FRONTMATTER_RE2;
+var init_frontmatter2 = __esm({
+  "../mcp/src/frontmatter.ts"() {
+    "use strict";
+    FRONTMATTER_RE2 = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n?/;
+  }
+});
+
+// ../mcp/src/lib/toolResponse.ts
+function textJson(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}
+function textWithStruct(markdown, data) {
+  return {
+    content: [{ type: "text", text: markdown }],
+    structuredContent: data
+  };
+}
+function textError(error) {
+  const payload = {
+    code: error.code,
+    message: error.message,
+    details: error.details ?? {}
+  };
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: payload
+  };
+}
+var init_toolResponse = __esm({
+  "../mcp/src/lib/toolResponse.ts"() {
+    "use strict";
+  }
+});
+
+// ../mcp/src/tools/prime.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename as basename2, join as join6 } from "node:path";
+import { z as z4 } from "zod";
+function pathSlug(p) {
+  return basename2(p).replace(/\.md$/, "");
+}
+async function readIndexFm(vaultRoot2, scope) {
+  try {
+    const raw = await readFile5(join6(vaultRoot2, "projects", scope, "index.md"), "utf8");
+    return parseFrontmatter2(raw).data;
+  } catch {
+    return {};
+  }
+}
+async function readPrimer(vaultRoot2, scope) {
+  try {
+    const raw = await readFile5(join6(vaultRoot2, "projects", scope, "primer.md"), "utf8");
+    return parseFrontmatter2(raw).content.trim().replace(/^#\s+[^\n]+\n+/, "");
+  } catch {
+    return "";
+  }
+}
+function sanitizeFtsQuery(raw) {
+  return raw.split(/\s+/).map((t) => t.replace(/["\-*():^]/g, "")).filter((t) => t.length > 0 && !FTS5_KEYWORDS.has(t)).join(" ");
+}
+async function prime(deps, input) {
+  const { db, vaultRoot: vaultRoot2, vaultConfig } = deps;
+  const { scope, task } = input;
+  const [fm, primer] = await Promise.all([
+    readIndexFm(vaultRoot2, scope),
+    readPrimer(vaultRoot2, scope)
+  ]);
+  const counts = db.prepare("SELECT kind, count(*) AS count FROM pages WHERE scope = ? GROUP BY kind").all(scope);
+  const adrs = db.prepare(
+    "SELECT path, title, summary FROM pages WHERE scope = ? AND kind = 'adr' AND status = 'active' ORDER BY updated DESC"
+  ).all(scope);
+  const planRow = db.prepare(
+    "SELECT path, title FROM pages WHERE scope = ? AND kind = 'plan' AND status = 'active' ORDER BY updated DESC LIMIT 1"
+  ).get(scope);
+  const tags = db.prepare(
+    `SELECT j.value AS tag, count(*) AS cnt
+       FROM pages, json_each(pages.tags) AS j
+       WHERE scope = ?
+       GROUP BY j.value
+       ORDER BY cnt DESC
+       LIMIT 10`
+  ).all(scope);
+  const hubs = db.prepare(
+    `SELECT p.path, p.title, count(*) AS inbound
+       FROM links l JOIN pages p ON p.path = l.target_path
+       WHERE p.scope = ?
+       GROUP BY p.path, p.title
+       ORDER BY inbound DESC LIMIT 5`
+  ).all(scope);
+  const events = db.prepare("SELECT path, operation, ts FROM events WHERE scope = ? ORDER BY ts DESC LIMIT 5").all(scope);
+  const crossScope = db.prepare(
+    `SELECT pf.scope AS from_scope, l.source_path AS from_path, l.target_path AS to_path
+       FROM links l
+       JOIN pages pt ON pt.path = l.target_path
+       JOIN pages pf ON pf.path = l.source_path
+       WHERE pt.scope = ? AND pf.scope IS NOT NULL AND pf.scope != ?
+       LIMIT 10`
+  ).all(scope, scope);
+  let relevant = [];
+  if (task) {
+    const ftsQuery = sanitizeFtsQuery(task);
+    if (ftsQuery) {
+      relevant = db.prepare(
+        `SELECT p.path, p.title, bm25(pages_fts) AS score
+             FROM pages_fts
+             JOIN pages p ON p.id = pages_fts.rowid
+             WHERE pages_fts MATCH ? AND p.scope = ?
+             ORDER BY bm25(pages_fts) LIMIT 3`
+      ).all(ftsQuery, scope).map((row) => ({
+        path: row.path,
+        title: row.title,
+        score: row.score
+      }));
+    }
+  }
+  const countsRecord = {};
+  for (const row of counts) countsRecord[row.kind] = Number(row.count);
+  const data = {
+    scope,
+    title: fm.title ?? null,
+    methodology: fm.methodology ?? null,
+    phase: typeof fm.phase === "number" ? fm.phase : null,
+    summary: fm.summary ?? "",
+    primer,
+    counts: countsRecord,
+    active_adrs: adrs.map((r) => ({
+      path: r.path,
+      slug: pathSlug(r.path),
+      title: r.title,
+      summary: r.summary
+    })),
+    current_plan: planRow ? {
+      path: planRow.path,
+      slug: pathSlug(planRow.path),
+      title: planRow.title
+    } : null,
+    top_tags: tags.map((r) => r.tag),
+    hub_pages: hubs.map((r) => ({
+      path: r.path,
+      title: r.title,
+      inbound: Number(r.inbound)
+    })),
+    recent: events.map((r) => ({
+      path: r.path,
+      operation: r.operation,
+      date: r.ts.slice(0, 10)
+    })),
+    relevant,
+    cross_scope: crossScope.map((r) => ({
+      from_scope: r.from_scope,
+      from_path: r.from_path,
+      to_path: r.to_path
+    }))
+  };
+  return { markdown: renderMarkdown(data, vaultConfig, task), data };
+}
+function renderMarkdown(d, config, task) {
+  const lines = [];
+  const phaseLabel = d.phase !== null ? d.methodology ? `Phase ${d.phase} (${d.methodology})` : `Phase ${d.phase}` : "";
+  const header = phaseLabel ? `${d.scope} \u2014 ${phaseLabel}` : d.scope;
+  lines.push(`# ${header}`);
+  if (d.summary) lines.push(d.summary);
+  if (d.primer) {
+    lines.push("", "## Primer", d.primer);
+  }
+  if (d.active_adrs.length > 0) {
+    lines.push("", "## Active Decisions");
+    for (const a of d.active_adrs) {
+      lines.push(`- ${a.slug}: ${a.summary ?? a.title}`);
+    }
+  }
+  if (d.current_plan) {
+    lines.push("", "## Current Plan");
+    lines.push(`${d.current_plan.slug}: ${d.current_plan.title}`);
+  }
+  const countEntries = Object.entries(d.counts);
+  if (countEntries.length > 0) {
+    lines.push("", "## Pages");
+    lines.push(countEntries.map(([k, n]) => `${k}: ${n}`).join(" | "));
+  }
+  lines.push("", "## Vocabulary");
+  lines.push(`kinds: ${config.kinds.join(", ")}`);
+  lines.push(`statuses: ${config.statuses.join(", ")}`);
+  lines.push(`tags: ${config.tags.canonical.join(", ")}`);
+  if (d.top_tags.length > 0) {
+    lines.push("", "## Tags");
+    lines.push(d.top_tags.join(", "));
+  }
+  if (d.hub_pages.length > 0) {
+    lines.push("", "## Hubs");
+    for (const h of d.hub_pages) {
+      lines.push(`- ${pathSlug(h.path)} (${h.inbound} inbound)`);
+    }
+  }
+  if (d.recent.length > 0) {
+    lines.push("", "## Recent");
+    for (const r of d.recent) {
+      lines.push(`- [${r.date}] ${pathSlug(r.path)} ${r.operation}`);
+    }
+  }
+  if (d.relevant.length > 0) {
+    lines.push("", `## Relevant (task: "${task}")`);
+    for (const r of d.relevant) {
+      lines.push(`- ${pathSlug(r.path)} (${r.score.toFixed(2)})`);
+    }
+  }
+  if (d.cross_scope.length > 0) {
+    lines.push("", "## Cross-scope");
+    for (const c of d.cross_scope) {
+      lines.push(`- ${c.from_scope}/${pathSlug(c.from_path)} \u2192 ${pathSlug(c.to_path)}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function handlePrime(deps, input) {
+  if (!Object.hasOwn(deps.vaultConfig.scopes, input.scope)) {
+    const valid = Object.keys(deps.vaultConfig.scopes).sort().join(", ");
+    return textError({
+      code: "UNKNOWN_SCOPE",
+      message: `unknown scope "${input.scope}"; valid scopes: ${valid}`
+    });
+  }
+  try {
+    const { markdown, data } = await prime(deps, input);
+    return textWithStruct(markdown, data);
+  } catch (err) {
+    return textError({
+      code: "PRIME_FAILED",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var PrimeInputSchema, FTS5_KEYWORDS;
+var init_prime = __esm({
+  "../mcp/src/tools/prime.ts"() {
+    "use strict";
+    init_frontmatter2();
+    init_toolResponse();
+    PrimeInputSchema = z4.object({
+      scope: z4.string().min(1).describe("Project scope to prime (matches projects/{scope}/ in the vault)."),
+      task: z4.string().optional().describe("Optional task description; surfaces top-3 tsvector-ranked relevant pages.")
+    });
+    FTS5_KEYWORDS = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
+  }
+});
+
+// ../mcp/src/tools/search.ts
+import { z as z5 } from "zod";
+function sanitizeFtsQuery2(raw) {
+  return raw.split(/\s+/).map((t) => t.replace(/["\-*():^]/g, "")).filter((t) => t.length > 0 && !FTS5_KEYWORDS2.has(t)).join(" ");
+}
+function search(deps, input) {
+  const ftsQuery = sanitizeFtsQuery2(input.query);
+  if (!ftsQuery) return { results: [] };
+  let sql = `SELECT p.path, p.title, p.kind, p.summary, p.scope, bm25(pages_fts) AS score
+     FROM pages_fts
+     JOIN pages p ON p.id = pages_fts.rowid
+     WHERE pages_fts MATCH ?`;
+  const params = [ftsQuery];
+  if (input.scope) {
+    sql += " AND p.scope = ?";
+    params.push(input.scope);
+  }
+  if (input.kind) {
+    sql += " AND p.kind = ?";
+    params.push(input.kind);
+  }
+  sql += " ORDER BY bm25(pages_fts) LIMIT ?";
+  params.push(input.limit);
+  const rows = deps.db.prepare(sql).all(...params);
+  return {
+    results: rows.map((r) => ({
+      path: r.path,
+      title: r.title,
+      kind: r.kind,
+      summary: r.summary,
+      scope: r.scope,
+      score: r.score
+    }))
+  };
+}
+function handleSearch(deps, input) {
+  try {
+    return textJson(search(deps, input));
+  } catch (err) {
+    return textError({
+      code: "SEARCH_FAILED",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var SearchInputSchema, FTS5_KEYWORDS2;
+var init_search = __esm({
+  "../mcp/src/tools/search.ts"() {
+    "use strict";
+    init_toolResponse();
+    SearchInputSchema = z5.object({
+      query: z5.string().min(1).describe(
+        "Natural-language search query. Matched against title, summary, and body via SQLite FTS5."
+      ),
+      scope: z5.string().optional().describe('Optional: restrict to a project scope (e.g. "ontology", "sotto").'),
+      kind: z5.string().optional().describe(
+        "Optional: restrict to a kind. Project kinds: spec, adr, plan, ops. Research kinds: article, src. Misc: note."
+      ),
+      limit: z5.number().int().min(1).max(50).default(5).describe("Maximum number of ranked results to return. Default 5.")
+    });
+    FTS5_KEYWORDS2 = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
+  }
+});
+
+// ../mcp/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function buildServer(args) {
+  const { name, version, vaultRoot: vaultRoot2, db, logger, vaultConfig } = args;
+  const mcp = new McpServer({ name, version }, { capabilities: { tools: {}, resources: {} } });
+  mcp.tool(
+    "prime",
+    "Orient on a project. Returns a markdown briefing with: identity (scope, phase, methodology, summary), the human-authored primer.md inlined, active ADRs, current plan, page counts, top tags, hub pages (most-linked-to), recent events, cross-scope references, and \u2014 when `task` is provided \u2014 the top 3 tsvector-ranked relevant pages. Call once at session start. Empty sections are omitted to keep the surface lean.",
+    PrimeInputSchema.shape,
+    async (input) => {
+      logger.debug({ tool: "prime", input }, "tool call");
+      return handlePrime({ db, vaultRoot: vaultRoot2, vaultConfig }, input);
+    }
+  );
+  mcp.tool(
+    "search",
+    "Full-text search across wiki pages via SQLite FTS5. Returns ranked candidates {path, title, kind, summary, score} \u2014 never page bodies. The agent reads the returned paths directly from the filesystem.",
+    SearchInputSchema.shape,
+    async (input) => {
+      logger.debug({ tool: "search", input }, "tool call");
+      return handleSearch({ db }, input);
+    }
+  );
+  registerTemplateResources(mcp, vaultRoot2);
+  return mcp;
+}
+var init_server = __esm({
+  "../mcp/src/server.ts"() {
+    "use strict";
+    init_templates();
+    init_prime();
+    init_search();
+  }
+});
+
+// ../mcp/src/vault-config.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { parse as parse2 } from "yaml";
+import { z as z6 } from "zod";
+async function loadVaultConfig2(vaultRoot2) {
+  const path = join7(vaultRoot2, "vault.yaml");
+  let raw;
+  try {
+    raw = await readFile6(path, "utf8");
+  } catch (err) {
+    throw new Error(`vault.yaml not found at ${path}`, { cause: err });
+  }
+  const parsed = VaultConfigSchema2.safeParse(parse2(raw));
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new Error(`Invalid vault.yaml at ${path}:
+${issues}`);
+  }
+  return parsed.data;
+}
+var ScopeSchema2, VaultConfigSchema2;
+var init_vault_config = __esm({
+  "../mcp/src/vault-config.ts"() {
+    "use strict";
+    ScopeSchema2 = z6.object({
+      repo: z6.string().optional(),
+      methodology: z6.enum(["sdd", "tdd", "hybrid"]).optional(),
+      status: z6.string()
+    });
+    VaultConfigSchema2 = z6.object({
+      scopes: z6.record(z6.string(), ScopeSchema2),
+      kinds: z6.array(z6.string()),
+      statuses: z6.array(z6.string()),
+      methodologies: z6.array(z6.string()),
+      tags: z6.object({
+        canonical: z6.array(z6.string()),
+        aliases: z6.record(z6.string(), z6.string())
+      })
+    });
+  }
+});
+
+// ../mcp/src/start.ts
+var start_exports = {};
+__export(start_exports, {
+  startMcpServer: () => startMcpServer
+});
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startMcpServer() {
+  diag("main entered");
+  const config = loadConfig();
+  diag("config loaded", { vault: config.wikiVault, level: config.logLevel });
+  const vaultConfig = await loadVaultConfig2(config.wikiVault);
+  diag("vault config loaded", {
+    scopes: Object.keys(vaultConfig.scopes).length,
+    kinds: vaultConfig.kinds.length,
+    statuses: vaultConfig.statuses.length
+  });
+  const logger = createLogger(config.logLevel, config.serverName);
+  logger.info(
+    { vault: config.wikiVault, serverName: config.serverName, serverVersion: config.serverVersion },
+    "starting wiki-mcp on stdio"
+  );
+  const db = createDatabase();
+  diag("database opened");
+  const mcp = buildServer({
+    name: config.serverName,
+    version: config.serverVersion,
+    vaultRoot: config.wikiVault,
+    db,
+    logger,
+    vaultConfig
+  });
+  diag("server built");
+  const shutdown = async (signal) => {
+    logger.info({ signal }, "shutting down");
+    diag("shutting down", { signal });
+    try {
+      await mcp.close();
+      db.close();
+    } catch (err) {
+      logger.error({ err }, "error during shutdown");
+    }
+    process.exit(0);
+  };
+  process.once("SIGINT", (s) => void shutdown(s));
+  process.once("SIGTERM", (s) => void shutdown(s));
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  logger.info("wiki-mcp ready");
+  diag("ready and connected to transport");
+}
+var init_start = __esm({
+  "../mcp/src/start.ts"() {
+    "use strict";
+    init_config2();
+    init_db();
+    init_diag();
+    init_logger();
+    init_server();
+    init_vault_config();
+  }
+});
+
+// bin/kmd.ts
+import { parseArgs as parseArgs2 } from "node:util";
+var USAGE = `usage: kmd <command> [options]
+
+commands:
+  sync                 vault \u2192 index sync (runs validate first)
+  validate [<path>]    deterministic vault checker (default: $WIKI_VAULT)
+  mcp [<vault-root>]   start the stdio MCP server (default: $WIKI_VAULT)
+  db reset             delete and recreate the index
+
+options:
+  --version   print version
+  --help      show this help`;
+var { positionals, values } = parseArgs2({
+  args: process.argv.slice(2),
+  allowPositionals: true,
+  strict: false,
+  options: {
+    version: { type: "boolean", short: "v" },
+    help: { type: "boolean", short: "h" }
+  }
+});
+var command = values.version ? "--version" : values.help ? "--help" : positionals[0];
+function applyVaultRoot(positionalIndex) {
+  const arg = positionals[positionalIndex];
+  if (arg) {
+    process.env.WIKI_VAULT = arg;
+  }
+}
+async function run() {
+  switch (command) {
+    case "sync": {
+      const { runSyncCommand: runSyncCommand2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+      await runSyncCommand2();
+      break;
+    }
+    case "validate": {
+      applyVaultRoot(1);
+      const { runValidate: runValidate2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+      await runValidate2();
+      break;
+    }
+    case "mcp": {
+      applyVaultRoot(1);
+      const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_start(), start_exports));
+      await startMcpServer2();
+      break;
+    }
+    case "db": {
+      const sub = positionals[1];
+      if (sub === "reset") {
+        const { homedir: homedir4 } = await import("node:os");
+        const { join: join8 } = await import("node:path");
+        const { unlinkSync } = await import("node:fs");
+        const dbPath = join8(homedir4(), ".kmd", "db", "index.db");
+        let deleted = false;
+        for (const suffix of ["", "-wal", "-shm"]) {
+          try {
+            unlinkSync(dbPath + suffix);
+            deleted = true;
+          } catch (err) {
+            if (err.code !== "ENOENT") throw err;
+          }
+        }
+        console.log(deleted ? `deleted ${dbPath}` : `${dbPath} does not exist \u2014 nothing to reset`);
+      } else {
+        console.error(sub ? `unknown db subcommand: ${sub}` : "usage: kmd db reset");
+        process.exit(2);
+      }
+      break;
+    }
+    case "--version":
+    case "-v": {
+      const { readFileSync } = await import("node:fs");
+      const { join: join8, dirname } = await import("node:path");
+      const { fileURLToPath } = await import("node:url");
+      const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+      const pkg = JSON.parse(readFileSync(join8(pkgDir, "package.json"), "utf8"));
+      console.log(pkg.version);
+      break;
+    }
+    case "--help":
+    case "-h":
+    case void 0: {
+      console.log(USAGE);
+      if (command === void 0) process.exit(2);
+      break;
+    }
+    default: {
+      console.error(`unknown command: ${command}
+
+${USAGE}`);
+      process.exit(2);
+    }
+  }
+}
+run().catch((err) => {
+  console.error("kmd failed:", err instanceof Error ? err.stack ?? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=kmd.mjs.map