@bartolli/kmd 0.4.0 → 0.5.1

package/dist/kmd.mjs

@@ -15,6 +15,10 @@ var __export = (target, all) => {
 };
 
 // ../db/src/database.ts
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function openDatabase(dbPath) {
   const db = new DatabaseSync(dbPath);
@@ -23,6 +27,34 @@ function openDatabase(dbPath) {
   db.exec(SCHEMA);
   return db;
 }
+function indexRootDir() {
+  const home = process.env.KMD_HOME ?? join(homedir(), ".kmd");
+  return join(home, "db");
+}
+function canonicalVaultRoot(vaultRoot2) {
+  try {
+    return realpathSync(vaultRoot2);
+  } catch {
+    return resolve(vaultRoot2);
+  }
+}
+function vaultKey(vaultRoot2) {
+  const canonical = canonicalVaultRoot(vaultRoot2);
+  const hash = createHash("sha256").update(canonical).digest("hex").slice(0, 8);
+  return `${basename(canonical)}-${hash}`;
+}
+function resolveIndexPath(vaultRoot2) {
+  return join(indexRootDir(), vaultKey(vaultRoot2), "index.db");
+}
+function getMeta(db, key) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setMeta(db, key, value) {
+  db.prepare(
+    "INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(key, value);
+}
 var SCHEMA;
 var init_database = __esm({
   "../db/src/database.ts"() {
@@ -73,20 +105,25 @@ CREATE TABLE IF NOT EXISTS events (
 );
 
 CREATE INDEX IF NOT EXISTS events_scope_ts ON events(scope, ts DESC);
+
+CREATE TABLE IF NOT EXISTS meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
 `;
   }
 });
 
 // ../cli/src/config.ts
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { parse } from "yaml";
 import { z } from "zod";
 function kindName(entry) {
   return typeof entry === "string" ? entry : entry.name;
 }
 async function loadVaultConfig(vaultRoot2) {
-  const path = join(vaultRoot2, "vault.yaml");
+  const path = join2(vaultRoot2, "vault.yaml");
   let raw;
   try {
     raw = await readFile(path, "utf8");
@@ -184,11 +221,10 @@ var init_frontmatter = __esm({
 });
 
 // ../cli/src/sync.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } 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 { dirname, join as join3, relative, sep } from "node:path";
 import { z as z2 } from "zod";
 function loadEnv() {
   const parsed = EnvSchema.safeParse({
@@ -209,20 +245,20 @@ async function walkMarkdown(root, domain) {
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       if (entry.isDirectory()) {
-        await recurse(join2(dir, entry.name));
+        await recurse(join3(dir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        out.push(join2(dir, entry.name));
+        out.push(join3(dir, entry.name));
       }
     }
   }
-  await recurse(join2(root, domain));
+  await recurse(join3(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");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function extractWikilinks(body) {
   const links = [];
@@ -339,12 +375,11 @@ function syncPage(db, fields) {
 }
 async function runSync() {
   const env = loadEnv();
-  const dbDir = join2(homedir(), ".kmd", "db");
-  const dbPath = join2(dbDir, "index.db");
+  const dbPath = resolveIndexPath(env.WIKI_VAULT);
   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 });
+  mkdirSync(dirname(dbPath), { recursive: true });
   const db = openDatabase(dbPath);
   try {
     const files = [];
@@ -384,6 +419,8 @@ async function runSync() {
       console.warn("no indexable pages found; skipping orphan deletion (safety)");
     }
     db.exec("INSERT INTO pages_fts(pages_fts) VALUES('rebuild')");
+    setMeta(db, "vault_root", canonicalVaultRoot(env.WIKI_VAULT));
+    setMeta(db, "last_synced", (/* @__PURE__ */ new Date()).toISOString());
     console.log(
       `done: ${changed} changed, ${unchanged} unchanged, ${skipped} skipped, ${pagesDeleted} pages deleted, ${linksDeleted} link orphans cleared`
     );
@@ -418,7 +455,7 @@ var init_sync = __esm({
 
 // ../cli/src/validate.ts
 import { readFile as readFile3, stat } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function hasIndexableTitle(data) {
   return typeof data.title === "string" && data.title.trim() !== "";
 }
@@ -576,7 +613,7 @@ function checkScopePath(relPath, data) {
 function refTarget(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
-  return trimmed === "" ? null : basename(trimmed);
+  return trimmed === "" ? null : basename2(trimmed);
 }
 function refTargets(value) {
   if (Array.isArray(value)) {
@@ -592,7 +629,7 @@ 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))) {
+    if (!refIndex.has(basename2(link.target))) {
       findings.push({
         path: relPath,
         rule: "dangling-link",
@@ -689,7 +726,7 @@ function validatePage(relPath, raw, cfg, refIndex) {
 function hasErrors(findings) {
   return findings.some((f) => f.severity === "error");
 }
-function basename(relPath) {
+function basename2(relPath) {
   const last = relPath.split("/").pop() ?? relPath;
   return last.replace(/\.md$/, "");
 }
@@ -697,7 +734,7 @@ function validateSupersession(pages) {
   const adrs = /* @__PURE__ */ new Map();
   for (const { path, data } of pages) {
     if (data.kind !== "adr") continue;
-    adrs.set(basename(path), {
+    adrs.set(basename2(path), {
       path,
       supersedes: refTargets(data.supersedes),
       supersededBy: refTargets(data.superseded_by)
@@ -743,7 +780,7 @@ function validateAmbiguousLinks(pages, basenameToPaths) {
     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 base = basename2(link.target);
       const owners = basenameToPaths.get(base);
       if (!owners || owners.length < 2) continue;
       if (here !== null && owners.some((p) => locationKey(p) === here)) continue;
@@ -765,7 +802,7 @@ async function validateVault(root) {
   }));
   const basenameToPaths = /* @__PURE__ */ new Map();
   for (const f of all) {
-    const b = basename(f.relPath);
+    const b = basename2(f.relPath);
     const owners = basenameToPaths.get(b);
     if (owners) owners.push(f.relPath);
     else basenameToPaths.set(b, [f.relPath]);
@@ -790,7 +827,7 @@ async function validateVault(root) {
   for (const name of customKindNames(cfg)) {
     const file = `templates/${name}.md`;
     try {
-      await stat(join3(root, file));
+      await stat(join4(root, file));
     } catch {
       findings.push({
         path: file,
@@ -862,10 +899,14 @@ var cli_exports = {};
 __export(cli_exports, {
   main: () => main,
   resolveCli: () => resolveCli,
+  runConfig: () => runConfig,
+  runDbReset: () => runDbReset,
   runSyncCommand: () => runSyncCommand,
   runValidate: () => runValidate,
   vaultRoot: () => vaultRoot
 });
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 import { parseArgs } from "node:util";
 function resolveCli(argv) {
   const { positionals: positionals2 } = parseArgs({ args: argv, allowPositionals: true, strict: false });
@@ -910,6 +951,76 @@ async function runSyncCommand() {
   }
   await runSync();
 }
+function describeVault(root) {
+  const vault = canonicalVaultRoot(root);
+  const index = resolveIndexPath(vault);
+  let synced = "never";
+  if (existsSync(index)) {
+    const db = openDatabase(index);
+    try {
+      synced = getMeta(db, "last_synced") ?? "never";
+    } finally {
+      db.close();
+    }
+  }
+  return { vault, index, synced };
+}
+function printVault(d) {
+  console.log(`vault: ${d.vault}`);
+  console.log(`index: ${d.index}`);
+  console.log(`synced: ${d.synced}`);
+}
+function knownVaults() {
+  const root = indexRootDir();
+  if (!existsSync(root)) return [];
+  const known = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const index = join5(root, entry.name, "index.db");
+    if (!existsSync(index)) continue;
+    const db = openDatabase(index);
+    try {
+      const vault = getMeta(db, "vault_root");
+      if (vault === null) continue;
+      known.push({ vault, index, synced: getMeta(db, "last_synced") ?? "never" });
+    } finally {
+      db.close();
+    }
+  }
+  return known;
+}
+async function runConfig() {
+  const root = process.env.WIKI_VAULT;
+  if (root) {
+    printVault(describeVault(root));
+    return;
+  }
+  const known = knownVaults();
+  if (known.length === 0) {
+    console.error(
+      "no vault specified and none known \u2014 pass a vault root, set WIKI_VAULT, or run `kmd sync <vault-root>` once"
+    );
+    process.exit(1);
+  }
+  known.forEach((d, i) => {
+    if (i > 0) console.log("");
+    printVault(d);
+  });
+}
+async function runDbReset() {
+  const root = process.env.WIKI_VAULT;
+  if (!root) {
+    console.error("usage: kmd db reset [<vault-root>] (or set WIKI_VAULT)");
+    process.exit(2);
+  }
+  const dir = dirname2(resolveIndexPath(root));
+  if (!existsSync(dir)) {
+    console.log(`${dir} does not exist \u2014 nothing to reset`);
+    return;
+  }
+  rmSync(dir, { recursive: true, force: true });
+  console.log(`deleted ${dir}`);
+}
 async function main() {
   const resolution = resolveCli(process.argv.slice(2));
   if (resolution.kind === "error") {
@@ -925,6 +1036,7 @@ async function main() {
 var init_cli = __esm({
   "../cli/src/cli.ts"() {
     "use strict";
+    init_database();
     init_sync();
     init_validate();
   }
@@ -961,13 +1073,13 @@ var init_config2 = __esm({
 
 // ../mcp/src/db.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
-function createDatabase() {
-  const dbDir = join4(homedir2(), ".kmd", "db");
-  const dbPath = join4(dbDir, "index.db");
-  mkdirSync2(dbDir, { recursive: true });
-  return openDatabase(dbPath);
+import { dirname as dirname3 } from "node:path";
+function createDatabase(vaultRoot2) {
+  const dbPath = resolveIndexPath(vaultRoot2);
+  mkdirSync2(dirname3(dbPath), { recursive: true });
+  const db = openDatabase(dbPath);
+  setMeta(db, "vault_root", canonicalVaultRoot(vaultRoot2));
+  return db;
 }
 var init_db = __esm({
   "../mcp/src/db.ts"() {
@@ -978,8 +1090,8 @@ var init_db = __esm({
 
 // ../mcp/src/lib/diag.ts
 import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join6 } from "node:path";
 function diag(msg, data) {
   try {
     const line = data ? `${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} ${msg} ${JSON.stringify(data)}
@@ -993,8 +1105,8 @@ var DIAG_DIR, DIAG_LOG_PATH;
 var init_diag = __esm({
   "../mcp/src/lib/diag.ts"() {
     "use strict";
-    DIAG_DIR = join5(homedir3(), ".local", "state", "wiki-mcp");
-    DIAG_LOG_PATH = join5(DIAG_DIR, "server.log");
+    DIAG_DIR = join6(homedir2(), ".local", "state", "wiki-mcp");
+    DIAG_LOG_PATH = join6(DIAG_DIR, "server.log");
     try {
       mkdirSync3(DIAG_DIR, { recursive: true });
     } catch {
@@ -1023,14 +1135,14 @@ var init_logger = __esm({
 
 // ../mcp/src/vault-config.ts
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { parse as parse2 } from "yaml";
 import { z as z4 } from "zod";
 function kindName2(entry) {
   return typeof entry === "string" ? entry : entry.name;
 }
 async function loadVaultConfig2(vaultRoot2) {
-  const path = join6(vaultRoot2, "vault.yaml");
+  const path = join7(vaultRoot2, "vault.yaml");
   let raw;
   try {
     raw = await readFile4(path, "utf8");
@@ -1157,7 +1269,7 @@ function buildVocabulary(config) {
   }
   return lines.join("\n");
 }
-function registerAuthoringResource(mcp, _vaultRoot, vaultConfig) {
+function registerAuthoringResource(mcp, vaultRoot2, vaultConfig) {
   mcp.registerResource(
     "Authoring guide",
     "wiki://authoring",
@@ -1169,6 +1281,8 @@ function registerAuthoringResource(mcp, _vaultRoot, vaultConfig) {
       const sections = [
         "# Wiki authoring guide",
         "",
+        `Vault root: \`${canonicalVaultRoot(vaultRoot2)}\` \u2014 every page path below is relative to it; write files and run \`kmd validate\` / \`kmd sync\` against it.`,
+        "",
         buildKindSelector(vaultConfig.kinds),
         "",
         buildVocabulary(vaultConfig),
@@ -1197,6 +1311,7 @@ var KIND_PEDAGOGY, DEFAULT_AUTHORING_RULES, DEFAULT_SYNC_PROTOCOL, CANONICAL_STA
 var init_authoring = __esm({
   "../mcp/src/resources/authoring.ts"() {
     "use strict";
+    init_database();
     init_vault_config();
     KIND_PEDAGOGY = /* @__PURE__ */ new Map([
       [
@@ -1315,7 +1430,7 @@ var init_authoring = __esm({
 
 // ../mcp/src/resources/templates.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function customTemplates(config) {
   const specs = [];
   for (const entry of config.kinds) {
@@ -1330,7 +1445,7 @@ function customTemplates(config) {
   return specs;
 }
 function registerTemplateResources(mcp, vaultRoot2, vaultConfig) {
-  const dir = join7(vaultRoot2, "templates");
+  const dir = join8(vaultRoot2, "templates");
   const templates = [...TEMPLATES, ...customTemplates(vaultConfig)];
   for (const tmpl of templates) {
     mcp.registerResource(
@@ -1340,7 +1455,7 @@ function registerTemplateResources(mcp, vaultRoot2, vaultConfig) {
       async (uri) => {
         let text;
         try {
-          text = await readFile5(join7(dir, tmpl.file), "utf8");
+          text = await readFile5(join8(dir, tmpl.file), "utf8");
         } catch (err) {
           throw new Error(`template file missing: templates/${tmpl.file} (${tmpl.uri})`, {
             cause: err
@@ -1519,16 +1634,78 @@ var init_toolResponse = __esm({
   }
 });
 
+// ../mcp/src/tools/search.ts
+import { z as z5 } from "zod";
+function search(deps, input) {
+  const ftsQuery = sanitizeFtsQuery(input.query);
+  if (!ftsQuery) return { results: [] };
+  let sql = `SELECT p.path, p.title, p.kind, p.summary, p.scope, ${FTS_RANK} 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 ${FTS_RANK} 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, FTS_RANK;
+var init_search = __esm({
+  "../mcp/src/tools/search.ts"() {
+    "use strict";
+    init_fts();
+    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.")
+    });
+    FTS_RANK = "bm25(pages_fts, 10.0, 5.0, 1.0)";
+  }
+});
+
 // ../mcp/src/tools/prime.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { basename as basename2, join as join8 } from "node:path";
-import { z as z5 } from "zod";
+import { basename as basename3, join as join9 } from "node:path";
+import { z as z6 } from "zod";
 function pathSlug(p) {
-  return basename2(p).replace(/\.md$/, "");
+  return basename3(p).replace(/\.md$/, "");
 }
 async function readIndexFm(vaultRoot2, scope) {
   try {
-    const raw = await readFile6(join8(vaultRoot2, "projects", scope, "index.md"), "utf8");
+    const raw = await readFile6(join9(vaultRoot2, "projects", scope, "index.md"), "utf8");
     return parseFrontmatter2(raw).data;
   } catch {
     return {};
@@ -1536,7 +1713,7 @@ async function readIndexFm(vaultRoot2, scope) {
 }
 async function readPrimer(vaultRoot2, scope) {
   try {
-    const raw = await readFile6(join8(vaultRoot2, "projects", scope, "primer.md"), "utf8");
+    const raw = await readFile6(join9(vaultRoot2, "projects", scope, "primer.md"), "utf8");
     return parseFrontmatter2(raw).content.trim().replace(/^#\s+[^\n]+\n+/, "");
   } catch {
     return "";
@@ -1585,11 +1762,11 @@ async function prime(deps, input) {
     const ftsQuery = sanitizeFtsQuery(task);
     if (ftsQuery) {
       relevant = db.prepare(
-        `SELECT p.path, p.title, bm25(pages_fts) AS score
+        `SELECT p.path, p.title, ${FTS_RANK} 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`
+             ORDER BY ${FTS_RANK} LIMIT 3`
       ).all(ftsQuery, scope).map((row) => ({
         path: row.path,
         title: row.title,
@@ -1601,6 +1778,7 @@ async function prime(deps, input) {
   for (const row of counts) countsRecord[row.kind] = Number(row.count);
   const data = {
     scope,
+    vault_root: canonicalVaultRoot(vaultRoot2),
     title: fm.title ?? null,
     methodology: fm.methodology ?? null,
     phase: typeof fm.phase === "number" ? fm.phase : null,
@@ -1644,6 +1822,7 @@ function renderMarkdown(d, config, task) {
   const header = phaseLabel ? `${d.scope} \u2014 ${phaseLabel}` : d.scope;
   lines.push(`# ${header}`);
   if (d.summary) lines.push(d.summary);
+  lines.push(`Vault root: \`${d.vault_root}\``);
   if (d.primer) {
     lines.push("", "## Primer", d.primer);
   }
@@ -1723,74 +1902,15 @@ var PrimeInputSchema;
 var init_prime = __esm({
   "../mcp/src/tools/prime.ts"() {
     "use strict";
+    init_database();
     init_frontmatter2();
     init_fts();
     init_toolResponse();
     init_vault_config();
-    PrimeInputSchema = z5.object({
-      scope: z5.string().min(1).describe("Project scope to prime (matches projects/{scope}/ in the vault)."),
-      task: z5.string().optional().describe("Optional task description; surfaces top-3 tsvector-ranked relevant pages.")
-    });
-  }
-});
-
-// ../mcp/src/tools/search.ts
-import { z as z6 } from "zod";
-function search(deps, input) {
-  const ftsQuery = sanitizeFtsQuery(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;
-var init_search = __esm({
-  "../mcp/src/tools/search.ts"() {
-    "use strict";
-    init_fts();
-    init_toolResponse();
-    SearchInputSchema = z6.object({
-      query: z6.string().min(1).describe(
-        "Natural-language search query. Matched against title, summary, and body via SQLite FTS5."
-      ),
-      scope: z6.string().optional().describe('Optional: restrict to a project scope (e.g. "ontology", "sotto").'),
-      kind: z6.string().optional().describe(
-        "Optional: restrict to a kind. Project kinds: spec, adr, plan, ops. Research kinds: article, src. Misc: note."
-      ),
-      limit: z6.number().int().min(1).max(50).default(5).describe("Maximum number of ranked results to return. Default 5.")
+    init_search();
+    PrimeInputSchema = z6.object({
+      scope: z6.string().min(1).describe("Project scope to prime (matches projects/{scope}/ in the vault)."),
+      task: z6.string().optional().describe("Optional task description; surfaces top-3 tsvector-ranked relevant pages.")
     });
   }
 });
@@ -1853,7 +1973,7 @@ async function startMcpServer() {
     { vault: config.wikiVault, serverName: config.serverName, serverVersion: config.serverVersion },
     "starting wiki-mcp on stdio"
   );
-  const db = createDatabase();
+  const db = createDatabase(config.wikiVault);
   diag("database opened");
   const mcp = buildServer({
     name: config.serverName,
@@ -1899,10 +2019,11 @@ 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
+  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)
+  config [<vault-root>]    print vault + index resolution; with no vault, list known vaults
+  db reset [<vault-root>]  delete the vault's index (default: $WIKI_VAULT)
 
 options:
   --version   print version
@@ -1942,25 +2063,20 @@ async function run() {
       await startMcpServer2();
       break;
     }
+    case "config": {
+      applyVaultRoot(1);
+      const { runConfig: runConfig2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+      await runConfig2();
+      break;
+    }
     case "db": {
       const sub = positionals[1];
       if (sub === "reset") {
-        const { homedir: homedir4 } = await import("node:os");
-        const { join: join9 } = await import("node:path");
-        const { unlinkSync } = await import("node:fs");
-        const dbPath = join9(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`);
+        applyVaultRoot(2);
+        const { runDbReset: runDbReset2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+        await runDbReset2();
       } else {
-        console.error(sub ? `unknown db subcommand: ${sub}` : "usage: kmd db reset");
+        console.error(sub ? `unknown db subcommand: ${sub}` : "usage: kmd db reset [<vault-root>]");
         process.exit(2);
       }
       break;
@@ -1968,10 +2084,10 @@ async function run() {
     case "--version":
     case "-v": {
       const { readFileSync } = await import("node:fs");
-      const { join: join9, dirname } = await import("node:path");
+      const { join: join10, dirname: dirname4 } = await import("node:path");
       const { fileURLToPath } = await import("node:url");
-      const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-      const pkg = JSON.parse(readFileSync(join9(pkgDir, "package.json"), "utf8"));
+      const pkgDir = dirname4(dirname4(fileURLToPath(import.meta.url)));
+      const pkg = JSON.parse(readFileSync(join10(pkgDir, "package.json"), "utf8"));
       console.log(pkg.version);
       break;
     }