stellavault 0.7.4 → 0.8.2

package/dist/stellavault.js

@@ -36,10 +36,38 @@ function mergeConfig(defaults, overrides) {
     folders: { ...defaults.folders, ...overrides.folders },
     embedding: { ...defaults.embedding, ...overrides.embedding },
     chunking: { ...defaults.chunking, ...overrides.chunking },
-    search: { ...defaults.search, ...overrides.search },
+    search: {
+      ...defaults.search,
+      ...overrides.search,
+      // B3 §4 — deep-merge weights so a partial override keeps the other defaults.
+      weights: { ...defaults.search.weights, ...overrides.search?.weights }
+    },
     mcp: { ...defaults.mcp, ...overrides.mcp }
   };
 }
+function resolveSearchWeights(config, env = process.env) {
+  const base = {
+    semantic: config.search.weights?.semantic ?? 1,
+    bm25: config.search.weights?.bm25 ?? 1,
+    entity: config.search.weights?.entity ?? 1.5,
+    recency: config.search.recencyWeight ?? 0.2
+  };
+  const parse = (raw, min, max) => {
+    const s = String(raw ?? "").trim();
+    if (s === "")
+      return void 0;
+    const n = Number(s);
+    if (!Number.isFinite(n) || n < min)
+      return void 0;
+    return Math.min(n, max);
+  };
+  return {
+    semantic: parse(env.STELLAVAULT_W_SEMANTIC, 0, Infinity) ?? base.semantic,
+    bm25: parse(env.STELLAVAULT_W_BM25, 0, Infinity) ?? base.bm25,
+    entity: parse(env.STELLAVAULT_W_ENTITY, 0, Infinity) ?? base.entity,
+    recency: parse(env.STELLAVAULT_RECENCY_WEIGHT, 0, 1) ?? base.recency
+  };
+}
 var DEFAULT_FOLDERS, DEFAULT_CONFIG;
 var init_config = __esm({
   "packages/core/dist/config.js"() {
@@ -65,7 +93,11 @@ var init_config = __esm({
       },
       search: {
         defaultLimit: 10,
-        rrfK: 60
+        rrfK: 60,
+        weights: { semantic: 1, bm25: 1, entity: 1.5 },
+        // B2.1: entity leads (per-doc cap prevents flooding)
+        recencyWeight: 0.2
+        // B3 §1.3 (±10% bound)
       },
       mcp: {
         mode: "stdio",
@@ -367,6 +399,165 @@ var init_chunker = __esm({
   }
 });
 
+// packages/core/dist/indexer/entity-extractor.js
+function normalize(s) {
+  return s.replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function isMeaningful(n) {
+  if (n.length < 2)
+    return false;
+  if (STOPWORDS.has(n))
+    return false;
+  return true;
+}
+function extractWikilinks(text) {
+  const out = [];
+  const re = /\[\[([^\]]+)\]\]/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    let target = m[1];
+    const pipe = target.indexOf("|");
+    if (pipe >= 0)
+      target = target.slice(0, pipe);
+    const hash = target.indexOf("#");
+    if (hash >= 0)
+      target = target.slice(0, hash);
+    target = target.trim();
+    if (target)
+      out.push(target);
+  }
+  return out;
+}
+function extractInlineTags(text) {
+  const out = [];
+  const re = /(?:^|\s)#([A-Za-z][\w/-]+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null)
+    out.push(m[1].replace(/[/_-]/g, " "));
+  return out;
+}
+function extractNounPhrases(text) {
+  const out = [];
+  const cleaned = text.replace(/`[^`]*`/g, " ").replace(/https?:\/\/\S+/g, " ");
+  const tc = /\b([A-Z][a-z0-9]+(?:\s+[A-Z][a-z0-9]+){1,4})\b/g;
+  let m;
+  while ((m = tc.exec(cleaned)) !== null)
+    out.push(m[1]);
+  const ac = /\b([A-Z]{2,6})\b/g;
+  while ((m = ac.exec(cleaned)) !== null)
+    out.push(m[1]);
+  return out;
+}
+function extractEntities(input) {
+  const set = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    const n = normalize(s);
+    if (isMeaningful(n))
+      set.add(n);
+  };
+  for (const w of extractWikilinks(input.content))
+    add(w);
+  for (const t2 of input.tags ?? [])
+    add(t2.replace(/^#/, "").replace(/[/_-]/g, " "));
+  for (const t2 of extractInlineTags(input.content))
+    add(t2);
+  if (input.heading)
+    add(input.heading);
+  if (input.title)
+    add(input.title);
+  for (const p of extractNounPhrases(input.content))
+    add(p);
+  if (input.heading)
+    for (const p of extractNounPhrases(input.heading))
+      add(p);
+  return [...set].slice(0, MAX_ENTITIES_PER_CHUNK);
+}
+function extractQueryTerms(query) {
+  const set = /* @__PURE__ */ new Set();
+  for (const w of extractWikilinks(query)) {
+    const n = normalize(w);
+    if (n)
+      set.add(n);
+  }
+  for (const a of query.match(/\b[A-Z]{2,6}\b/g) ?? [])
+    set.add(a.toLowerCase());
+  const words = query.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter(Boolean);
+  for (let n = 1; n <= 4; n++) {
+    for (let i = 0; i + n <= words.length; i++) {
+      const gram = words.slice(i, i + n);
+      if (gram.every((w) => STOPWORDS.has(w)))
+        continue;
+      if (n > 1 && (STOPWORDS.has(gram[0]) || STOPWORDS.has(gram[gram.length - 1])))
+        continue;
+      const phrase = gram.join(" ");
+      if (phrase.length >= 2)
+        set.add(phrase);
+    }
+  }
+  return [...set].slice(0, MAX_QUERY_TERMS);
+}
+var MAX_ENTITIES_PER_CHUNK, MAX_QUERY_TERMS, STOPWORDS;
+var init_entity_extractor = __esm({
+  "packages/core/dist/indexer/entity-extractor.js"() {
+    "use strict";
+    MAX_ENTITIES_PER_CHUNK = 30;
+    MAX_QUERY_TERMS = 64;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "this",
+      "that",
+      "from",
+      "into",
+      "your",
+      "you",
+      "are",
+      "was",
+      "not",
+      "but",
+      "all",
+      "can",
+      "has",
+      "have",
+      "will",
+      "what",
+      "when",
+      "which",
+      "their",
+      "them",
+      "these",
+      "those",
+      "then",
+      "than",
+      "about",
+      "over",
+      "more",
+      "most",
+      "some",
+      "such",
+      "also",
+      "how",
+      "why",
+      "does",
+      "did",
+      "who",
+      "where",
+      "a",
+      "an",
+      "of",
+      "to",
+      "in",
+      "on",
+      "is",
+      "it",
+      "or",
+      "as"
+    ]);
+  }
+});
+
 // packages/core/dist/utils/retry.js
 async function withRetry(fn, options = {}) {
   const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULT_OPTIONS2, ...options };
@@ -513,13 +704,19 @@ function createWatcher(options) {
   let watcher = null;
   let debounceTimer = null;
   let reindexing = false;
+  let pendingReindex = false;
   async function triggerReindex() {
-    if (reindexing)
+    if (reindexing) {
+      pendingReindex = true;
       return;
+    }
     reindexing = true;
     try {
-      const result = await indexVault(vaultPath, { store, embedder, chunkOptions });
-      onReindex?.({ indexed: result.indexed, skipped: result.skipped });
+      do {
+        pendingReindex = false;
+        const result = await indexVault(vaultPath, { store, embedder, chunkOptions });
+        onReindex?.({ indexed: result.indexed, skipped: result.skipped });
+      } while (pendingReindex);
     } finally {
       reindexing = false;
     }
@@ -595,7 +792,13 @@ async function indexVault(vaultPath, options) {
       const embeddings = await withRetry(() => embedder.embedBatch(texts), { maxRetries: 2, baseDelayMs: 1e3 });
       const chunksWithEmbeddings = chunks.map((c, j) => ({
         ...c,
-        embedding: embeddings[j]
+        embedding: embeddings[j],
+        entities: extractEntities({
+          content: c.content,
+          heading: c.heading,
+          title: doc.title,
+          tags: doc.tags
+        })
       }));
       await store.upsertDocument(doc);
       await store.upsertChunks(chunksWithEmbeddings);
@@ -631,6 +834,7 @@ var init_indexer = __esm({
     "use strict";
     init_scanner();
     init_chunker();
+    init_entity_extractor();
     init_retry();
     init_local_embedder();
     init_scanner();
@@ -2411,25 +2615,25 @@ async function extractTimedTranscriptFromHtml(html) {
   return parseTranscriptXml(xml);
 }
 async function extractTimedTranscriptViaTool(videoId) {
-  const { execSync: execSync2 } = await import("node:child_process");
-  const { readdirSync: readdirSync9, readFileSync: readFileSync18, unlinkSync } = await import("node:fs");
-  const { join: join30 } = await import("node:path");
+  const { execSync: execSync3 } = await import("node:child_process");
+  const { readdirSync: readdirSync9, readFileSync: readFileSync19, unlinkSync } = await import("node:fs");
+  const { join: join32 } = await import("node:path");
   const tmpDir = (await import("node:os")).tmpdir();
-  const tmpBase = join30(tmpDir, `sv-sub-${videoId}`);
+  const tmpBase = join32(tmpDir, `sv-sub-${videoId}`);
   const url = `https://www.youtube.com/watch?v=${videoId}`;
   for (const lang of ["ko", "en"]) {
     try {
-      execSync2(`python -m yt_dlp --write-auto-sub --sub-lang ${lang} --skip-download --sub-format srv1 -o "${tmpBase}" "${url}"`, { timeout: 3e4, stdio: "pipe" });
+      execSync3(`python -m yt_dlp --write-auto-sub --sub-lang ${lang} --skip-download --sub-format srv1 -o "${tmpBase}" "${url}"`, { timeout: 3e4, stdio: "pipe" });
     } catch {
       continue;
     }
     const files = readdirSync9(tmpDir).filter((f) => f.startsWith(`sv-sub-${videoId}`) && f.endsWith(".srv1"));
     if (files.length === 0)
       continue;
-    const xml = readFileSync18(join30(tmpDir, files[0]), "utf-8");
+    const xml = readFileSync19(join32(tmpDir, files[0]), "utf-8");
     for (const f of files) {
       try {
-        unlinkSync(join30(tmpDir, f));
+        unlinkSync(join32(tmpDir, f));
       } catch {
       }
     }
@@ -3402,6 +3606,195 @@ var init_file_extractors = __esm({
   }
 });
 
+// packages/cli/dist/mcp-clients.js
+import { execSync as execSync2 } from "node:child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync16, readFileSync as readFileSync15, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname4, join as join21 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+function appData() {
+  return process.env.APPDATA ?? join21(homedir13(), "AppData", "Roaming");
+}
+function xdgConfig() {
+  return process.env.XDG_CONFIG_HOME ?? join21(homedir13(), ".config");
+}
+function resolveServeCommand(override) {
+  if (override?.command) {
+    const args = override.args ? override.args.split(/\s+/).filter(Boolean) : ["serve"];
+    return { command: override.command, args };
+  }
+  if (isWin)
+    return { command: "cmd", args: ["/c", "stellavault", "serve"] };
+  return { command: "stellavault", args: ["serve"] };
+}
+function claudeDesktopPath() {
+  if (isWin)
+    return join21(appData(), "Claude", "claude_desktop_config.json");
+  if (isMac)
+    return join21(homedir13(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  return join21(xdgConfig(), "Claude", "claude_desktop_config.json");
+}
+function vscodePath() {
+  if (isWin)
+    return join21(appData(), "Code", "User", "mcp.json");
+  if (isMac)
+    return join21(homedir13(), "Library", "Application Support", "Code", "User", "mcp.json");
+  return join21(xdgConfig(), "Code", "User", "mcp.json");
+}
+function isDetected(client) {
+  return existsSync15(client.detectDir);
+}
+function writeClientConfig(client, serve) {
+  const path = client.configPath;
+  try {
+    let json = {};
+    if (existsSync15(path)) {
+      const raw = readFileSync15(path, "utf-8").trim();
+      if (raw)
+        json = JSON.parse(raw);
+    }
+    const key = client.serversKey;
+    if (typeof json[key] !== "object" || json[key] === null)
+      json[key] = {};
+    const already = Boolean(json[key].stellavault);
+    json[key].stellavault = client.needsType ? { type: "stdio", command: serve.command, args: serve.args } : { command: serve.command, args: serve.args };
+    mkdirSync16(dirname4(path), { recursive: true });
+    writeFileSync16(path, JSON.stringify(json, null, 2) + "\n", "utf-8");
+    return { client: client.label, status: already ? "updated" : "written", path };
+  } catch (err) {
+    return { client: client.label, status: "error", path, detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+function setupClaudeCode(serve) {
+  const manual = `claude mcp add -s user stellavault -- ${serve.command} ${serve.args.join(" ")}`;
+  try {
+    execSync2("claude --version", { stdio: "ignore" });
+  } catch {
+    return { client: "Claude Code", status: "skipped", detail: `claude CLI not found \u2014 run manually:
+           ${manual}` };
+  }
+  try {
+    try {
+      execSync2("claude mcp remove stellavault", { stdio: "ignore" });
+    } catch {
+    }
+    execSync2(manual, { stdio: "ignore" });
+    return { client: "Claude Code", status: "written", detail: "via claude mcp add (user scope)" };
+  } catch (err) {
+    return { client: "Claude Code", status: "error", detail: `${err instanceof Error ? err.message : String(err)} \u2014 try: ${manual}` };
+  }
+}
+var isWin, isMac, FILE_CLIENTS, ALL_CLIENT_IDS;
+var init_mcp_clients = __esm({
+  "packages/cli/dist/mcp-clients.js"() {
+    "use strict";
+    isWin = process.platform === "win32";
+    isMac = process.platform === "darwin";
+    FILE_CLIENTS = [
+      {
+        id: "claude-desktop",
+        label: "Claude Desktop",
+        configPath: claudeDesktopPath(),
+        detectDir: dirname4(claudeDesktopPath()),
+        serversKey: "mcpServers",
+        needsType: false
+      },
+      {
+        id: "cursor",
+        label: "Cursor",
+        configPath: join21(homedir13(), ".cursor", "mcp.json"),
+        detectDir: join21(homedir13(), ".cursor"),
+        serversKey: "mcpServers",
+        needsType: false
+      },
+      {
+        id: "windsurf",
+        label: "Windsurf",
+        configPath: join21(homedir13(), ".codeium", "windsurf", "mcp_config.json"),
+        detectDir: join21(homedir13(), ".codeium"),
+        serversKey: "mcpServers",
+        needsType: false
+      },
+      {
+        id: "vscode",
+        label: "VS Code",
+        configPath: vscodePath(),
+        detectDir: dirname4(dirname4(vscodePath())),
+        // .../Code
+        serversKey: "servers",
+        needsType: true
+      }
+    ];
+    ALL_CLIENT_IDS = ["claude-code", ...FILE_CLIENTS.map((c) => c.id)];
+  }
+});
+
+// packages/cli/dist/commands/setup-cmd.js
+var setup_cmd_exports = {};
+__export(setup_cmd_exports, {
+  setupCommand: () => setupCommand
+});
+import chalk4 from "chalk";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join22 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+async function setupCommand(options) {
+  console.log("");
+  console.log(chalk4.bold("  \u2726 Stellavault \u2014 Connect to your AI clients"));
+  console.log(chalk4.dim("  Registering Stellavault as an MCP server.\n"));
+  if (!existsSync16(join22(homedir14(), ".stellavault.json"))) {
+    console.log(chalk4.yellow("  \u26A0 No config found. Run ") + chalk4.cyan("stellavault init") + chalk4.yellow(" first to index your vault.\n"));
+  }
+  const serve = resolveServeCommand({ command: options.command, args: options.args });
+  console.log(chalk4.dim(`  Server command: ${serve.command} ${serve.args.join(" ")}
+`));
+  const requested = options.client && options.client.length > 0 ? options.client.map((c) => c.toLowerCase()) : null;
+  if (requested) {
+    const unknown = requested.filter((id) => !ALL_CLIENT_IDS.includes(id));
+    if (unknown.length > 0) {
+      console.log(chalk4.red(`  Unknown client(s): ${unknown.join(", ")}`));
+      console.log(chalk4.dim(`  Valid ids: ${ALL_CLIENT_IDS.join(", ")}
+`));
+      return;
+    }
+  }
+  const results = [];
+  if (!requested || requested.includes("claude-code")) {
+    results.push(setupClaudeCode(serve));
+  }
+  for (const client of FILE_CLIENTS) {
+    if (requested && !requested.includes(client.id))
+      continue;
+    if (!requested && !options.all && !isDetected(client)) {
+      results.push({ client: client.label, status: "skipped", detail: "not detected (use --all to force)" });
+      continue;
+    }
+    results.push(writeClientConfig(client, serve));
+  }
+  console.log(chalk4.bold("  Results:"));
+  for (const r of results) {
+    const icon = r.status === "written" ? chalk4.green("\u2713 added  ") : r.status === "updated" ? chalk4.green("\u2713 updated") : r.status === "skipped" ? chalk4.dim("\u2022 skipped") : chalk4.red("\u2717 error  ");
+    console.log(`    ${icon}  ${chalk4.white(r.client)}`);
+    if (r.path)
+      console.log(`               ${chalk4.dim(r.path)}`);
+    if (r.detail)
+      console.log(`               ${chalk4.dim(r.detail)}`);
+  }
+  const ok = results.filter((r) => r.status === "written" || r.status === "updated").length;
+  console.log("");
+  if (ok > 0) {
+    console.log(chalk4.green(`  \u2726 Connected ${ok} client${ok > 1 ? "s" : ""}.`) + chalk4.dim(" Restart the app(s) to load Stellavault."));
+  } else {
+    console.log(chalk4.yellow("  No clients configured.") + chalk4.dim(" Use --all to write configs even when a client is not detected."));
+  }
+  console.log("");
+}
+var init_setup_cmd = __esm({
+  "packages/cli/dist/commands/setup-cmd.js"() {
+    "use strict";
+    init_mcp_clients();
+  }
+});
+
 // packages/cli/dist/index.js
 import { Command } from "commander";
 
@@ -3459,11 +3852,19 @@ function createSqliteVecStore(dbPath, dimensions = 384) {
           INSERT INTO chunk_embeddings (chunk_id, embedding)
           VALUES (?, ?)
         `);
+        const insertEntity = db.prepare(`
+          INSERT INTO chunk_entities (chunk_id, entity)
+          VALUES (?, ?)
+        `);
         for (const chunk of chunks) {
           insertChunk.run(chunk.id, chunk.documentId, chunk.content, chunk.heading, chunk.startLine, chunk.endLine, chunk.tokenCount);
           if (chunk.embedding) {
             insertEmbedding.run(chunk.id, float32Buffer(chunk.embedding));
           }
+          if (chunk.entities) {
+            for (const entity of chunk.entities)
+              insertEntity.run(chunk.id, entity);
+          }
         }
       });
       tx();
@@ -3504,6 +3905,41 @@ function createSqliteVecStore(dbPath, dimensions = 384) {
         // FTS5 rank is negative (lower = better)
       }));
     },
+    async searchEntities(entities, limit) {
+      if (!entities || entities.length === 0)
+        return [];
+      const exactPH = entities.map(() => "?").join(",");
+      const fuzzy = entities.filter((t2) => t2.length >= 4 && (/\s/.test(t2) || /[^\x00-\x7f]/.test(t2) || t2.length >= 6)).slice(0, 16);
+      let matched;
+      let matchedParams;
+      if (fuzzy.length === 0) {
+        matched = `SELECT chunk_id, CAST(COUNT(*) AS REAL) AS score FROM chunk_entities WHERE entity IN (${exactPH}) GROUP BY chunk_id`;
+        matchedParams = [...entities];
+      } else {
+        const esc = (t2) => t2.replace(/[\\%_]/g, "\\$&");
+        const likeClause = fuzzy.map(() => `entity LIKE ? ESCAPE '\\'`).join(" OR ");
+        matched = `
+          SELECT chunk_id, SUM(w) AS score FROM (
+            SELECT chunk_id, 1.0 AS w FROM chunk_entities WHERE entity IN (${exactPH})
+            UNION ALL
+            SELECT chunk_id, 0.4 AS w FROM chunk_entities
+              WHERE (${likeClause}) AND entity NOT IN (${exactPH})
+          ) GROUP BY chunk_id`;
+        matchedParams = [...entities, ...fuzzy.map((t2) => `%${esc(t2)}%`), ...entities];
+      }
+      const rows = db.prepare(`
+        SELECT chunk_id, score FROM (
+          SELECT m.chunk_id AS chunk_id, m.score AS score,
+                 ROW_NUMBER() OVER (PARTITION BY c.document_id ORDER BY m.score DESC, m.chunk_id) AS rn
+          FROM (${matched}) m
+          JOIN chunks c ON c.id = m.chunk_id
+        )
+        WHERE rn <= 2
+        ORDER BY score DESC, chunk_id
+        LIMIT ?
+      `).all(...matchedParams, limit);
+      return rows.map((r) => ({ chunkId: r.chunk_id, score: r.score }));
+    },
     async getDocument(documentId) {
       const row = db.prepare("SELECT * FROM documents WHERE id = ?").get(documentId);
       if (!row)
@@ -3643,6 +4079,13 @@ function createTables(db, dimensions = 384) {
 
     CREATE INDEX IF NOT EXISTS idx_chunks_document_id ON chunks(document_id);
     CREATE INDEX IF NOT EXISTS idx_documents_content_hash ON documents(content_hash);
+
+    CREATE TABLE IF NOT EXISTS chunk_entities (
+      chunk_id TEXT NOT NULL REFERENCES chunks(id) ON DELETE CASCADE,
+      entity TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_chunk_entities_entity ON chunk_entities(entity);
+    CREATE INDEX IF NOT EXISTS idx_chunk_entities_chunk ON chunk_entities(chunk_id);
   `);
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
@@ -3698,32 +4141,127 @@ async function searchSemantic(store, embedder, query, limit) {
   return store.searchSemantic(embedding, limit);
 }
 
+// packages/core/dist/search/entity.js
+init_entity_extractor();
+async function searchEntities(store, query, limit) {
+  if (typeof store.searchEntities !== "function")
+    return [];
+  const terms = extractQueryTerms(query);
+  if (terms.length === 0)
+    return [];
+  return store.searchEntities(terms, limit);
+}
+
 // packages/core/dist/search/rrf.js
-function rrfFusion(listA, listB, k = 60, limit = 10) {
+function rrfFusionN(lists, k = 60, limit = 10, opts = {}) {
+  const { weights, recencyScores, recencyWeight = 0 } = opts;
   const scores = /* @__PURE__ */ new Map();
-  for (let i = 0; i < listA.length; i++) {
-    const id = listA[i].chunkId;
-    scores.set(id, (scores.get(id) ?? 0) + 1 / (k + i + 1));
+  for (let li = 0; li < lists.length; li++) {
+    const w = weights?.[li] ?? 1;
+    const list = lists[li];
+    for (let i = 0; i < list.length; i++) {
+      const id = list[i].chunkId;
+      scores.set(id, (scores.get(id) ?? 0) + w * (1 / (k + i + 1)));
+    }
   }
-  for (let i = 0; i < listB.length; i++) {
-    const id = listB[i].chunkId;
-    scores.set(id, (scores.get(id) ?? 0) + 1 / (k + i + 1));
+  if (recencyWeight > 0 && recencyScores) {
+    for (const [id, s] of scores) {
+      const r = recencyScores.get(id) ?? 0.5;
+      scores.set(id, s * (1 + recencyWeight * (r - 0.5)));
+    }
   }
   return [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([chunkId, score]) => ({ chunkId, score }));
 }
 
+// packages/core/dist/search/adaptive.js
+function createAdaptiveSearch(deps) {
+  const { baseSearch } = deps;
+  const searchHistory = [];
+  const recentTags = [];
+  return {
+    async search(options) {
+      const { context, ...baseOptions } = options;
+      const results = await baseSearch.search(baseOptions);
+      if (!context && searchHistory.length === 0)
+        return results;
+      const ctx = {
+        recentSearches: context?.recentSearches ?? searchHistory.slice(-5),
+        recentDocTags: context?.recentDocTags ?? recentTags.slice(-10),
+        currentFilePath: context?.currentFilePath
+      };
+      const reranked = results.map((r) => {
+        let boost = 0;
+        const docTags = ctx.recentDocTags ?? [];
+        if (docTags.length > 0 && r.document.tags.length > 0) {
+          const docTagSet = new Set(r.document.tags);
+          const overlap = docTags.filter((t2) => docTagSet.has(t2)).length;
+          boost += Math.min(overlap / Math.max(docTags.length, 1), 1) * 0.3;
+        }
+        if (ctx.currentFilePath && r.document.filePath) {
+          const ctxParts = ctx.currentFilePath.split("/");
+          const docParts = r.document.filePath.split("/");
+          let common = 0;
+          for (let i = 0; i < Math.min(ctxParts.length, docParts.length); i++) {
+            if (ctxParts[i] === docParts[i])
+              common++;
+            else
+              break;
+          }
+          if (common > 0) {
+            boost += Math.min(common / Math.max(ctxParts.length - 1, 1), 1) * 0.2;
+          }
+        }
+        return { ...r, score: r.score * (1 + boost) };
+      });
+      reranked.sort((a, b) => b.score - a.score);
+      searchHistory.push(options.query);
+      if (searchHistory.length > 20)
+        searchHistory.shift();
+      for (const r of reranked.slice(0, 3)) {
+        for (const t2 of r.document.tags) {
+          recentTags.push(t2);
+        }
+      }
+      while (recentTags.length > 30)
+        recentTags.shift();
+      return reranked;
+    }
+  };
+}
+
 // packages/core/dist/search/index.js
+var DEFAULT_SIGNAL_WEIGHTS = {
+  semantic: 1,
+  bm25: 1,
+  entity: 1.5,
+  // B2.1: leading curated-graph signal. Per-doc cap in searchEntities
+  // prevents one large note flooding top-k. Tune via STELLAVAULT_W_ENTITY
+  // (e.g. 2.0 for aggressive project-name surfacing, 0.5 for conservative).
+  recency: 0.2
+  // ±10% bound on relevance
+};
 function createSearchEngine(deps) {
-  const { store, embedder, rrfK = 60 } = deps;
+  const { store, embedder, rrfK = 60, getDecayEngine } = deps;
+  const baseWeights = { ...DEFAULT_SIGNAL_WEIGHTS, ...deps.weights };
   const FETCH_LIMIT = 30;
   return {
     async search(options) {
-      const { query, limit = 10, threshold = 0, tags } = options;
-      const [bm25Results, semanticResults] = await Promise.all([
+      const { query, limit = 10, threshold = 0, tags, signalWeights } = options;
+      const w = { ...baseWeights, ...signalWeights };
+      const [bm25Results, semanticResults, entityResults] = await Promise.all([
         searchBm25(store, query, FETCH_LIMIT),
-        searchSemantic(store, embedder, query, FETCH_LIMIT)
+        searchSemantic(store, embedder, query, FETCH_LIMIT),
+        searchEntities(store, query, FETCH_LIMIT)
       ]);
-      const fused = rrfFusion(semanticResults, bm25Results, rrfK, limit * 2);
+      const lists = [semanticResults, bm25Results, entityResults];
+      const weights = [w.semantic, w.bm25, w.entity];
+      const decay = getDecayEngine?.();
+      const recencyScores = decay ? await buildRecencyMap(store, decay, lists) : void 0;
+      const fused = rrfFusionN(lists, rrfK, limit * 2, {
+        weights,
+        recencyScores,
+        recencyWeight: recencyScores ? w.recency : 0
+      });
       const results = [];
       for (const scored of fused) {
         if (scored.score < threshold)
@@ -3752,6 +4290,33 @@ function createSearchEngine(deps) {
     }
   };
 }
+async function buildRecencyMap(store, decay, lists) {
+  const chunkIds = /* @__PURE__ */ new Set();
+  for (const list of lists)
+    for (const c of list)
+      chunkIds.add(c.chunkId);
+  if (chunkIds.size === 0)
+    return /* @__PURE__ */ new Map();
+  const chunkDoc = [];
+  const docIds = /* @__PURE__ */ new Set();
+  for (const chunkId of chunkIds) {
+    const chunk = await store.getChunk(chunkId);
+    if (!chunk)
+      continue;
+    chunkDoc.push({ chunkId, documentId: chunk.documentId });
+    docIds.add(chunk.documentId);
+  }
+  if (docIds.size === 0)
+    return /* @__PURE__ */ new Map();
+  const rByDoc = await decay.getRetrievabilityForDocs([...docIds]);
+  const map = /* @__PURE__ */ new Map();
+  for (const { chunkId, documentId } of chunkDoc) {
+    const r = rByDoc.get(documentId);
+    if (r !== void 0)
+      map.set(chunkId, r);
+  }
+  return map;
+}
 function extractHighlights(content, query) {
   const words = query.toLowerCase().split(/\s+/).filter((w) => w.length > 1);
   const lines = content.split("\n");
@@ -3794,6 +4359,7 @@ async function handleSearch(searchEngine, args) {
     tags: args.tags
   });
   return results.map((r) => ({
+    documentId: r.document.id,
     title: r.document.title,
     filePath: r.document.filePath,
     heading: r.chunk.heading,
@@ -4334,6 +4900,12 @@ var DecayEngine = class {
         retrievability REAL NOT NULL DEFAULT 1.0,
         updated_at TEXT NOT NULL
       );
+      -- 2026-05-15: getDecaying() \uC758 'WHERE retrievability < ? ORDER BY
+      -- retrievability ASC' \uAC00 full table scan \uC73C\uB85C 1215+ docs vault \uC5D0\uC11C
+      -- \uBB34\uAC70\uC6C0. index \uCD94\uAC00\uB85C sort+filter \uB458 \uB2E4 \uAC00\uC18D.
+      CREATE INDEX IF NOT EXISTS idx_decay_state_retrievability ON decay_state(retrievability);
+      -- recompute \uC2DC stale row \uBE60\uB974\uAC8C \uCC3E\uAE30.
+      CREATE INDEX IF NOT EXISTS idx_decay_state_updated_at ON decay_state(updated_at);
     `);
   }
   /**
@@ -4447,6 +5019,25 @@ var DecayEngine = class {
       title: r.title
     }));
   }
+  /**
+   * Design Ref: §B3.3.3 — read-only live retrievability for a set of documents.
+   * Reuses persisted stability + last_access and recomputes R fresh, ignoring the
+   * stale decay_state.retrievability snapshot column. No writes → no contention
+   * with recordAccess. Single parametrized IN(...) query (bounded by ≤90 fused
+   * candidates); documents without a decay_state row are simply absent from the map.
+   */
+  async getRetrievabilityForDocs(documentIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (documentIds.length === 0)
+      return out;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const placeholders = documentIds.map(() => "?").join(",");
+    const rows = this.db.prepare(`SELECT document_id, stability, last_access FROM decay_state WHERE document_id IN (${placeholders})`).all(...documentIds);
+    for (const r of rows) {
+      out.set(r.document_id, computeRetrievability(r.stability, elapsedDays(r.last_access, now)));
+    }
+    return out;
+  }
   /**
    * Initialize decay state for documents that don't have one yet.
    */
@@ -4570,12 +5161,99 @@ function createLearningPathTool(store) {
   };
 }
 
-// packages/core/dist/mcp/tools/detect-gaps.js
+// packages/core/dist/intelligence/gap-cache.js
 init_gap_detector();
-function createDetectGapsTool(store) {
+var CACHE_VERSION = 1;
+var DEFAULT_MAX_AGE_MS = 6 * 60 * 60 * 1e3;
+var inflightByDb = /* @__PURE__ */ new WeakMap();
+var generationByDb = /* @__PURE__ */ new WeakMap();
+function bumpGeneration(db) {
+  const cur = generationByDb.get(db) ?? 0;
+  const next = cur + 1;
+  generationByDb.set(db, next);
+  return next;
+}
+function getGeneration(db) {
+  return generationByDb.get(db) ?? 0;
+}
+function ensureGapCacheTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS gap_cache (
+      id INTEGER PRIMARY KEY,
+      payload TEXT NOT NULL,
+      version INTEGER NOT NULL DEFAULT 1,
+      computed_at TEXT NOT NULL
+    );
+  `);
+}
+function readCachedGapReport(db, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  try {
+    ensureGapCacheTable(db);
+    const row = db.prepare("SELECT * FROM gap_cache WHERE id = 1").get();
+    if (!row)
+      return null;
+    if (row.version !== CACHE_VERSION)
+      return null;
+    const computedAt = new Date(row.computed_at).getTime();
+    if (Number.isNaN(computedAt))
+      return null;
+    if (Date.now() - computedAt > maxAgeMs)
+      return null;
+    return JSON.parse(row.payload);
+  } catch {
+    return null;
+  }
+}
+async function computeAndCacheGaps(store, db) {
+  const currentGeneration = getGeneration(db);
+  const existing = inflightByDb.get(db);
+  if (existing && existing.generation === currentGeneration) {
+    return existing.promise;
+  }
+  const startGeneration = currentGeneration;
+  const promise = (async () => {
+    try {
+      ensureGapCacheTable(db);
+      const report = await detectKnowledgeGaps(store);
+      if (getGeneration(db) === startGeneration) {
+        const payload = JSON.stringify(report);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.prepare(`INSERT INTO gap_cache (id, payload, version, computed_at) VALUES (1, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET payload = excluded.payload, version = excluded.version, computed_at = excluded.computed_at`).run(payload, CACHE_VERSION, now);
+      }
+      return report;
+    } finally {
+      const cur = inflightByDb.get(db);
+      if (cur?.generation === startGeneration)
+        inflightByDb.delete(db);
+    }
+  })();
+  inflightByDb.set(db, { generation: startGeneration, promise });
+  return promise;
+}
+function invalidateGapCache(db) {
+  try {
+    ensureGapCacheTable(db);
+    db.prepare("DELETE FROM gap_cache WHERE id = 1").run();
+    bumpGeneration(db);
+  } catch {
+  }
+}
+async function getGapReport(store, db, opts = {}) {
+  if (!opts.forceRefresh) {
+    const cached = readCachedGapReport(db, opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
+    if (cached)
+      return { report: cached, fromCache: true };
+  }
+  const fresh = await computeAndCacheGaps(store, db);
+  return { report: fresh, fromCache: false };
+}
+
+// packages/core/dist/mcp/tools/detect-gaps.js
+function createDetectGapsTool(store, getDb) {
   return {
     name: "detect-gaps",
-    description: "Detect knowledge gaps between topic clusters. Returns gap severity, isolated nodes, and suggested topics to bridge gaps.",
+    description: "Detect knowledge gaps between topic clusters. Returns gap severity, isolated nodes, and suggested topics to bridge gaps. Result cached 6h (set forceRefresh=true to recompute).",
     inputSchema: {
       type: "object",
       properties: {
@@ -4583,12 +5261,17 @@ function createDetectGapsTool(store) {
           type: "string",
           description: "Minimum gap severity to include: high, medium, or low",
           enum: ["high", "medium", "low"]
+        },
+        forceRefresh: {
+          type: "boolean",
+          description: "Bypass cache and recompute (expensive: 30s+ on large vaults). Default false."
         }
       }
     },
     handler: async (args) => {
       const minSeverity = args.minSeverity ?? "medium";
-      const report = await detectKnowledgeGaps(store);
+      const db = getDb();
+      const { report, fromCache } = await getGapReport(store, db, { forceRefresh: args.forceRefresh });
       const sevOrder = { high: 0, medium: 1, low: 2 };
       const threshold = sevOrder[minSeverity] ?? 1;
       const filtered = report.gaps.filter((g) => sevOrder[g.severity] <= threshold);
@@ -4606,7 +5289,8 @@ function createDetectGapsTool(store) {
               suggestedTopic: g.suggestedTopic
             })),
             isolatedNodes: report.isolatedNodes.slice(0, 10),
-            suggestion: filtered.length > 0 ? `${filtered[0].suggestedTopic} \uC8FC\uC81C\uB85C \uB178\uD2B8\uB97C \uC791\uC131\uD558\uBA74 \uC9C0\uC2DD \uAC2D\uC744 \uC904\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4.` : "\uD604\uC7AC \uC2EC\uAC01\uD55C \uC9C0\uC2DD \uAC2D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+            suggestion: filtered.length > 0 ? `${filtered[0].suggestedTopic} \uC8FC\uC81C\uB85C \uB178\uD2B8\uB97C \uC791\uC131\uD558\uBA74 \uC9C0\uC2DD \uAC2D\uC744 \uC904\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4.` : "\uD604\uC7AC \uC2EC\uAC01\uD55C \uC9C0\uC2DD \uAC2D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+            cacheStatus: fromCache ? "cached" : "fresh"
           }, null, 2)
         }]
       };
@@ -5036,11 +5720,11 @@ The note will appear in the graph after next index.`
         if (!source) {
           return { content: [{ type: "text", text: `Source note "${args.sourceTitle}" not found.` }] };
         }
-        const { readFileSync: readFileSync18 } = await import("node:fs");
+        const { readFileSync: readFileSync19 } = await import("node:fs");
         const fullPath = join7(vaultPath, source.filePath);
         let existing = "";
         try {
-          existing = readFileSync18(fullPath, "utf-8");
+          existing = readFileSync19(fullPath, "utf-8");
         } catch {
         }
         const linkSection = `
@@ -5065,14 +5749,15 @@ The note will appear in the graph after next index.`
 function createMcpServer(options) {
   const { store, searchEngine, embedder, vaultPath = "", decayEngine } = options;
   const ready = options.ready ?? Promise.resolve();
+  const adaptiveSearch = createAdaptiveSearch({ baseSearch: searchEngine });
   const learningPathTool = createLearningPathTool(store);
-  const detectGapsTool = createDetectGapsTool(store);
+  const detectGapsTool = createDetectGapsTool(store, () => store.getDb());
   const getEvolutionTool = createGetEvolutionTool(store);
   const linkCodeTool = createLinkCodeTool(searchEngine);
   const askTool = createAskTool(searchEngine, vaultPath);
   const generateDraftTool = createGenerateDraftTool(searchEngine, vaultPath);
   const agenticTools = embedder ? createAgenticGraphTools(store, embedder, vaultPath) : [];
-  const server = new Server({ name: "stellavault", version: "0.7.3" }, { capabilities: { tools: {} } });
+  const server = new Server({ name: "stellavault", version: "0.8.2" }, { capabilities: { tools: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
       searchToolDef,
@@ -5102,10 +5787,10 @@ function createMcpServer(options) {
       let result;
       switch (name) {
         case "search":
-          result = await handleSearch(searchEngine, args);
-          if (decayEngine && result && typeof result === "object" && "results" in result) {
+          result = await handleSearch(adaptiveSearch, args);
+          if (decayEngine && Array.isArray(result)) {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            for (const r of result.results ?? []) {
+            for (const r of result) {
               if (r.documentId)
                 decayEngine.recordAccess({ documentId: r.documentId, type: "mcp_query", timestamp: now }).catch(() => {
                 });
@@ -5576,17 +6261,17 @@ function createKnowledgeRouter(opts) {
         res.status(404).json({ error: "Document not found" });
         return;
       }
-      const { readFileSync: readFileSync18, writeFileSync: writeFileSync22, unlinkSync } = await import("node:fs");
-      const { join: join30, resolve: resolve22 } = await import("node:path");
+      const { readFileSync: readFileSync19, writeFileSync: writeFileSync23, unlinkSync } = await import("node:fs");
+      const { join: join32, resolve: resolve22 } = await import("node:path");
       const [keeper, removed] = docA.content.length >= docB.content.length ? [docA, docB] : [docB, docA];
-      const keeperPath = resolve22(join30(vaultPath, keeper.filePath));
-      const removedPath = resolve22(join30(vaultPath, removed.filePath));
+      const keeperPath = resolve22(join32(vaultPath, keeper.filePath));
+      const removedPath = resolve22(join32(vaultPath, removed.filePath));
       const vaultRoot = resolve22(vaultPath);
       if (!keeperPath.startsWith(vaultRoot) || !removedPath.startsWith(vaultRoot)) {
         res.status(400).json({ error: "Invalid file path" });
         return;
       }
-      const keeperContent = readFileSync18(keeperPath, "utf-8");
+      const keeperContent = readFileSync19(keeperPath, "utf-8");
       const appendix = `
 
 ---
@@ -5594,7 +6279,7 @@ function createKnowledgeRouter(opts) {
 > Merged from: ${removed.title} (${removed.filePath})
 
 ${removed.content}`;
-      writeFileSync22(keeperPath, keeperContent + appendix, "utf-8");
+      writeFileSync23(keeperPath, keeperContent + appendix, "utf-8");
       try {
         unlinkSync(removedPath);
       } catch {
@@ -5617,8 +6302,8 @@ ${removed.content}`;
         res.status(400).json({ error: "clusterA, clusterB required" });
         return;
       }
-      const { writeFileSync: writeFileSync22, mkdirSync: mkdirSync22 } = await import("node:fs");
-      const { join: join30, resolve: resolve22 } = await import("node:path");
+      const { writeFileSync: writeFileSync23, mkdirSync: mkdirSync23 } = await import("node:fs");
+      const { join: join32, resolve: resolve22 } = await import("node:path");
       const nameA = clusterA.replace(/\s*\(\d+\)$/, "");
       const nameB = clusterB.replace(/\s*\(\d+\)$/, "");
       const resultsA = await searchEngine.search({ query: nameA, limit: 3 });
@@ -5658,14 +6343,14 @@ ${removed.content}`;
         ""
       ].join("\n");
       const safeTitle = title.replace(/[<>:"/\\|?*]/g, "").replace(/\s+/g, " ");
-      const dir = resolve22(join30(vaultPath, "01_Knowledge"));
+      const dir = resolve22(join32(vaultPath, "01_Knowledge"));
       if (!dir.startsWith(resolve22(vaultPath))) {
         res.status(400).json({ error: "Invalid path" });
         return;
       }
-      mkdirSync22(dir, { recursive: true });
-      const filePath = join30(dir, `${safeTitle}.md`);
-      writeFileSync22(filePath, content, "utf-8");
+      mkdirSync23(dir, { recursive: true });
+      const filePath = join32(dir, `${safeTitle}.md`);
+      writeFileSync23(filePath, content, "utf-8");
       res.json({ success: true, title: safeTitle, path: filePath });
     } catch (err) {
       console.error(err);
@@ -5815,12 +6500,12 @@ function createIngestRouter(opts) {
           return;
         }
         try {
-          const { writeFileSync: writeFileSync22, unlinkSync } = await import("node:fs");
-          const { join: join30 } = await import("node:path");
+          const { writeFileSync: writeFileSync23, unlinkSync } = await import("node:fs");
+          const { join: join32 } = await import("node:path");
           const { tmpdir } = await import("node:os");
           const safeName = (file.originalname ?? "upload").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 100);
-          const tmpPath = join30(tmpdir(), `sv-upload-${Date.now()}-${safeName}`);
-          writeFileSync22(tmpPath, file.buffer);
+          const tmpPath = join32(tmpdir(), `sv-upload-${Date.now()}-${safeName}`);
+          writeFileSync23(tmpPath, file.buffer);
           const { extractFileContent: extractFileContent2 } = await Promise.resolve().then(() => (init_file_extractors(), file_extractors_exports));
           const ext = file.originalname.split(".").pop()?.toLowerCase() ?? "";
           const binaryExts = /* @__PURE__ */ new Set(["pdf", "docx", "pptx", "xlsx", "xls"]);
@@ -5926,11 +6611,11 @@ ${desc}
         if (content.length > 1e4)
           content = content.slice(0, 1e4) + "\n\n...(truncated)";
       }
-      const { writeFileSync: writeFileSync22, mkdirSync: mkdirSync22 } = await import("node:fs");
-      const { join: join30 } = await import("node:path");
+      const { writeFileSync: writeFileSync23, mkdirSync: mkdirSync23 } = await import("node:fs");
+      const { join: join32 } = await import("node:path");
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const clipDir = join30(vaultPath || ".", "06_Research", "clips");
-      mkdirSync22(clipDir, { recursive: true });
+      const clipDir = join32(vaultPath || ".", "06_Research", "clips");
+      mkdirSync23(clipDir, { recursive: true });
       const fileName = `${date} ${safeTitle}.md`;
       const md = `---
 title: "${safeTitle}"
@@ -5944,8 +6629,8 @@ tags: [clip${isYT ? ", youtube" : ""}]
 > Source: ${url}
 
 ${content}`;
-      writeFileSync22(join30(clipDir, fileName), md, "utf-8");
-      res.json({ success: true, fileName, path: join30(clipDir, fileName) });
+      writeFileSync23(join32(clipDir, fileName), md, "utf-8");
+      res.json({ success: true, fileName, path: join32(clipDir, fileName) });
     } catch (err) {
       console.error(err);
       res.status(500).json({ error: "Clip failed" });
@@ -6433,14 +7118,14 @@ function createApiServer(options) {
         res.status(404).json({ error: "Document not found" });
         return;
       }
-      const { resolve: resolve22, join: join30 } = await import("node:path");
-      const { writeFileSync: writeFileSync22, readFileSync: readFileSync18 } = await import("node:fs");
+      const { resolve: resolve22, join: join32 } = await import("node:path");
+      const { writeFileSync: writeFileSync23, readFileSync: readFileSync19 } = await import("node:fs");
       const fullPath = resolve22(vaultPath, doc.filePath);
       if (!fullPath.startsWith(resolve22(vaultPath))) {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      const existing = readFileSync18(fullPath, "utf-8");
+      const existing = readFileSync19(fullPath, "utf-8");
       let updated = existing;
       if (title && title !== doc.title) {
         updated = updated.replace(/^title:\s*.+$/m, `title: "${title.replace(/"/g, "''")}"`);
@@ -6461,7 +7146,7 @@ function createApiServer(options) {
           updated = content;
         }
       }
-      writeFileSync22(fullPath, updated, "utf-8");
+      writeFileSync23(fullPath, updated, "utf-8");
       await store.upsertDocument({
         ...doc,
         title: title ?? doc.title,
@@ -6484,13 +7169,13 @@ function createApiServer(options) {
         return;
       }
       const { resolve: resolve22 } = await import("node:path");
-      const { unlinkSync, existsSync: existsSync25 } = await import("node:fs");
+      const { unlinkSync, existsSync: existsSync27 } = await import("node:fs");
       const fullPath = resolve22(vaultPath, doc.filePath);
       if (!fullPath.startsWith(resolve22(vaultPath))) {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (existsSync25(fullPath)) {
+      if (existsSync27(fullPath)) {
         unlinkSync(fullPath);
       }
       await store.deleteByDocumentId(id);
@@ -6616,12 +7301,12 @@ function createApiServer(options) {
       const { resolve: resolve22 } = await import("node:path");
       const syncScript = resolve22(process.cwd(), "packages/sync/sync-to-obsidian.mjs");
       const syncDir = resolve22(process.cwd(), "packages/sync");
-      const { existsSync: existsSync25 } = await import("node:fs");
-      if (!existsSync25(syncScript)) {
+      const { existsSync: existsSync27 } = await import("node:fs");
+      if (!existsSync27(syncScript)) {
         res.json({ success: false, error: "sync script not found" });
         return;
       }
-      if (!existsSync25(resolve22(syncDir, ".env"))) {
+      if (!existsSync27(resolve22(syncDir, ".env"))) {
         res.json({ success: false, error: ".env not found" });
         return;
       }
@@ -7016,8 +7701,8 @@ async function transcribeAudio(audioPath, options = {}) {
     try {
       execFileSync("whisper", args, { stdio: "pipe", timeout: 3e5 });
       const outputName = basename4(audioPath).replace(/\.[^.]+$/, ".txt");
-      const { readFileSync: readFileSync18 } = await import("node:fs");
-      return readFileSync18(join14("/tmp/sv-whisper", outputName), "utf-8").trim();
+      const { readFileSync: readFileSync19 } = await import("node:fs");
+      return readFileSync19(join14("/tmp/sv-whisper", outputName), "utf-8").trim();
     } catch (err) {
       throw new Error(`Whisper failed: ${err instanceof Error ? err.message : err}`);
     }
@@ -7253,11 +7938,33 @@ var CREDITS_FILE = join19(homedir11(), ".stellavault", "federation", "credits.js
 init_retry();
 init_math();
 init_indexer();
+init_config();
 function createKnowledgeHub(config, options = {}) {
   const embedder = createLocalEmbedder(config.embedding.localModel);
   const dims = embedder.dimensions;
   const store = createSqliteVecStore(config.dbPath, dims);
-  const searchEngine = createSearchEngine({ store, embedder, rrfK: config.search.rrfK });
+  let _decay = null;
+  const getDecayEngine = () => {
+    if (_decay)
+      return _decay;
+    try {
+      const db = store.getDb();
+      if (!db)
+        return void 0;
+      _decay = new DecayEngine(db);
+      return _decay;
+    } catch {
+      return void 0;
+    }
+  };
+  const sw = resolveSearchWeights(config);
+  const searchEngine = createSearchEngine({
+    store,
+    embedder,
+    rrfK: config.search.rrfK,
+    weights: { semantic: sw.semantic, bm25: sw.bm25, entity: sw.entity, recency: sw.recency },
+    getDecayEngine
+  });
   const mcpServer = createMcpServer({ store, searchEngine, vaultPath: config.vaultPath, ready: options.ready });
   return { store, embedder, searchEngine, mcpServer, config };
 }
@@ -7269,6 +7976,14 @@ function getVaultDbPath(vaultPath) {
   mkdirSync15(dir, { recursive: true });
   return join20(dir, `${hash}.db`);
 }
+function resolveDbPath(vault2, configDbPath) {
+  const envDbPath = process.env.STELLAVAULT_DB_PATH?.trim();
+  if (envDbPath)
+    return envDbPath;
+  if (configDbPath)
+    return configDbPath;
+  return getVaultDbPath(vault2);
+}
 async function indexCommand(vaultPath, opts = {}) {
   if (opts.profileMemory)
     process.env.STELLAVAULT_PROFILE_MEMORY = "1";
@@ -7278,7 +7993,7 @@ async function indexCommand(vaultPath, opts = {}) {
     console.error(chalk.red("Error: vault path required. Use stellavault index <path> or set vaultPath in .stellavault.json"));
     process.exit(1);
   }
-  const dbPath = vaultPath ? getVaultDbPath(vault2) : config.dbPath;
+  const dbPath = resolveDbPath(vault2, config.dbPath);
   const existingVaults = listVaults();
   const vaultName = vault2.split(/[/\\]/).filter(Boolean).pop() ?? "vault";
   if (!existingVaults.some((v) => v.path === vault2)) {
@@ -7380,7 +8095,13 @@ async function searchCommand(query, options, cmd) {
   await store.initialize();
   const embedder = createLocalEmbedder(config.embedding.localModel);
   await embedder.initialize();
-  const engine = createSearchEngine({ store, embedder, rrfK: config.search.rrfK });
+  const sw = resolveSearchWeights(config);
+  const engine = createSearchEngine({
+    store,
+    embedder,
+    rrfK: config.search.rrfK,
+    weights: { semantic: sw.semantic, bm25: sw.bm25, entity: sw.entity, recency: sw.recency }
+  });
   const results = await engine.search({ query, limit });
   await store.close();
   if (jsonMode) {
@@ -7422,6 +8143,8 @@ async function serveCommand() {
   console.error(chalk3.green("\u{1F680} MCP Server running (stdio mode) \u2014 index loading in background"));
   console.error(chalk3.dim("\u{1F4A1} Claude Code: claude mcp add stellavault -- stellavault serve"));
   const serverPromise = hub.mcpServer.startStdio();
+  const watcherEnabled = (process.env.STELLAVAULT_WATCH ?? "1").trim() !== "0";
+  let watcherHandle = null;
   (async () => {
     try {
       const t0 = Date.now();
@@ -7431,16 +8154,60 @@ async function serveCommand() {
       const elapsed = Date.now() - t0;
       console.error(`\u{1F4DA} ${stats.documentCount} documents | ${stats.chunkCount} chunks (ready in ${elapsed}ms)`);
       resolveReady();
+      if (watcherEnabled && config.vaultPath) {
+        try {
+          watcherHandle = createWatcher({
+            vaultPath: config.vaultPath,
+            store: hub.store,
+            embedder: hub.embedder,
+            chunkOptions: config.chunking,
+            debounceMs: Number(process.env.STELLAVAULT_WATCH_DEBOUNCE_MS ?? 5e3),
+            onReindex: (r) => {
+              console.error(`\u{1F440} watcher reindex: ${r.indexed} indexed, ${r.skipped} unchanged`);
+              try {
+                invalidateGapCache(hub.store.getDb());
+              } catch {
+              }
+            }
+          });
+          watcherHandle.start();
+          console.error(chalk3.green(`\u{1F440} Watcher started (debounce ${process.env.STELLAVAULT_WATCH_DEBOUNCE_MS ?? 5e3}ms) \u2014 vault changes auto-reindex`));
+        } catch (err) {
+          console.error(chalk3.yellow("\u26A0\uFE0F Watcher init failed: " + err.message));
+        }
+      } else if (!watcherEnabled) {
+        console.error(chalk3.dim("\u{1F440} Watcher disabled (STELLAVAULT_WATCH=0)"));
+      } else {
+        console.error(chalk3.dim("\u{1F440} Watcher skipped (no config.vaultPath set)"));
+      }
     } catch (err) {
       console.error(chalk3.red("\u274C Index load failed: " + err.message));
       resolveReady();
     }
   })();
+  const cleanup = () => {
+    try {
+      watcherHandle?.stop();
+    } catch {
+    }
+  };
+  process.once("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
   await serverPromise;
+  cleanup();
 }
 
+// packages/cli/dist/index.js
+init_setup_cmd();
+
 // packages/cli/dist/commands/status-cmd.js
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 async function statusCommand(_opts, cmd) {
   const globalOpts = cmd?.parent?.opts?.() ?? {};
   const jsonMode = globalOpts.json;
@@ -7472,7 +8239,7 @@ async function statusCommand(_opts, cmd) {
     return;
   }
   console.log("");
-  console.log(chalk4.bold("\u{1F4CA} Stellavault Status"));
+  console.log(chalk5.bold("\u{1F4CA} Stellavault Status"));
   console.log("\u2500".repeat(40));
   console.log(`  \u{1F4C4} Documents: ${stats.documentCount}${totalFiles != null ? ` / ${totalFiles} files (${Math.round(stats.documentCount / totalFiles * 100)}%)` : ""}`);
   if (skippedFiles != null && skippedFiles > 0) {
@@ -7484,7 +8251,7 @@ async function statusCommand(_opts, cmd) {
   console.log(`  \u{1F4C1} Vault: ${config.vaultPath || "(not set)"}`);
   if (topics.length > 0) {
     console.log("");
-    console.log(chalk4.bold("\u{1F3F7}\uFE0F Top topics:"));
+    console.log(chalk5.bold("\u{1F3F7}\uFE0F Top topics:"));
     topics.slice(0, 10).forEach((t2) => {
       console.log(`  #${t2.topic} (${t2.count})`);
     });
@@ -7493,22 +8260,22 @@ async function statusCommand(_opts, cmd) {
 }
 
 // packages/cli/dist/commands/graph-cmd.js
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { spawn } from "node:child_process";
-import { resolve as resolve11, dirname as dirname4 } from "node:path";
-import { existsSync as existsSync15 } from "node:fs";
+import { resolve as resolve11, dirname as dirname5 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
 import { fileURLToPath } from "node:url";
 function locateBundledGraphUi() {
   try {
-    const here = dirname4(fileURLToPath(import.meta.url));
+    const here = dirname5(fileURLToPath(import.meta.url));
     const bundled = resolve11(here, "graph-ui");
-    if (existsSync15(resolve11(bundled, "index.html")))
+    if (existsSync17(resolve11(bundled, "index.html")))
       return bundled;
     const monorepoGraphDist = resolve11(here, "..", "..", "..", "graph", "dist");
-    if (existsSync15(resolve11(monorepoGraphDist, "index.html")))
+    if (existsSync17(resolve11(monorepoGraphDist, "index.html")))
       return monorepoGraphDist;
     const singleFileBundle = resolve11(here, "..", "dist", "graph-ui");
-    if (existsSync15(resolve11(singleFileBundle, "index.html")))
+    if (existsSync17(resolve11(singleFileBundle, "index.html")))
       return singleFileBundle;
   } catch {
   }
@@ -7517,12 +8284,12 @@ function locateBundledGraphUi() {
 async function graphCommand() {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk5.dim("\u23F3 Initializing..."));
+  console.error(chalk6.dim("\u23F3 Initializing..."));
   await hub.store.initialize();
   await hub.embedder.initialize();
   const stats = await hub.store.getStats();
   if (stats.documentCount === 0) {
-    console.error(chalk5.yellow("\u26A0 No documents indexed. Run `stellavault index <vault-path>` first."));
+    console.error(chalk6.yellow("\u26A0 No documents indexed. Run `stellavault index <vault-path>` first."));
     process.exit(1);
   }
   const port = config.mcp.port || 3333;
@@ -7540,28 +8307,28 @@ async function graphCommand() {
     await api.start();
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE") {
-      console.error(chalk5.red(`Port ${port} is already in use.`));
-      console.error(chalk5.dim(`Stop the other process or use a different port:`));
-      console.error(chalk5.dim(`  Edit .stellavault.json: { "mcp": { "port": ${port + 1} } }`));
+      console.error(chalk6.red(`Port ${port} is already in use.`));
+      console.error(chalk6.dim(`Stop the other process or use a different port:`));
+      console.error(chalk6.dim(`  Edit .stellavault.json: { "mcp": { "port": ${port + 1} } }`));
       process.exit(1);
     }
     throw err;
   }
-  console.error(chalk5.green("\u{1F9E0} Stellavault \u2014 Neural Knowledge Graph"));
+  console.error(chalk6.green("\u{1F9E0} Stellavault \u2014 Neural Knowledge Graph"));
   console.error(`   \u{1F4DA} ${stats.documentCount} documents | ${stats.chunkCount} chunks`);
   console.error(`   \u{1F310} API: http://127.0.0.1:${port}`);
   if (graphUiPath) {
     const url = `http://127.0.0.1:${port}/`;
-    console.error(chalk5.green(`   \u{1F52E} Graph: ${url}`));
-    console.error(chalk5.dim(`   Press Ctrl+C to stop`));
+    console.error(chalk6.green(`   \u{1F52E} Graph: ${url}`));
+    console.error(chalk6.dim(`   Press Ctrl+C to stop`));
     openBrowser(url);
     process.on("SIGINT", () => process.exit(0));
     return;
   }
   const devGraphDir = resolve11(process.cwd(), "packages/graph");
-  const hasDevGraph = existsSync15(resolve11(devGraphDir, "package.json"));
+  const hasDevGraph = existsSync17(resolve11(devGraphDir, "package.json"));
   if (hasDevGraph) {
-    console.error(chalk5.dim("   \u{1F680} Starting Vite dev server..."));
+    console.error(chalk6.dim("   \u{1F680} Starting Vite dev server..."));
     const vite = spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["vite", "--host"], {
       cwd: devGraphDir,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7571,21 +8338,21 @@ async function graphCommand() {
       if (line.includes("Local:")) {
         const match = line.match(/http:\/\/localhost:\d+/);
         const url = match?.[0] ?? "http://localhost:5173";
-        console.error(chalk5.green(`   \u{1F52E} Graph: ${url}`));
+        console.error(chalk6.green(`   \u{1F52E} Graph: ${url}`));
         openBrowser(url);
       }
     });
     vite.on("close", () => {
-      console.error(chalk5.dim("   Vite server stopped"));
+      console.error(chalk6.dim("   Vite server stopped"));
     });
     process.on("SIGINT", () => {
       vite.kill();
       process.exit(0);
     });
   } else {
-    console.error(chalk5.yellow("   \u26A0 Bundled graph UI missing. Reinstall stellavault: npm i -g stellavault@latest"));
+    console.error(chalk6.yellow("   \u26A0 Bundled graph UI missing. Reinstall stellavault: npm i -g stellavault@latest"));
   }
-  console.error(chalk5.dim("   Press Ctrl+C to stop"));
+  console.error(chalk6.dim("   Press Ctrl+C to stop"));
 }
 async function openBrowser(url) {
   try {
@@ -7596,41 +8363,41 @@ async function openBrowser(url) {
 }
 
 // packages/cli/dist/commands/card-cmd.js
-import chalk6 from "chalk";
-import { writeFileSync as writeFileSync16 } from "node:fs";
+import chalk7 from "chalk";
+import { writeFileSync as writeFileSync17 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
 async function cardCommand(options) {
   const output = options.output ?? "knowledge-card.svg";
   const outPath = resolve12(process.cwd(), output);
-  console.error(chalk6.dim("\u23F3 Generating profile card..."));
+  console.error(chalk7.dim("\u23F3 Generating profile card..."));
   try {
     const res = await fetch("http://127.0.0.1:3333/api/profile-card");
     if (!res.ok)
       throw new Error(`API error: ${res.status}. Is 'stellavault graph' running?`);
     const svg = await res.text();
-    writeFileSync16(outPath, svg, "utf-8");
-    console.error(chalk6.green(`\u2705 Profile card saved: ${outPath}`));
-    console.error(chalk6.dim("   Embed in GitHub README:"));
-    console.error(chalk6.dim(`   ![Knowledge Card](${output})`));
+    writeFileSync17(outPath, svg, "utf-8");
+    console.error(chalk7.green(`\u2705 Profile card saved: ${outPath}`));
+    console.error(chalk7.dim("   Embed in GitHub README:"));
+    console.error(chalk7.dim(`   ![Knowledge Card](${output})`));
   } catch (err) {
-    console.error(chalk6.red(`\u274C Failed: ${err}`));
-    console.error(chalk6.dim("   Make sure API server is running: stellavault graph"));
+    console.error(chalk7.red(`\u274C Failed: ${err}`));
+    console.error(chalk7.dim("   Make sure API server is running: stellavault graph"));
     process.exit(1);
   }
 }
 
 // packages/cli/dist/commands/pack-cmd.js
-import chalk7 from "chalk";
-import { resolve as resolve13, join as join21 } from "node:path";
-import { readdirSync as readdirSync6, existsSync as existsSync16, readFileSync as readFileSync15, mkdirSync as mkdirSync16 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-var PACKS_DIR = join21(homedir13(), ".stellavault", "packs");
+import chalk8 from "chalk";
+import { resolve as resolve13, join as join23 } from "node:path";
+import { readdirSync as readdirSync6, existsSync as existsSync18, readFileSync as readFileSync16, mkdirSync as mkdirSync17 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+var PACKS_DIR = join23(homedir15(), ".stellavault", "packs");
 async function packCreateCommand(name, options) {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
   await hub.store.initialize();
   await hub.embedder.initialize();
-  console.error(chalk7.dim("\u23F3 Creating pack..."));
+  console.error(chalk8.dim("\u23F3 Creating pack..."));
   const { pack: pack2, piiReport } = await createPack(hub.store, hub.searchEngine, hub.embedder, {
     name,
     fromSearch: options.fromSearch,
@@ -7640,89 +8407,89 @@ async function packCreateCommand(name, options) {
     description: options.description,
     limit: options.limit ? parseInt(options.limit) : 100
   });
-  mkdirSync16(PACKS_DIR, { recursive: true });
-  const outPath = join21(PACKS_DIR, `${name}.sv-pack`);
+  mkdirSync17(PACKS_DIR, { recursive: true });
+  const outPath = join23(PACKS_DIR, `${name}.sv-pack`);
   exportPack(pack2, outPath);
-  console.error(chalk7.green(`\u2705 Pack created: ${name}`));
+  console.error(chalk8.green(`\u2705 Pack created: ${name}`));
   console.error(`   \u{1F4E6} ${pack2.chunks.length} chunks`);
   console.error(`   \u{1F4BE} ${outPath}`);
   if (piiReport.redactedCount > 0) {
-    console.error(chalk7.yellow(`   \u{1F512} PII masked: ${piiReport.redactedCount} items (${piiReport.types.join(", ")})`));
+    console.error(chalk8.yellow(`   \u{1F512} PII masked: ${piiReport.redactedCount} items (${piiReport.types.join(", ")})`));
   }
   await hub.store.close();
 }
 async function packExportCommand(name, options) {
-  const srcPath = join21(PACKS_DIR, `${name}.sv-pack`);
-  if (!existsSync16(srcPath)) {
-    console.error(chalk7.red(`\u274C Pack not found: ${name}`));
+  const srcPath = join23(PACKS_DIR, `${name}.sv-pack`);
+  if (!existsSync18(srcPath)) {
+    console.error(chalk8.red(`\u274C Pack not found: ${name}`));
     process.exit(1);
   }
   const outPath = resolve13(process.cwd(), options.output ?? `${name}.sv-pack`);
-  const content = readFileSync15(srcPath, "utf-8");
-  const { writeFileSync: writeFileSync22 } = await import("node:fs");
-  writeFileSync22(outPath, content);
-  console.error(chalk7.green(`\u2705 Exported: ${outPath}`));
+  const content = readFileSync16(srcPath, "utf-8");
+  const { writeFileSync: writeFileSync23 } = await import("node:fs");
+  writeFileSync23(outPath, content);
+  console.error(chalk8.green(`\u2705 Exported: ${outPath}`));
 }
 async function packImportCommand(filePath) {
   const absPath = resolve13(process.cwd(), filePath);
-  if (!existsSync16(absPath)) {
-    console.error(chalk7.red(`\u274C File not found: ${absPath}`));
+  if (!existsSync18(absPath)) {
+    console.error(chalk8.red(`\u274C File not found: ${absPath}`));
     process.exit(1);
   }
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
   await hub.store.initialize();
   await hub.embedder.initialize();
-  console.error(chalk7.dim("\u23F3 Importing pack..."));
+  console.error(chalk8.dim("\u23F3 Importing pack..."));
   const result = await importPack(hub.store, hub.embedder, absPath);
-  console.error(chalk7.green(`\u2705 Imported: ${result.imported} chunks`));
+  console.error(chalk8.green(`\u2705 Imported: ${result.imported} chunks`));
   if (result.skipped > 0)
-    console.error(chalk7.yellow(`   \u23ED\uFE0F Skipped: ${result.skipped}`));
+    console.error(chalk8.yellow(`   \u23ED\uFE0F Skipped: ${result.skipped}`));
   if (result.modelMismatch) {
-    console.error(chalk7.yellow(`   \u26A0\uFE0F Model mismatch \u2014 ${result.reEmbedded} chunks re-embedded`));
+    console.error(chalk8.yellow(`   \u26A0\uFE0F Model mismatch \u2014 ${result.reEmbedded} chunks re-embedded`));
   }
   await hub.store.close();
 }
 async function packListCommand() {
-  mkdirSync16(PACKS_DIR, { recursive: true });
+  mkdirSync17(PACKS_DIR, { recursive: true });
   const files = readdirSync6(PACKS_DIR).filter((f) => f.endsWith(".sv-pack"));
   if (files.length === 0) {
-    console.error(chalk7.dim("No packs found. Create one: stellavault pack create <name> --from-search <query>"));
+    console.error(chalk8.dim("No packs found. Create one: stellavault pack create <name> --from-search <query>"));
     return;
   }
-  console.error(chalk7.green(`\u{1F4E6} ${files.length} packs in ${PACKS_DIR}
+  console.error(chalk8.green(`\u{1F4E6} ${files.length} packs in ${PACKS_DIR}
 `));
   for (const file of files) {
     try {
-      const pack2 = JSON.parse(readFileSync15(join21(PACKS_DIR, file), "utf-8"));
-      console.error(`  ${chalk7.bold(pack2.name)} v${pack2.version} \u2014 ${pack2.chunks.length} chunks (${pack2.license})`);
+      const pack2 = JSON.parse(readFileSync16(join23(PACKS_DIR, file), "utf-8"));
+      console.error(`  ${chalk8.bold(pack2.name)} v${pack2.version} \u2014 ${pack2.chunks.length} chunks (${pack2.license})`);
     } catch {
       console.error(`  ${file} (invalid)`);
     }
   }
 }
 async function packInfoCommand(name) {
-  const filePath = join21(PACKS_DIR, `${name}.sv-pack`);
-  if (!existsSync16(filePath)) {
-    console.error(chalk7.red(`\u274C Pack not found: ${name}`));
+  const filePath = join23(PACKS_DIR, `${name}.sv-pack`);
+  if (!existsSync18(filePath)) {
+    console.error(chalk8.red(`\u274C Pack not found: ${name}`));
     process.exit(1);
   }
-  const pack2 = JSON.parse(readFileSync15(filePath, "utf-8"));
+  const pack2 = JSON.parse(readFileSync16(filePath, "utf-8"));
   console.error(packToSummary(pack2));
 }
 
 // packages/cli/dist/commands/decay-cmd.js
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 async function decayCommand(_opts, cmd) {
   const globalOpts = cmd?.parent?.opts?.() ?? {};
   const jsonMode = globalOpts.json;
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk8.dim("\u23F3 Initializing..."));
+  console.error(chalk9.dim("\u23F3 Initializing..."));
   await hub.store.initialize();
   const db = hub.store.getDb();
   if (!db) {
-    console.error(chalk8.red("\u274C Cannot access database"));
+    console.error(chalk9.red("\u274C Cannot access database"));
     process.exit(1);
   }
   const decayEngine = new DecayEngine(db);
@@ -7732,65 +8499,65 @@ async function decayCommand(_opts, cmd) {
     await hub.store.close();
     return;
   }
-  console.log(chalk8.green("\n\u{1F9E0} Knowledge Decay Report"));
-  console.log(chalk8.dim("\u2500".repeat(50)));
+  console.log(chalk9.green("\n\u{1F9E0} Knowledge Decay Report"));
+  console.log(chalk9.dim("\u2500".repeat(50)));
   console.log(`  \u{1F4C4} Total documents:  ${report.totalDocuments}`);
-  console.log(`  \u26A0\uFE0F  Decaying (R<0.5): ${chalk8.yellow(String(report.decayingCount))}`);
-  console.log(`  \u{1F534} Critical (R<0.3): ${chalk8.red(String(report.criticalCount))}`);
+  console.log(`  \u26A0\uFE0F  Decaying (R<0.5): ${chalk9.yellow(String(report.decayingCount))}`);
+  console.log(`  \u{1F534} Critical (R<0.3): ${chalk9.red(String(report.criticalCount))}`);
   console.log(`  \u{1F4CA} Average R:        ${report.averageR}`);
-  console.log(chalk8.dim("\u2500".repeat(50)));
+  console.log(chalk9.dim("\u2500".repeat(50)));
   if (report.topDecaying.length > 0) {
-    console.log(chalk8.yellow("\n\u{1F4CB} Top Decaying Notes (need review):"));
+    console.log(chalk9.yellow("\n\u{1F4CB} Top Decaying Notes (need review):"));
     for (const d of report.topDecaying.slice(0, 20)) {
       const rBar = "\u2588".repeat(Math.round(d.retrievability * 10)) + "\u2591".repeat(10 - Math.round(d.retrievability * 10));
-      const color = d.retrievability < 0.3 ? chalk8.red : chalk8.yellow;
+      const color = d.retrievability < 0.3 ? chalk9.red : chalk9.yellow;
       console.log(`  ${color(rBar)} R=${d.retrievability.toFixed(2)} | ${d.daysSinceAccess}d ago | ${d.title}`);
     }
   }
   if (report.clusterHealth.length > 0) {
-    console.log(chalk8.dim("\n\u{1F4CA} Cluster Health:"));
+    console.log(chalk9.dim("\n\u{1F4CA} Cluster Health:"));
     for (const c of report.clusterHealth.slice(0, 10)) {
-      const color = c.avgR < 0.3 ? chalk8.red : c.avgR < 0.5 ? chalk8.yellow : chalk8.green;
+      const color = c.avgR < 0.3 ? chalk9.red : c.avgR < 0.5 ? chalk9.yellow : chalk9.green;
       console.log(`  ${color(`R=${c.avgR.toFixed(2)}`)} | ${c.count} docs | ${c.label}`);
     }
   }
-  console.log(chalk8.dim("\n\u{1F4A1} Tip: stellavault search <topic> to refresh decaying knowledge"));
+  console.log(chalk9.dim("\n\u{1F4A1} Tip: stellavault search <topic> to refresh decaying knowledge"));
 }
 
 // packages/cli/dist/commands/sync-cmd.js
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { spawn as spawn2 } from "node:child_process";
 import { resolve as resolve14 } from "node:path";
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 async function syncCommand(options) {
   const syncDir = resolve14(process.cwd(), "packages/sync");
   const syncScript = resolve14(syncDir, "sync-to-obsidian.mjs");
-  if (!existsSync17(syncScript)) {
-    console.error(chalk9.red("\u274C packages/sync/sync-to-obsidian.mjs not found"));
-    console.error(chalk9.dim("   Run from project root: cd notion-obsidian-sync"));
+  if (!existsSync19(syncScript)) {
+    console.error(chalk10.red("\u274C packages/sync/sync-to-obsidian.mjs not found"));
+    console.error(chalk10.dim("   Run from project root: cd notion-obsidian-sync"));
     process.exit(1);
   }
   const envFile = resolve14(syncDir, ".env");
-  if (!existsSync17(envFile)) {
-    console.error(chalk9.red("\u274C packages/sync/.env not found"));
-    console.error(chalk9.dim("   Copy .env.example \u2192 .env and set NOTION_TOKEN"));
+  if (!existsSync19(envFile)) {
+    console.error(chalk10.red("\u274C packages/sync/.env not found"));
+    console.error(chalk10.dim("   Copy .env.example \u2192 .env and set NOTION_TOKEN"));
     process.exit(1);
   }
   if (options.upload) {
     const uploadScript = resolve14(syncDir, "upload-pdca-to-notion.mjs");
-    if (!existsSync17(uploadScript)) {
-      console.error(chalk9.red("\u274C upload-pdca-to-notion.mjs not found"));
+    if (!existsSync19(uploadScript)) {
+      console.error(chalk10.red("\u274C upload-pdca-to-notion.mjs not found"));
       process.exit(1);
     }
-    console.error(chalk9.dim("\u{1F4E4} Uploading PDCA documents to Notion..."));
+    console.error(chalk10.dim("\u{1F4E4} Uploading PDCA documents to Notion..."));
     await runScript(uploadScript, syncDir);
   } else {
-    console.error(chalk9.dim("\u{1F504} Syncing Notion \u2192 Obsidian..."));
+    console.error(chalk10.dim("\u{1F504} Syncing Notion \u2192 Obsidian..."));
     await runScript(syncScript, syncDir);
     if (options.watch) {
-      console.error(chalk9.green("\u{1F440} Watch mode \u2014 syncing every 5 minutes"));
+      console.error(chalk10.green("\u{1F440} Watch mode \u2014 syncing every 5 minutes"));
       setInterval(async () => {
-        console.error(chalk9.dim(`\u{1F504} [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Re-syncing...`));
+        console.error(chalk10.dim(`\u{1F504} [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Re-syncing...`));
         await runScript(syncScript, syncDir);
       }, 5 * 60 * 1e3);
       process.stdin.resume();
@@ -7815,7 +8582,7 @@ function runScript(scriptPath, cwd) {
 }
 
 // packages/cli/dist/commands/review-cmd.js
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import { createInterface } from "node:readline";
 function globToRegex(glob) {
   const esc = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
@@ -7839,11 +8606,11 @@ async function reviewCommand(options) {
   const minAgeDays = parseInt(options.minAge ?? "0", 10);
   const excludeRe = options.exclude ? globToRegex(options.exclude) : null;
   if (!options.json)
-    console.error(chalk10.dim("\u23F3 Initializing..."));
+    console.error(chalk11.dim("\u23F3 Initializing..."));
   await hub.store.initialize();
   const db = hub.store.getDb();
   if (!db) {
-    console.error(chalk10.red("\u274C Cannot access database"));
+    console.error(chalk11.red("\u274C Cannot access database"));
     process.exit(1);
   }
   const decayEngine = new DecayEngine(db);
@@ -7883,12 +8650,12 @@ async function reviewCommand(options) {
     return;
   }
   if (decaying.length === 0) {
-    console.log(chalk10.green("\n\u2728 All knowledge is healthy! No notes to review."));
+    console.log(chalk11.green("\n\u2728 All knowledge is healthy! No notes to review."));
     return;
   }
-  console.log(chalk10.green(`
+  console.log(chalk11.green(`
 \u{1F9E0} Today's review (${decaying.length})`));
-  console.log(chalk10.dim("\u2500".repeat(50)));
+  console.log(chalk11.dim("\u2500".repeat(50)));
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const ask2 = (q) => new Promise((r) => rl.question(q, r));
   let reviewed = 0;
@@ -7896,13 +8663,13 @@ async function reviewCommand(options) {
     const d = decaying[i];
     const elapsed = Math.round((Date.now() - new Date(d.lastAccess).getTime()) / 864e5);
     const rBar = "\u2588".repeat(Math.round(d.retrievability * 10)) + "\u2591".repeat(10 - Math.round(d.retrievability * 10));
-    const color = d.retrievability < 0.3 ? chalk10.red : chalk10.yellow;
+    const color = d.retrievability < 0.3 ? chalk11.red : chalk11.yellow;
     console.log(`
-${chalk10.bold(`[${i + 1}/${decaying.length}]`)} ${chalk10.cyan(d.title)}`);
+${chalk11.bold(`[${i + 1}/${decaying.length}]`)} ${chalk11.cyan(d.title)}`);
     console.log(`  ${color(rBar)} R=${d.retrievability.toFixed(2)} | ${elapsed} days ago`);
-    const answer = await ask2(chalk10.dim("  \u2192 [y]open [n]skip [s]snooze [q]quit: "));
+    const answer = await ask2(chalk11.dim("  \u2192 [y]open [n]skip [s]snooze [q]quit: "));
     if (answer.toLowerCase() === "q") {
-      console.log(chalk10.dim("\nReview stopped."));
+      console.log(chalk11.dim("\nReview stopped."));
       break;
     }
     if (answer.toLowerCase() === "s") {
@@ -7912,7 +8679,7 @@ ${chalk10.bold(`[${i + 1}/${decaying.length}]`)} ${chalk10.cyan(d.title)}`);
         timestamp: new Date(Date.now() - 23 * 36e5).toISOString()
         // 23시간 전으로 기록
       });
-      console.log(chalk10.dim("  \u23F0 Reminder set for tomorrow"));
+      console.log(chalk11.dim("  \u23F0 Reminder set for tomorrow"));
       continue;
     }
     if (answer.toLowerCase() === "y") {
@@ -7935,14 +8702,14 @@ ${chalk10.bold(`[${i + 1}/${decaying.length}]`)} ${chalk10.cyan(d.title)}`);
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       reviewed++;
-      console.log(chalk10.green("  \u2705 Opened + memory strength updated"));
+      console.log(chalk11.green("  \u2705 Opened + memory strength updated"));
     } else {
-      console.log(chalk10.dim("  \u23ED\uFE0F Skipped"));
+      console.log(chalk11.dim("  \u23ED\uFE0F Skipped"));
     }
   }
   rl.close();
-  console.log(chalk10.dim("\n\u2500".repeat(50)));
-  console.log(chalk10.green(`Review complete! ${reviewed}/${decaying.length} reviewed`));
+  console.log(chalk11.dim("\n\u2500".repeat(50)));
+  console.log(chalk11.green(`Review complete! ${reviewed}/${decaying.length} reviewed`));
   try {
     const days = db.prepare(`
       SELECT DISTINCT date(accessed_at) as d FROM access_log
@@ -7959,94 +8726,94 @@ ${chalk10.bold(`[${i + 1}/${decaying.length}]`)} ${chalk10.cyan(d.title)}`);
         break;
     }
     if (streak > 1) {
-      console.log(chalk10.yellow(`\u{1F525} ${streak}-day review streak!`));
+      console.log(chalk11.yellow(`\u{1F525} ${streak}-day review streak!`));
     }
   } catch {
   }
 }
 
 // packages/cli/dist/commands/duplicates-cmd.js
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 async function duplicatesCommand(options) {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
   const threshold = parseFloat(options.threshold ?? "0.88");
-  console.error(chalk11.dim("\u23F3 Scanning for duplicates..."));
+  console.error(chalk12.dim("\u23F3 Scanning for duplicates..."));
   await hub.store.initialize();
   await hub.embedder.initialize();
   const pairs = await detectDuplicates(hub.store, threshold, 20);
   if (pairs.length === 0) {
-    console.log(chalk11.green("\n\u2728 No duplicate notes found!"));
+    console.log(chalk12.green("\n\u2728 No duplicate notes found!"));
     return;
   }
-  console.log(chalk11.yellow(`
+  console.log(chalk12.yellow(`
 \u{1F50D} Found ${pairs.length} similar note pairs (threshold: ${threshold})`));
-  console.log(chalk11.dim("\u2500".repeat(60)));
+  console.log(chalk12.dim("\u2500".repeat(60)));
   for (let i = 0; i < pairs.length; i++) {
     const p = pairs[i];
     const pct = Math.round(p.similarity * 100);
-    const color = pct >= 95 ? chalk11.red : chalk11.yellow;
+    const color = pct >= 95 ? chalk12.red : chalk12.yellow;
     console.log(`
-${chalk11.bold(`[${i + 1}]`)} ${color(`${pct}% similar`)}`);
-    console.log(`  A: ${chalk11.cyan(p.docA.title)}`);
-    console.log(`     ${chalk11.dim(p.docA.filePath)}`);
-    console.log(`  B: ${chalk11.cyan(p.docB.title)}`);
-    console.log(`     ${chalk11.dim(p.docB.filePath)}`);
+${chalk12.bold(`[${i + 1}]`)} ${color(`${pct}% similar`)}`);
+    console.log(`  A: ${chalk12.cyan(p.docA.title)}`);
+    console.log(`     ${chalk12.dim(p.docA.filePath)}`);
+    console.log(`  B: ${chalk12.cyan(p.docB.title)}`);
+    console.log(`     ${chalk12.dim(p.docB.filePath)}`);
   }
-  console.log(chalk11.dim("\n\u{1F4A1} Merge or delete duplicates in Obsidian"));
+  console.log(chalk12.dim("\n\u{1F4A1} Merge or delete duplicates in Obsidian"));
 }
 
 // packages/cli/dist/commands/gaps-cmd.js
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function gapsCommand() {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk12.dim("\u23F3 Analyzing knowledge gaps..."));
+  console.error(chalk13.dim("\u23F3 Analyzing knowledge gaps..."));
   await hub.store.initialize();
   await hub.embedder.initialize();
   const report = await detectKnowledgeGaps(hub.store);
-  console.log(chalk12.green("\n\u{1F573}\uFE0F Knowledge Gap Report"));
-  console.log(chalk12.dim("\u2500".repeat(50)));
+  console.log(chalk13.green("\n\u{1F573}\uFE0F Knowledge Gap Report"));
+  console.log(chalk13.dim("\u2500".repeat(50)));
   console.log(`  Clusters: ${report.totalClusters}`);
-  console.log(`  Gaps: ${chalk12.yellow(String(report.totalGaps))} (High+Medium)`);
+  console.log(`  Gaps: ${chalk13.yellow(String(report.totalGaps))} (High+Medium)`);
   console.log(`  Isolated nodes: ${report.isolatedNodes.length}`);
-  console.log(chalk12.dim("\u2500".repeat(50)));
+  console.log(chalk13.dim("\u2500".repeat(50)));
   if (report.gaps.length > 0) {
-    console.log(chalk12.yellow("\n\u{1F4CA} Inter-cluster gaps:"));
+    console.log(chalk13.yellow("\n\u{1F4CA} Inter-cluster gaps:"));
     for (const gap of report.gaps) {
       const icon = gap.severity === "high" ? "\u{1F534}" : gap.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
       console.log(`  ${icon} ${gap.clusterA} \u2194 ${gap.clusterB}`);
-      console.log(`     Bridges: ${gap.bridgeCount} | Suggestion: ${chalk12.cyan(gap.suggestedTopic)}`);
+      console.log(`     Bridges: ${gap.bridgeCount} | Suggestion: ${chalk13.cyan(gap.suggestedTopic)}`);
     }
   }
   if (report.isolatedNodes.length > 0) {
-    console.log(chalk12.dim("\n\u{1F3DD}\uFE0F Isolated notes (\u22641 connections):"));
+    console.log(chalk13.dim("\n\u{1F3DD}\uFE0F Isolated notes (\u22641 connections):"));
     for (const n of report.isolatedNodes.slice(0, 10)) {
       console.log(`  \u2022 ${n.title} (${n.connections} connections)`);
     }
   }
-  console.log(chalk12.dim("\n\u{1F4A1} Filling knowledge gaps strengthens your graph"));
+  console.log(chalk13.dim("\n\u{1F4A1} Filling knowledge gaps strengthens your graph"));
 }
 
 // packages/cli/dist/commands/clip-cmd.js
-import chalk13 from "chalk";
-import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync17 } from "node:fs";
-import { join as join22 } from "node:path";
+import chalk14 from "chalk";
+import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync18 } from "node:fs";
+import { join as join24 } from "node:path";
 async function clipCommand(url, options) {
   if (!url) {
-    console.error(chalk13.red("\u274C Please provide a URL: stellavault clip <url>"));
+    console.error(chalk14.red("\u274C Please provide a URL: stellavault clip <url>"));
     process.exit(1);
   }
   const config = loadConfig();
   const vaultPath = config.vaultPath;
   if (!vaultPath) {
-    console.error(chalk13.red("\u274C vaultPath not configured"));
+    console.error(chalk14.red("\u274C vaultPath not configured"));
     process.exit(1);
   }
   const folder = options.folder ?? "06_Research/clips";
-  const targetDir = join22(vaultPath, folder);
-  mkdirSync17(targetDir, { recursive: true });
-  console.error(chalk13.dim(`\u{1F4CE} Clipping: ${url}`));
+  const targetDir = join24(vaultPath, folder);
+  mkdirSync18(targetDir, { recursive: true });
+  console.error(chalk14.dim(`\u{1F4CE} Clipping: ${url}`));
   try {
     const isYouTube = /youtube\.com\/watch|youtu\.be\//.test(url);
     let title;
@@ -8063,7 +8830,7 @@ async function clipCommand(url, options) {
     const safeTitle = title.replace(/[<>:"/\\|?*]/g, "").replace(/\s+/g, " ").trim().slice(0, 80);
     const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const fileName = `${date} ${safeTitle}.md`;
-    const filePath = join22(targetDir, fileName);
+    const filePath = join24(targetDir, fileName);
     const md = [
       "---",
       `title: "${safeTitle}"`,
@@ -8079,12 +8846,12 @@ async function clipCommand(url, options) {
       "",
       content
     ].join("\n");
-    writeFileSync17(filePath, md, "utf-8");
-    console.log(chalk13.green(`\u2705 Saved: ${fileName}`));
-    console.log(chalk13.dim(`   \u2192 ${filePath}`));
-    console.log(chalk13.dim("   \u{1F4A1} Run stellavault index to make it searchable"));
+    writeFileSync18(filePath, md, "utf-8");
+    console.log(chalk14.green(`\u2705 Saved: ${fileName}`));
+    console.log(chalk14.dim(`   \u2192 ${filePath}`));
+    console.log(chalk14.dim("   \u{1F4A1} Run stellavault index to make it searchable"));
   } catch (err) {
-    console.error(chalk13.red(`\u274C Clip failed: ${err.message}`));
+    console.error(chalk14.red(`\u274C Clip failed: ${err.message}`));
     process.exit(1);
   }
 }
@@ -8127,7 +8894,7 @@ async function clipYouTube(url) {
 }
 
 // packages/cli/dist/commands/brief-cmd.js
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 async function briefCommand() {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
@@ -8135,31 +8902,31 @@ async function briefCommand() {
   await hub.embedder.initialize();
   const db = hub.store.getDb();
   if (!db) {
-    console.error(chalk14.red("\u274C Cannot access database"));
+    console.error(chalk15.red("\u274C Cannot access database"));
     process.exit(1);
   }
   const decayEngine = new DecayEngine(db);
   const stats = await hub.store.getStats();
-  console.log(chalk14.green("\n\u2600\uFE0F Good morning! Today's knowledge briefing"));
-  console.log(chalk14.dim("\u2500".repeat(50)));
+  console.log(chalk15.green("\n\u2600\uFE0F Good morning! Today's knowledge briefing"));
+  console.log(chalk15.dim("\u2500".repeat(50)));
   console.log(`
-\u{1F4DA} ${chalk14.bold(String(stats.documentCount))} notes | ${stats.chunkCount} chunks`);
+\u{1F4DA} ${chalk15.bold(String(stats.documentCount))} notes | ${stats.chunkCount} chunks`);
   const report = await decayEngine.computeAll();
-  const avgRColor = report.averageR >= 0.7 ? chalk14.green : report.averageR >= 0.5 ? chalk14.yellow : chalk14.red;
-  console.log(`\u{1F9E0} Overall health: ${avgRColor("R=" + report.averageR)} | Decaying ${chalk14.yellow(String(report.decayingCount))} | Critical ${chalk14.red(String(report.criticalCount))}`);
+  const avgRColor = report.averageR >= 0.7 ? chalk15.green : report.averageR >= 0.5 ? chalk15.yellow : chalk15.red;
+  console.log(`\u{1F9E0} Overall health: ${avgRColor("R=" + report.averageR)} | Decaying ${chalk15.yellow(String(report.decayingCount))} | Critical ${chalk15.red(String(report.criticalCount))}`);
   if (report.topDecaying.length > 0) {
-    console.log(chalk14.yellow("\n\u{1F4CB} Review recommendations:"));
+    console.log(chalk15.yellow("\n\u{1F4CB} Review recommendations:"));
     for (const d of report.topDecaying.slice(0, 5)) {
       const bar = "\u2588".repeat(Math.round(d.retrievability * 10)) + "\u2591".repeat(10 - Math.round(d.retrievability * 10));
-      console.log(`  ${chalk14.dim(bar)} R=${d.retrievability.toFixed(2)} ${d.title}`);
+      console.log(`  ${chalk15.dim(bar)} R=${d.retrievability.toFixed(2)} ${d.title}`);
     }
-    console.log(chalk14.dim("  \u2192 Run stellavault review to start"));
+    console.log(chalk15.dim("  \u2192 Run stellavault review to start"));
   }
   try {
     const gapReport = await detectKnowledgeGaps(hub.store);
     const highGaps = gapReport.gaps.filter((g) => g.severity === "high");
     if (highGaps.length > 0) {
-      console.log(chalk14.yellow(`
+      console.log(chalk15.yellow(`
 \u{1F573}\uFE0F ${highGaps.length} knowledge gaps:`));
       for (const g of highGaps.slice(0, 3)) {
         console.log(`  \u{1F534} ${g.clusterA.replace(/\s*\(\d+\)$/, "")} \u2194 ${g.clusterB.replace(/\s*\(\d+\)$/, "")}`);
@@ -8181,7 +8948,7 @@ async function briefCommand() {
         break;
     }
     if (streak > 0)
-      console.log(chalk14.yellow(`
+      console.log(chalk15.yellow(`
 \u{1F525} ${streak}-day review streak!`));
   } catch {
   }
@@ -8192,7 +8959,7 @@ async function briefCommand() {
       GROUP BY document_id ORDER BY cnt DESC LIMIT 3
     `).all();
     if (recent.length > 0) {
-      console.log(chalk14.dim("\n\u{1F4CA} Most viewed notes this week:"));
+      console.log(chalk15.dim("\n\u{1F4CA} Most viewed notes this week:"));
       for (const r of recent) {
         const doc = db.prepare("SELECT title FROM documents WHERE id = ?").get(r.document_id);
         console.log(`  ${r.cnt} views \u2014 ${doc?.title ?? r.document_id}`);
@@ -8200,12 +8967,12 @@ async function briefCommand() {
     }
   } catch {
   }
-  console.log("\n" + chalk14.dim("\u2500".repeat(50)));
-  console.log(chalk14.dim("\u{1F4A1} stellavault review | stellavault gaps | stellavault graph"));
+  console.log("\n" + chalk15.dim("\u2500".repeat(50)));
+  console.log(chalk15.dim("\u{1F4A1} stellavault review | stellavault gaps | stellavault graph"));
 }
 
 // packages/cli/dist/commands/digest-cmd.js
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 async function digestCommand(options) {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
@@ -8213,12 +8980,12 @@ async function digestCommand(options) {
   await hub.store.initialize();
   const db = hub.store.getDb();
   if (!db) {
-    console.error(chalk15.red("\u274C Cannot access database"));
+    console.error(chalk16.red("\u274C Cannot access database"));
     process.exit(1);
   }
-  console.log(chalk15.green(`
+  console.log(chalk16.green(`
 \u{1F4CA} Knowledge activity report (last ${days} days)`));
-  console.log(chalk15.dim("\u2500".repeat(50)));
+  console.log(chalk16.dim("\u2500".repeat(50)));
   const accessStats = db.prepare(`
     SELECT access_type, COUNT(*) as cnt
     FROM access_log WHERE accessed_at > datetime('now', '-${days} days')
@@ -8226,7 +8993,7 @@ async function digestCommand(options) {
   `).all();
   const totalAccess = accessStats.reduce((s, r) => s + r.cnt, 0);
   console.log(`
-\u{1F50D} Total access: ${chalk15.bold(String(totalAccess))} times`);
+\u{1F50D} Total access: ${chalk16.bold(String(totalAccess))} times`);
   for (const r of accessStats) {
     const icon = r.access_type === "view" ? "\u{1F441}\uFE0F" : r.access_type === "search" ? "\u{1F50D}" : "\u{1F916}";
     console.log(`  ${icon} ${r.access_type}: ${r.cnt} times`);
@@ -8240,11 +9007,11 @@ async function digestCommand(options) {
     ORDER BY cnt DESC LIMIT 10
   `).all();
   if (topDocs.length > 0) {
-    console.log(chalk15.dim(`
+    console.log(chalk16.dim(`
 \u{1F4C4} Most accessed notes:`));
     for (const d of topDocs) {
       const bar = "\u2588".repeat(Math.min(d.cnt, 20));
-      console.log(`  ${chalk15.cyan(bar)} ${d.cnt} views ${d.title}`);
+      console.log(`  ${chalk16.cyan(bar)} ${d.cnt} views ${d.title}`);
     }
   }
   const dailyActivity = db.prepare(`
@@ -8253,12 +9020,12 @@ async function digestCommand(options) {
     GROUP BY day ORDER BY day
   `).all();
   if (dailyActivity.length > 0) {
-    console.log(chalk15.dim("\n\u{1F4C5} Daily activity:"));
+    console.log(chalk16.dim("\n\u{1F4C5} Daily activity:"));
     const maxCnt = Math.max(...dailyActivity.map((d) => d.cnt));
     for (const d of dailyActivity) {
       const barLen = Math.round(d.cnt / maxCnt * 20);
       const bar = "\u2588".repeat(barLen) + "\u2591".repeat(20 - barLen);
-      console.log(`  ${d.day.slice(5)} ${chalk15.green(bar)} ${d.cnt}`);
+      console.log(`  ${d.day.slice(5)} ${chalk16.green(bar)} ${d.cnt}`);
     }
   }
   const typeStats = db.prepare(`
@@ -8269,7 +9036,7 @@ async function digestCommand(options) {
     GROUP BY d.type ORDER BY cnt DESC
   `).all();
   if (typeStats.length > 0) {
-    console.log(chalk15.dim("\n\u{1F4CA} Note types accessed:"));
+    console.log(chalk16.dim("\n\u{1F4CA} Note types accessed:"));
     for (const t2 of typeStats) {
       console.log(`  ${t2.type}: ${t2.cnt}`);
     }
@@ -8278,16 +9045,16 @@ async function digestCommand(options) {
   const report = await decayEngine.computeAll();
   console.log(`
 \u{1F9E0} Health: R=${report.averageR} | Decaying ${report.decayingCount} | Critical ${report.criticalCount}`);
-  console.log(chalk15.dim("\n\u2550".repeat(50)));
+  console.log(chalk16.dim("\n\u2550".repeat(50)));
   if (options.visual) {
-    const { writeFileSync: writeFileSync22, mkdirSync: mkdirSync22, existsSync: existsSync25 } = await import("node:fs");
-    const { join: join30, resolve: resolve22 } = await import("node:path");
+    const { writeFileSync: writeFileSync23, mkdirSync: mkdirSync23, existsSync: existsSync27 } = await import("node:fs");
+    const { join: join32, resolve: resolve22 } = await import("node:path");
     const outputDir = resolve22(config.vaultPath, "_stellavault/digests");
-    if (!existsSync25(outputDir))
-      mkdirSync22(outputDir, { recursive: true });
+    if (!existsSync27(outputDir))
+      mkdirSync23(outputDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const filename = `digest-${date}.md`;
-    const outputPath = join30(outputDir, filename);
+    const outputPath = join32(outputDir, filename);
     const pieData = (typeStats.length > 0 ? typeStats : [{ type: "note", cnt: 1 }]).map((t2) => `    "${t2.type}" : ${t2.cnt}`).join("\n");
     const timelineData = dailyActivity.map((d) => `    ${d.day.slice(5)} : ${d.cnt}`).join("\n");
     const md = [
@@ -8325,22 +9092,22 @@ async function digestCommand(options) {
       "---",
       `*Generated by \`stellavault digest --visual\` on ${(/* @__PURE__ */ new Date()).toISOString()}*`
     ].filter(Boolean).join("\n");
-    writeFileSync22(outputPath, md, "utf-8");
-    console.log(chalk15.green(`
+    writeFileSync23(outputPath, md, "utf-8");
+    console.log(chalk16.green(`
 Visual digest saved: ${filename}`));
-    console.log(chalk15.dim(`Open in Obsidian to see Mermaid charts.`));
+    console.log(chalk16.dim(`Open in Obsidian to see Mermaid charts.`));
   }
 }
 
 // packages/cli/dist/commands/init-cmd.js
 import { createInterface as createInterface2 } from "node:readline";
-import { existsSync as existsSync18, mkdirSync as mkdirSync18, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join23 } from "node:path";
-import { homedir as homedir14 } from "node:os";
+import { existsSync as existsSync20, mkdirSync as mkdirSync19, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join25 } from "node:path";
+import { homedir as homedir16 } from "node:os";
 import ora2 from "ora";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 function ask(rl, question, defaultVal) {
-  const suffix = defaultVal ? ` ${chalk16.dim(`(${defaultVal})`)}` : "";
+  const suffix = defaultVal ? ` ${chalk17.dim(`(${defaultVal})`)}` : "";
   return new Promise((resolve22) => {
     rl.question(`${question}${suffix}: `, (answer) => {
       resolve22(answer.trim() || defaultVal || "");
@@ -8349,31 +9116,31 @@ function ask(rl, question, defaultVal) {
 }
 async function initCommand() {
   console.log("");
-  console.log(chalk16.bold("  \u2726 Stellavault Setup Wizard"));
-  console.log(chalk16.dim("  Notes die in folders. Let's bring yours to life.\n"));
+  console.log(chalk17.bold("  \u2726 Stellavault Setup Wizard"));
+  console.log(chalk17.dim("  Notes die in folders. Let's bring yours to life.\n"));
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
-    console.log(chalk16.cyan("  Step 1/3") + " \u2014 Where is your Obsidian vault?");
-    console.log(chalk16.dim("  This is the folder containing your .md files.\n"));
+    console.log(chalk17.cyan("  Step 1/3") + " \u2014 Where is your Obsidian vault?");
+    console.log(chalk17.dim("  This is the folder containing your .md files.\n"));
     let vaultPath = "";
     while (!vaultPath) {
       const input = await ask(rl, "  Vault path");
       if (!input) {
-        console.log(chalk16.yellow("  Please enter your vault path."));
+        console.log(chalk17.yellow("  Please enter your vault path."));
         continue;
       }
-      const resolved = input.replace(/^~/, homedir14());
-      if (!existsSync18(resolved)) {
-        console.log(chalk16.yellow(`  Path not found: ${resolved}`));
+      const resolved = input.replace(/^~/, homedir16());
+      if (!existsSync20(resolved)) {
+        console.log(chalk17.yellow(`  Path not found: ${resolved}`));
         continue;
       }
       vaultPath = resolved;
     }
-    console.log(chalk16.green(`  \u2713 Vault: ${vaultPath}
+    console.log(chalk17.green(`  \u2713 Vault: ${vaultPath}
 `));
-    const configDir = join23(homedir14(), ".stellavault");
-    mkdirSync18(configDir, { recursive: true });
-    const dbPath = join23(configDir, "index.db");
+    const configDir = join25(homedir16(), ".stellavault");
+    mkdirSync19(configDir, { recursive: true });
+    const dbPath = join25(configDir, "index.db");
     const configData = {
       vaultPath,
       dbPath,
@@ -8382,11 +9149,11 @@ async function initCommand() {
       search: { defaultLimit: 10, rrfK: 60 },
       mcp: { mode: "stdio", port: 3333 }
     };
-    writeFileSync18(join23(homedir14(), ".stellavault.json"), JSON.stringify(configData, null, 2), "utf-8");
-    console.log(chalk16.dim(`  Config saved: ~/.stellavault.json`));
+    writeFileSync19(join25(homedir16(), ".stellavault.json"), JSON.stringify(configData, null, 2), "utf-8");
+    console.log(chalk17.dim(`  Config saved: ~/.stellavault.json`));
     console.log("");
-    console.log(chalk16.cyan("  Step 2/3") + " \u2014 Indexing your vault");
-    console.log(chalk16.dim("  Vectorizing notes with local AI (no data leaves your machine).\n"));
+    console.log(chalk17.cyan("  Step 2/3") + " \u2014 Indexing your vault");
+    console.log(chalk17.dim("  Vectorizing notes with local AI (no data leaves your machine).\n"));
     const spinner = ora2({ text: "  Loading embedding model (first run downloads ~30MB, please wait)...", indent: 2 }).start();
     const store = createSqliteVecStore(dbPath);
     await store.initialize();
@@ -8403,11 +9170,11 @@ async function initCommand() {
         spinner.text = `  [${bar}] ${pct}% (${current}/${total}) ${doc.title.slice(0, 30)}`;
       }
     });
-    spinner.succeed(chalk16.green(`  Indexed ${result.indexed} docs, ${result.totalChunks} chunks (${(result.elapsedMs / 1e3).toFixed(1)}s)`));
+    spinner.succeed(chalk17.green(`  Indexed ${result.indexed} docs, ${result.totalChunks} chunks (${(result.elapsedMs / 1e3).toFixed(1)}s)`));
     if (result.indexed === 0) {
-      console.log(chalk16.yellow("\n  Your vault is empty \u2014 creating 3 starter notes so you can explore.\n"));
-      const rawDir = join23(vaultPath, "raw");
-      mkdirSync18(rawDir, { recursive: true });
+      console.log(chalk17.yellow("\n  Your vault is empty \u2014 creating 3 starter notes so you can explore.\n"));
+      const rawDir = join25(vaultPath, "raw");
+      mkdirSync19(rawDir, { recursive: true });
       const samples = [
         {
           file: "welcome-to-stellavault.md",
@@ -8480,7 +9247,7 @@ Andrej Karpathy's approach: every session auto-compiles into structured knowledg
         }
       ];
       for (const s of samples) {
-        writeFileSync18(join23(rawDir, s.file), s.content, "utf-8");
+        writeFileSync19(join25(rawDir, s.file), s.content, "utf-8");
       }
       const reSpinner = ora2({ text: "  Indexing sample notes...", indent: 2 }).start();
       const reResult = await indexVault(vaultPath, {
@@ -8488,83 +9255,88 @@ Andrej Karpathy's approach: every session auto-compiles into structured knowledg
         embedder,
         chunkOptions: { maxTokens: 300, overlap: 50, minTokens: 50 }
       });
-      reSpinner.succeed(chalk16.green(`  Indexed ${reResult.indexed} sample notes, ${reResult.totalChunks} chunks`));
+      reSpinner.succeed(chalk17.green(`  Indexed ${reResult.indexed} sample notes, ${reResult.totalChunks} chunks`));
     }
     console.log("");
-    console.log(chalk16.cyan("  Step 3/3") + " \u2014 Try your first search");
-    console.log(chalk16.dim("  Type a topic you know about. Stellavault finds connections.\n"));
+    console.log(chalk17.cyan("  Step 3/3") + " \u2014 Try your first search");
+    console.log(chalk17.dim("  Type a topic you know about. Stellavault finds connections.\n"));
     const searchEngine = createSearchEngine({ store, embedder, rrfK: 60 });
     let searchDone = false;
     while (!searchDone) {
       const query = await ask(rl, "  Search");
       if (!query) {
-        console.log(chalk16.dim("  Type something, or press Ctrl+C to skip."));
+        console.log(chalk17.dim("  Type something, or press Ctrl+C to skip."));
         continue;
       }
       const searchSpinner = ora2({ text: "  Searching...", indent: 2 }).start();
       const results = await searchEngine.search({ query, limit: 5 });
       searchSpinner.stop();
       if (results.length === 0) {
-        console.log(chalk16.yellow("  No results. Try a different topic."));
+        console.log(chalk17.yellow("  No results. Try a different topic."));
         continue;
       }
       console.log("");
       for (const r of results) {
         const score = Math.round(r.score * 100);
-        const bar = score >= 70 ? chalk16.green("\u25CF") : score >= 40 ? chalk16.yellow("\u25CF") : chalk16.dim("\u25CF");
-        console.log(`  ${bar} ${chalk16.bold(r.document.title)} ${chalk16.dim(`(${score}%)`)}`);
+        const bar = score >= 70 ? chalk17.green("\u25CF") : score >= 40 ? chalk17.yellow("\u25CF") : chalk17.dim("\u25CF");
+        console.log(`  ${bar} ${chalk17.bold(r.document.title)} ${chalk17.dim(`(${score}%)`)}`);
         if (r.highlights[0]) {
-          console.log(`    ${chalk16.dim(r.highlights[0].slice(0, 80))}...`);
+          console.log(`    ${chalk17.dim(r.highlights[0].slice(0, 80))}...`);
         }
       }
       console.log("");
       searchDone = true;
     }
     await store.close();
-    console.log(chalk16.bold.green("  \u2726 Setup complete!\n"));
+    console.log(chalk17.bold.green("  \u2726 Setup complete!\n"));
     console.log("  What's next:");
-    console.log(`  ${chalk16.cyan("stellavault graph")}     Launch 3D knowledge graph`);
-    console.log(`  ${chalk16.cyan("stellavault decay")}     See what knowledge is fading`);
-    console.log(`  ${chalk16.cyan("stellavault brief")}     Get your daily knowledge briefing`);
-    console.log(`  ${chalk16.cyan("stellavault serve")}     Connect AI agents via MCP`);
+    console.log(`  ${chalk17.cyan("stellavault graph")}     Launch 3D knowledge graph`);
+    console.log(`  ${chalk17.cyan("stellavault decay")}     See what knowledge is fading`);
+    console.log(`  ${chalk17.cyan("stellavault brief")}     Get your daily knowledge briefing`);
+    console.log(`  ${chalk17.cyan("stellavault serve")}     Connect AI agents via MCP`);
     console.log("");
-    console.log(chalk16.cyan("  \u2500\u2500\u2500 Build a habit \u2500\u2500\u2500\n"));
+    const doConnect = await ask(rl, "  Connect Stellavault to your AI clients now? [Y/n]", "Y");
+    if (doConnect.toLowerCase() !== "n") {
+      const { setupCommand: setupCommand2 } = await Promise.resolve().then(() => (init_setup_cmd(), setup_cmd_exports));
+      await setupCommand2({});
+    }
+    console.log(chalk17.cyan("  \u2500\u2500\u2500 Build a habit \u2500\u2500\u2500\n"));
     const setupCron = await ask(rl, "  Auto-run daily briefing? (adds cron job) [Y/n]", "Y");
     if (setupCron.toLowerCase() !== "n") {
       const cronLine = `0 9 * * * cd "${vaultPath}" && stellavault brief >> ~/.stellavault/daily.log 2>&1`;
       const platform = process.platform;
       if (platform === "win32") {
-        console.log(chalk16.dim("\n  Windows: Add this to Task Scheduler:"));
-        console.log(chalk16.dim(`  Action: stellavault brief`));
-        console.log(chalk16.dim(`  Trigger: Daily at 9:00 AM`));
-        console.log(chalk16.dim(`  Start in: ${vaultPath}
+        console.log(chalk17.dim("\n  Windows: Add this to Task Scheduler:"));
+        console.log(chalk17.dim(`  Action: stellavault brief`));
+        console.log(chalk17.dim(`  Trigger: Daily at 9:00 AM`));
+        console.log(chalk17.dim(`  Start in: ${vaultPath}
 `));
       } else {
-        console.log(chalk16.dim("\n  Add this to your crontab (crontab -e):"));
-        console.log(chalk16.dim(`  ${cronLine}
+        console.log(chalk17.dim("\n  Add this to your crontab (crontab -e):"));
+        console.log(chalk17.dim(`  ${cronLine}
 `));
         const autoAdd = await ask(rl, "  Add to crontab now? [Y/n]", "Y");
         if (autoAdd.toLowerCase() !== "n") {
           try {
-            const { execSync: execSync2 } = await import("node:child_process");
-            const existing = execSync2("crontab -l 2>/dev/null || true", { encoding: "utf-8" });
+            const { execSync: execSync3 } = await import("node:child_process");
+            const existing = execSync3("crontab -l 2>/dev/null || true", { encoding: "utf-8" });
             if (!existing.includes("stellavault brief")) {
-              execSync2(`(crontab -l 2>/dev/null; echo "${cronLine}") | crontab -`, { encoding: "utf-8" });
-              console.log(chalk16.green("  \u2713 Daily briefing scheduled at 9:00 AM\n"));
+              execSync3(`(crontab -l 2>/dev/null; echo "${cronLine}") | crontab -`, { encoding: "utf-8" });
+              console.log(chalk17.green("  \u2713 Daily briefing scheduled at 9:00 AM\n"));
             } else {
-              console.log(chalk16.dim("  Already scheduled.\n"));
+              console.log(chalk17.dim("  Already scheduled.\n"));
             }
           } catch {
-            console.log(chalk16.yellow("  Could not auto-add. Please add manually.\n"));
+            console.log(chalk17.yellow("  Could not auto-add. Please add manually.\n"));
           }
         }
       }
     }
-    console.log(chalk16.dim("  Tomorrow morning, run:"));
-    console.log(`  ${chalk16.cyan("stellavault brief")}     See what changed overnight`);
-    console.log(`  ${chalk16.cyan("stellavault decay")}     Review fading knowledge`);
+    console.log(chalk17.dim("  Tomorrow morning, run:"));
+    console.log(`  ${chalk17.cyan("stellavault brief")}     See what changed overnight`);
+    console.log(`  ${chalk17.cyan("stellavault decay")}     Review fading knowledge`);
     console.log("");
-    console.log(chalk16.dim("  Your knowledge is now alive. \u2726"));
+    console.log(chalk17.dim("  Your knowledge is now alive. \u2726"));
     console.log("");
   } finally {
     rl.close();
@@ -8572,7 +9344,7 @@ Andrej Karpathy's approach: every session auto-compiles into structured knowledg
 }
 
 // packages/cli/dist/commands/learn-cmd.js
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 async function learnCommand(_opts, cmd) {
   const globalOpts = cmd?.parent?.opts?.() ?? {};
   const jsonMode = globalOpts.json;
@@ -8582,7 +9354,7 @@ async function learnCommand(_opts, cmd) {
   await hub.embedder.initialize();
   const db = hub.store.getDb();
   if (!db) {
-    console.error(chalk17.red("Cannot access database"));
+    console.error(chalk18.red("Cannot access database"));
     process.exit(1);
   }
   const decayEngine = new DecayEngine(db);
@@ -8600,32 +9372,32 @@ async function learnCommand(_opts, cmd) {
     return;
   }
   console.log("");
-  console.log(chalk17.bold("  \u{1F3AF} Your Learning Path"));
-  console.log(chalk17.dim(`  ${path.summary.reviewCount} to review \xB7 ${path.summary.bridgeCount} gaps to bridge \xB7 ~${path.summary.estimatedMinutes}min`));
+  console.log(chalk18.bold("  \u{1F3AF} Your Learning Path"));
+  console.log(chalk18.dim(`  ${path.summary.reviewCount} to review \xB7 ${path.summary.bridgeCount} gaps to bridge \xB7 ~${path.summary.estimatedMinutes}min`));
   console.log("");
   for (const item of path.items) {
     const icon = item.category === "review" ? "\u{1F4D6}" : item.category === "bridge" ? "\u{1F309}" : "\u{1F52D}";
-    const prioColor = item.priority === "critical" ? chalk17.red : item.priority === "important" ? chalk17.yellow : chalk17.dim;
+    const prioColor = item.priority === "critical" ? chalk18.red : item.priority === "important" ? chalk18.yellow : chalk18.dim;
     const prioLabel = prioColor(item.priority.toUpperCase());
-    console.log(`  ${icon} ${prioLabel} ${chalk17.bold(item.title)} ${chalk17.dim(`(${item.score}pt)`)}`);
-    console.log(`     ${chalk17.dim(item.reason)}`);
+    console.log(`  ${icon} ${prioLabel} ${chalk18.bold(item.title)} ${chalk18.dim(`(${item.score}pt)`)}`);
+    console.log(`     ${chalk18.dim(item.reason)}`);
   }
   if (path.items.length === 0) {
-    console.log(chalk17.green("  All clear! Your knowledge is in great shape."));
+    console.log(chalk18.green("  All clear! Your knowledge is in great shape."));
   }
   console.log("");
-  console.log(chalk17.dim("  \u{1F4A1} stellavault review \u2014 start reviewing decaying notes"));
+  console.log(chalk18.dim("  \u{1F4A1} stellavault review \u2014 start reviewing decaying notes"));
   console.log("");
 }
 
 // packages/cli/dist/commands/contradictions-cmd.js
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 async function contradictionsCommand(_opts, cmd) {
   const globalOpts = cmd?.parent?.opts?.() ?? {};
   const jsonMode = globalOpts.json;
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk18.dim("Scanning for contradictions..."));
+  console.error(chalk19.dim("Scanning for contradictions..."));
   await hub.store.initialize();
   await hub.embedder.initialize();
   const pairs = await detectContradictions(hub.store, 20);
@@ -8635,42 +9407,42 @@ async function contradictionsCommand(_opts, cmd) {
     return;
   }
   console.log("");
-  console.log(chalk18.bold(`  \u26A1 ${pairs.length} potential contradictions found`));
+  console.log(chalk19.bold(`  \u26A1 ${pairs.length} potential contradictions found`));
   console.log("");
   for (const p of pairs) {
-    const confColor = p.confidence >= 0.8 ? chalk18.red : p.confidence >= 0.6 ? chalk18.yellow : chalk18.dim;
-    console.log(`  ${confColor(`${Math.round(p.confidence * 100)}%`)} ${chalk18.dim(`[${p.type}]`)} ${chalk18.bold(p.docA.title)} vs ${chalk18.bold(p.docB.title)}`);
-    console.log(`    A: ${chalk18.dim(p.docA.statement.slice(0, 80))}`);
-    console.log(`    B: ${chalk18.dim(p.docB.statement.slice(0, 80))}`);
+    const confColor = p.confidence >= 0.8 ? chalk19.red : p.confidence >= 0.6 ? chalk19.yellow : chalk19.dim;
+    console.log(`  ${confColor(`${Math.round(p.confidence * 100)}%`)} ${chalk19.dim(`[${p.type}]`)} ${chalk19.bold(p.docA.title)} vs ${chalk19.bold(p.docB.title)}`);
+    console.log(`    A: ${chalk19.dim(p.docA.statement.slice(0, 80))}`);
+    console.log(`    B: ${chalk19.dim(p.docB.statement.slice(0, 80))}`);
     console.log("");
   }
   if (pairs.length === 0) {
-    console.log(chalk18.green("  No contradictions detected. Your knowledge is consistent!"));
+    console.log(chalk19.green("  No contradictions detected. Your knowledge is consistent!"));
     console.log("");
   }
 }
 
 // packages/cli/dist/commands/federate-cmd.js
 import { createInterface as createInterface3 } from "node:readline";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 async function federateJoinCommand(options) {
   if (!isFederationExperimentalEnabled()) {
     console.log("");
-    console.log(chalk19.red("  \u2726 Federation is experimental and disabled by default."));
+    console.log(chalk20.red("  \u2726 Federation is experimental and disabled by default."));
     console.log("");
-    console.log(chalk19.dim("  Enable it by setting an environment variable:"));
-    console.log(chalk19.dim('    PowerShell:  $env:STELLAVAULT_FEDERATION_EXPERIMENTAL = "1"'));
-    console.log(chalk19.dim("    bash/zsh:    export STELLAVAULT_FEDERATION_EXPERIMENTAL=1"));
+    console.log(chalk20.dim("  Enable it by setting an environment variable:"));
+    console.log(chalk20.dim('    PowerShell:  $env:STELLAVAULT_FEDERATION_EXPERIMENTAL = "1"'));
+    console.log(chalk20.dim("    bash/zsh:    export STELLAVAULT_FEDERATION_EXPERIMENTAL=1"));
     console.log("");
-    console.log(chalk19.dim("  Then re-run `stellavault federate join`."));
+    console.log(chalk20.dim("  Then re-run `stellavault federate join`."));
     console.log("");
     process.exit(2);
   }
   const config = loadConfig();
   const identity = getOrCreateIdentity(options.name);
   console.log("");
-  console.log(chalk19.bold("  \u2726 Stellavault Federation") + chalk19.yellow(" (experimental)"));
-  console.log(chalk19.dim(`  Node: ${identity.displayName} (${identity.peerId})`));
+  console.log(chalk20.bold("  \u2726 Stellavault Federation") + chalk20.yellow(" (experimental)"));
+  console.log(chalk20.dim(`  Node: ${identity.displayName} (${identity.peerId})`));
   console.log("");
   const store = createSqliteVecStore(config.dbPath);
   await store.initialize();
@@ -8684,28 +9456,28 @@ async function federateJoinCommand(options) {
   search.startResponder();
   const sharingCfg = loadSharingConfig();
   if (sharingCfg.myNodeLevel === 0) {
-    console.log(chalk19.yellow("  \u26A0 Receive-only mode (my node level = 0)."));
-    console.log(chalk19.dim("    Run `set-level 1` or higher in the federation prompt to share."));
+    console.log(chalk20.yellow("  \u26A0 Receive-only mode (my node level = 0)."));
+    console.log(chalk20.dim("    Run `set-level 1` or higher in the federation prompt to share."));
   } else {
-    console.log(chalk19.dim(`  Sharing level: ${sharingCfg.myNodeLevel} (set-level <0-4> to change)`));
+    console.log(chalk20.dim(`  Sharing level: ${sharingCfg.myNodeLevel} (set-level <0-4> to change)`));
   }
   node.on("joined", (info) => {
-    console.log(chalk19.green(`  \u2726 Joined federation network`));
-    console.log(chalk19.dim(`    Topic: ${info.topic}`));
-    console.log(chalk19.dim(`    Waiting for peers...
+    console.log(chalk20.green(`  \u2726 Joined federation network`));
+    console.log(chalk20.dim(`    Topic: ${info.topic}`));
+    console.log(chalk20.dim(`    Waiting for peers...
 `));
   });
   node.on("peer_joined", (peer) => {
-    console.log(chalk19.cyan(`  \u2192 Peer found: ${peer.displayName} (${peer.documentCount} docs) [${peer.peerId}]`));
+    console.log(chalk20.cyan(`  \u2192 Peer found: ${peer.displayName} (${peer.documentCount} docs) [${peer.peerId}]`));
   });
   node.on("peer_left", (info) => {
-    console.log(chalk19.yellow(`  \u2190 Peer left: ${info.peerId}`));
+    console.log(chalk20.yellow(`  \u2190 Peer left: ${info.peerId}`));
   });
   node.on("search_request", () => {
   });
   await node.join();
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  const prompt = () => rl.question(chalk19.dim("federation> "), handleInput);
+  const prompt = () => rl.question(chalk20.dim("federation> "), handleInput);
   async function handleInput(line) {
     const parts = line.trim().split(/\s+/);
     const cmd = parts[0];
@@ -8713,23 +9485,23 @@ async function federateJoinCommand(options) {
       case "search": {
         const query = parts.slice(1).join(" ");
         if (!query) {
-          console.log(chalk19.yellow("  Usage: search <query>"));
+          console.log(chalk20.yellow("  Usage: search <query>"));
           break;
         }
         const start = Date.now();
-        console.log(chalk19.dim(`  Searching ${node.peerCount} peers...`));
+        console.log(chalk20.dim(`  Searching ${node.peerCount} peers...`));
         const results = await search.search(query, { limit: 5, timeout: 5e3 });
         const elapsed = Date.now() - start;
         if (results.length === 0) {
-          console.log(chalk19.yellow(`  No results from peers. (${elapsed}ms)`));
+          console.log(chalk20.yellow(`  No results from peers. (${elapsed}ms)`));
         } else {
           console.log("");
           for (const r of results) {
-            const simColor = r.similarity >= 0.7 ? chalk19.green : r.similarity >= 0.4 ? chalk19.yellow : chalk19.dim;
-            console.log(`  ${simColor(`${Math.round(r.similarity * 100)}%`)} ${chalk19.bold(r.title)} ${chalk19.dim(`[${r.peerName}]`)}`);
-            console.log(`     ${chalk19.dim(r.snippet)}...`);
+            const simColor = r.similarity >= 0.7 ? chalk20.green : r.similarity >= 0.4 ? chalk20.yellow : chalk20.dim;
+            console.log(`  ${simColor(`${Math.round(r.similarity * 100)}%`)} ${chalk20.bold(r.title)} ${chalk20.dim(`[${r.peerName}]`)}`);
+            console.log(`     ${chalk20.dim(r.snippet)}...`);
           }
-          console.log(chalk19.dim(`
+          console.log(chalk20.dim(`
   ${results.length} results from ${new Set(results.map((r) => r.peerId)).size} peers (${elapsed}ms)`));
         }
         break;
@@ -8737,46 +9509,46 @@ async function federateJoinCommand(options) {
       case "peers": {
         const peers = node.getPeers();
         if (peers.length === 0) {
-          console.log(chalk19.yellow("  No peers connected"));
+          console.log(chalk20.yellow("  No peers connected"));
         } else {
           console.log("");
           for (const p of peers) {
-            console.log(`  ${chalk19.cyan(p.displayName)} ${chalk19.dim(`(${p.documentCount} docs)`)} [${p.peerId}]`);
+            console.log(`  ${chalk20.cyan(p.displayName)} ${chalk20.dim(`(${p.documentCount} docs)`)} [${p.peerId}]`);
             if (p.topTopics.length > 0) {
-              console.log(`    ${chalk19.dim(p.topTopics.map((t2) => `#${t2}`).join(" "))}`);
+              console.log(`    ${chalk20.dim(p.topTopics.map((t2) => `#${t2}`).join(" "))}`);
             }
           }
-          console.log(chalk19.dim(`
+          console.log(chalk20.dim(`
   ${peers.length} peer(s) connected`));
         }
         break;
       }
       case "status": {
         console.log("");
-        console.log(`  ${chalk19.bold("Node:")} ${identity.displayName} (${identity.peerId})`);
-        console.log(`  ${chalk19.bold("Docs:")} ${stats.documentCount}`);
-        console.log(`  ${chalk19.bold("Peers:")} ${node.peerCount}`);
-        console.log(`  ${chalk19.bold("Running:")} ${node.isRunning ? chalk19.green("yes") : chalk19.red("no")}`);
+        console.log(`  ${chalk20.bold("Node:")} ${identity.displayName} (${identity.peerId})`);
+        console.log(`  ${chalk20.bold("Docs:")} ${stats.documentCount}`);
+        console.log(`  ${chalk20.bold("Peers:")} ${node.peerCount}`);
+        console.log(`  ${chalk20.bold("Running:")} ${node.isRunning ? chalk20.green("yes") : chalk20.red("no")}`);
         break;
       }
       case "connect": {
         const addr = parts[1];
         if (!addr || !addr.includes(":")) {
-          console.log(chalk19.yellow("  Usage: connect <host:port>"));
+          console.log(chalk20.yellow("  Usage: connect <host:port>"));
           break;
         }
         const [host, portStr] = addr.split(":");
         try {
-          console.log(chalk19.dim(`  Connecting to ${addr}...`));
+          console.log(chalk20.dim(`  Connecting to ${addr}...`));
           await node.joinDirect(host, parseInt(portStr, 10));
-          console.log(chalk19.green(`  Connected to ${addr}`));
+          console.log(chalk20.green(`  Connected to ${addr}`));
         } catch (err) {
-          console.log(chalk19.red(`  Failed: ${err instanceof Error ? err.message : err}`));
+          console.log(chalk20.red(`  Failed: ${err instanceof Error ? err.message : err}`));
         }
         break;
       }
       case "sharing": {
-        console.log("\n" + chalk19.bold("  Sharing Settings"));
+        console.log("\n" + chalk20.bold("  Sharing Settings"));
         console.log("  " + getSharingSummary().split("\n").join("\n  "));
         console.log("");
         break;
@@ -8785,38 +9557,38 @@ async function federateJoinCommand(options) {
         const tag = parts[1];
         const lvl = parseInt(parts[2], 10);
         if (!tag || isNaN(lvl) || lvl < 0 || lvl > 4) {
-          console.log(chalk19.yellow("  Usage: set-tag <tag> <0-4>"));
+          console.log(chalk20.yellow("  Usage: set-tag <tag> <0-4>"));
           break;
         }
         setTagLevel(tag, lvl);
-        console.log(chalk19.green(`  #${tag} \u2192 Level ${lvl}`));
+        console.log(chalk20.green(`  #${tag} \u2192 Level ${lvl}`));
         break;
       }
       case "set-folder": {
         const folder = parts[1];
         const lvl = parseInt(parts[2], 10);
         if (!folder || isNaN(lvl) || lvl < 0 || lvl > 4) {
-          console.log(chalk19.yellow("  Usage: set-folder <folder> <0-4>"));
+          console.log(chalk20.yellow("  Usage: set-folder <folder> <0-4>"));
           break;
         }
         setFolderLevel(folder, lvl);
-        console.log(chalk19.green(`  ${folder} \u2192 Level ${lvl}`));
+        console.log(chalk20.green(`  ${folder} \u2192 Level ${lvl}`));
         break;
       }
       case "set-level": {
         const lvl = parseInt(parts[1], 10);
         if (isNaN(lvl) || lvl < 0 || lvl > 4) {
-          console.log(chalk19.yellow("  Usage: set-level <0-4> (your node sharing level)"));
+          console.log(chalk20.yellow("  Usage: set-level <0-4> (your node sharing level)"));
           break;
         }
         setNodeLevel(lvl);
-        console.log(chalk19.green(`  My node level \u2192 ${lvl}`));
+        console.log(chalk20.green(`  My node level \u2192 ${lvl}`));
         break;
       }
       case "requests": {
         const pending = getPendingRequests();
         if (pending.length === 0) {
-          console.log(chalk19.dim("  No pending requests"));
+          console.log(chalk20.dim("  No pending requests"));
           break;
         }
         console.log(`
@@ -8829,33 +9601,33 @@ async function federateJoinCommand(options) {
       case "approve": {
         const reqId = parts[1];
         if (!reqId) {
-          console.log(chalk19.yellow("  Usage: approve <request-id>"));
+          console.log(chalk20.yellow("  Usage: approve <request-id>"));
           break;
         }
         const match = getPendingRequests().find((r) => r.requestId.startsWith(reqId));
         if (match && approveRequest(match.requestId))
-          console.log(chalk19.green(`  Approved: ${match.documentTitle}`));
+          console.log(chalk20.green(`  Approved: ${match.documentTitle}`));
         else
-          console.log(chalk19.red("  Request not found"));
+          console.log(chalk20.red("  Request not found"));
         break;
       }
       case "deny": {
         const reqId = parts[1];
         if (!reqId) {
-          console.log(chalk19.yellow("  Usage: deny <request-id>"));
+          console.log(chalk20.yellow("  Usage: deny <request-id>"));
           break;
         }
         const match = getPendingRequests().find((r) => r.requestId.startsWith(reqId));
         if (match && denyRequest(match.requestId))
-          console.log(chalk19.green(`  Denied: ${match.documentTitle}`));
+          console.log(chalk20.green(`  Denied: ${match.documentTitle}`));
         else
-          console.log(chalk19.red("  Request not found"));
+          console.log(chalk20.red("  Request not found"));
         break;
       }
       case "leave":
       case "quit":
       case "exit": {
-        console.log(chalk19.dim("  Leaving federation..."));
+        console.log(chalk20.dim("  Leaving federation..."));
         await node.leave();
         await store.close();
         rl.close();
@@ -8865,30 +9637,30 @@ async function federateJoinCommand(options) {
       case "help": {
         console.log("");
         console.log("  Commands:");
-        console.log(`    ${chalk19.cyan("search <query>")}    Search across all connected peers`);
-        console.log(`    ${chalk19.cyan("peers")}             List connected peers`);
-        console.log(`    ${chalk19.cyan("status")}            Show node info`);
-        console.log(`    ${chalk19.cyan("connect <ip:port>")} Connect to peer directly`);
-        console.log(`    ${chalk19.cyan("sharing")}              Show sharing settings`);
-        console.log(`    ${chalk19.cyan("set-tag <t> <0-4>")}   Set tag sharing level`);
-        console.log(`    ${chalk19.cyan("set-folder <f> <0-4>")} Set folder sharing level`);
-        console.log(`    ${chalk19.cyan("set-level <0-4>")}     Set your node level`);
-        console.log(`    ${chalk19.cyan("requests")}            Show pending full-text requests`);
-        console.log(`    ${chalk19.cyan("approve <id>")}        Approve a request`);
-        console.log(`    ${chalk19.cyan("deny <id>")}           Deny a request`);
-        console.log(`    ${chalk19.cyan("leave")}             Disconnect and exit`);
+        console.log(`    ${chalk20.cyan("search <query>")}    Search across all connected peers`);
+        console.log(`    ${chalk20.cyan("peers")}             List connected peers`);
+        console.log(`    ${chalk20.cyan("status")}            Show node info`);
+        console.log(`    ${chalk20.cyan("connect <ip:port>")} Connect to peer directly`);
+        console.log(`    ${chalk20.cyan("sharing")}              Show sharing settings`);
+        console.log(`    ${chalk20.cyan("set-tag <t> <0-4>")}   Set tag sharing level`);
+        console.log(`    ${chalk20.cyan("set-folder <f> <0-4>")} Set folder sharing level`);
+        console.log(`    ${chalk20.cyan("set-level <0-4>")}     Set your node level`);
+        console.log(`    ${chalk20.cyan("requests")}            Show pending full-text requests`);
+        console.log(`    ${chalk20.cyan("approve <id>")}        Approve a request`);
+        console.log(`    ${chalk20.cyan("deny <id>")}           Deny a request`);
+        console.log(`    ${chalk20.cyan("leave")}             Disconnect and exit`);
         break;
       }
       default: {
         if (cmd)
-          console.log(chalk19.dim(`  Unknown command: ${cmd}. Type 'help' for commands.`));
+          console.log(chalk20.dim(`  Unknown command: ${cmd}. Type 'help' for commands.`));
         break;
       }
     }
     prompt();
   }
   process.on("SIGINT", async () => {
-    console.log(chalk19.dim("\n  Leaving federation..."));
+    console.log(chalk20.dim("\n  Leaving federation..."));
     await node.leave();
     await store.close();
     process.exit(0);
@@ -8899,7 +9671,7 @@ async function federateStatusCommand() {
   const identity = getOrCreateIdentity();
   const config = loadConfig();
   console.log("");
-  console.log(chalk19.bold("  \u2726 Federation Identity"));
+  console.log(chalk20.bold("  \u2726 Federation Identity"));
   console.log(`  PeerID: ${identity.peerId}`);
   console.log(`  Name:   ${identity.displayName}`);
   console.log(`  Since:  ${identity.createdAt}`);
@@ -8908,7 +9680,7 @@ async function federateStatusCommand() {
 }
 
 // packages/cli/dist/commands/cloud-cmd.js
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 function getCloudConfig() {
   const endpoint = process.env.SV_CLOUD_ENDPOINT;
   const bucket = process.env.SV_CLOUD_BUCKET ?? "stellavault";
@@ -8922,22 +9694,22 @@ function getCloudConfig() {
 async function cloudSyncCommand() {
   const cloudConfig = getCloudConfig();
   if (!cloudConfig) {
-    console.log(chalk20.red("\n  Cloud not configured. Set environment variables:"));
-    console.log(chalk20.dim("    SV_CLOUD_ENDPOINT=https://xxx.r2.cloudflarestorage.com"));
-    console.log(chalk20.dim("    SV_CLOUD_SECRET_KEY=your_api_token"));
-    console.log(chalk20.dim("    SV_CLOUD_ENCRYPTION_KEY=your_passphrase (optional)\n"));
+    console.log(chalk21.red("\n  Cloud not configured. Set environment variables:"));
+    console.log(chalk21.dim("    SV_CLOUD_ENDPOINT=https://xxx.r2.cloudflarestorage.com"));
+    console.log(chalk21.dim("    SV_CLOUD_SECRET_KEY=your_api_token"));
+    console.log(chalk21.dim("    SV_CLOUD_ENCRYPTION_KEY=your_passphrase (optional)\n"));
     return;
   }
   const config = loadConfig();
-  console.log(chalk20.dim("\n  Encrypting and uploading..."));
+  console.log(chalk21.dim("\n  Encrypting and uploading..."));
   const result = await syncToCloud(config.dbPath, cloudConfig);
   if (result.success) {
-    console.log(chalk20.green("\n  \u2705 Cloud sync complete"));
+    console.log(chalk21.green("\n  \u2705 Cloud sync complete"));
     console.log(`    DB: ${(result.dbSize / 1024).toFixed(0)}KB \u2192 Encrypted: ${(result.encryptedSize / 1024).toFixed(0)}KB`);
-    console.log(chalk20.dim(`    ${result.timestamp}
+    console.log(chalk21.dim(`    ${result.timestamp}
 `));
   } else {
-    console.log(chalk20.red(`
+    console.log(chalk21.red(`
   \u274C Sync failed: ${result.error}
 `));
   }
@@ -8945,18 +9717,18 @@ async function cloudSyncCommand() {
 async function cloudRestoreCommand() {
   const cloudConfig = getCloudConfig();
   if (!cloudConfig) {
-    console.log(chalk20.red("\n  Cloud not configured. See: sv cloud sync --help\n"));
+    console.log(chalk21.red("\n  Cloud not configured. See: sv cloud sync --help\n"));
     return;
   }
   const config = loadConfig();
-  console.log(chalk20.dim("\n  Downloading and decrypting..."));
+  console.log(chalk21.dim("\n  Downloading and decrypting..."));
   const result = await restoreFromCloud(config.dbPath, cloudConfig);
   if (result.success) {
-    console.log(chalk20.green("\n  \u2705 Restore complete"));
+    console.log(chalk21.green("\n  \u2705 Restore complete"));
     console.log(`    Encrypted: ${(result.encryptedSize / 1024).toFixed(0)}KB \u2192 DB: ${(result.dbSize / 1024).toFixed(0)}KB`);
-    console.log(chalk20.dim("    Previous DB backed up as .backup\n"));
+    console.log(chalk21.dim("    Previous DB backed up as .backup\n"));
   } else {
-    console.log(chalk20.red(`
+    console.log(chalk21.red(`
   \u274C Restore failed: ${result.error}
 `));
   }
@@ -8964,29 +9736,29 @@ async function cloudRestoreCommand() {
 async function cloudStatusCommand() {
   const state = getSyncState();
   if (!state) {
-    console.log(chalk20.yellow("\n  No cloud sync history. Run: sv cloud sync\n"));
+    console.log(chalk21.yellow("\n  No cloud sync history. Run: sv cloud sync\n"));
     return;
   }
-  console.log(chalk20.bold("\n  \u2601\uFE0F  Cloud Sync Status"));
+  console.log(chalk21.bold("\n  \u2601\uFE0F  Cloud Sync Status"));
   console.log(`    Last sync: ${state.lastSync}`);
   console.log(`    DB size:   ${(state.dbSize / 1024).toFixed(0)}KB
 `);
 }
 
 // packages/cli/dist/commands/vault-cmd.js
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 async function vaultAddCommand(id, vaultPath, options) {
   const config = loadConfig();
   const dbPath = vaultPath.replace(/\/$/, "") + "/.stellavault/index.db";
   try {
     const entry = addVault(id, options.name ?? id, vaultPath, dbPath, !!options.shared);
-    console.log(chalk21.green(`
+    console.log(chalk22.green(`
   \u2705 Vault "${entry.name}" added (${entry.id})`));
-    console.log(chalk21.dim(`    Path: ${entry.path}
+    console.log(chalk22.dim(`    Path: ${entry.path}
     DB: ${entry.dbPath}
 `));
   } catch (err) {
-    console.log(chalk21.red(`
+    console.log(chalk22.red(`
   \u274C ${err instanceof Error ? err.message : err}
 `));
   }
@@ -8994,22 +9766,22 @@ async function vaultAddCommand(id, vaultPath, options) {
 async function vaultListCommand() {
   const vaults = listVaults();
   if (vaults.length === 0) {
-    console.log(chalk21.yellow("\n  No vaults registered. Use: sv vault add <id> <path>\n"));
+    console.log(chalk22.yellow("\n  No vaults registered. Use: sv vault add <id> <path>\n"));
     return;
   }
-  console.log(chalk21.bold("\n  Registered Vaults"));
+  console.log(chalk22.bold("\n  Registered Vaults"));
   for (const v of vaults) {
-    console.log(`  ${chalk21.cyan(v.id)} ${v.name} ${chalk21.dim(`(${v.path})`)}`);
+    console.log(`  ${chalk22.cyan(v.id)} ${v.name} ${chalk22.dim(`(${v.path})`)}`);
   }
   console.log("");
 }
 async function vaultRemoveCommand(id) {
   if (removeVault(id)) {
-    console.log(chalk21.green(`
+    console.log(chalk22.green(`
   \u2705 Vault "${id}" removed
 `));
   } else {
-    console.log(chalk21.red(`
+    console.log(chalk22.red(`
   \u274C Vault "${id}" not found
 `));
   }
@@ -9018,33 +9790,33 @@ async function vaultSearchAllCommand(query, options) {
   const config = loadConfig();
   const embedder = createLocalEmbedder(config.embedding.localModel);
   await embedder.initialize();
-  console.log(chalk21.dim(`
+  console.log(chalk22.dim(`
   Searching all vaults for "${query}"...`));
   const results = await searchAllVaults(query, embedder, (dbPath) => createSqliteVecStore(dbPath), { limit: parseInt(options.limit ?? "10", 10) });
   if (results.length === 0) {
-    console.log(chalk21.yellow("  No results across vaults.\n"));
+    console.log(chalk22.yellow("  No results across vaults.\n"));
     return;
   }
   for (const r of results) {
     const pct = Math.round(r.score * 100);
-    const color = pct >= 70 ? chalk21.green : pct >= 40 ? chalk21.yellow : chalk21.dim;
-    console.log(`  ${color(`${pct}%`)} ${chalk21.bold(r.title)} ${chalk21.dim(`[${r.vaultName}]`)}`);
-    console.log(`     ${chalk21.dim(r.snippet)}...`);
+    const color = pct >= 70 ? chalk22.green : pct >= 40 ? chalk22.yellow : chalk22.dim;
+    console.log(`  ${color(`${pct}%`)} ${chalk22.bold(r.title)} ${chalk22.dim(`[${r.vaultName}]`)}`);
+    console.log(`     ${chalk22.dim(r.snippet)}...`);
   }
   console.log("");
 }
 
 // packages/cli/dist/commands/capture-cmd.js
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 async function captureCommand(audioFile, options) {
   if (!isWhisperAvailable()) {
-    console.log(chalk22.red("\n  Whisper not installed."));
-    console.log(chalk22.dim("  Install: pip install openai-whisper"));
-    console.log(chalk22.dim("  Or: brew install whisper-cpp\n"));
+    console.log(chalk23.red("\n  Whisper not installed."));
+    console.log(chalk23.dim("  Install: pip install openai-whisper"));
+    console.log(chalk23.dim("  Or: brew install whisper-cpp\n"));
     return;
   }
   const config = loadConfig();
-  console.log(chalk22.dim(`
+  console.log(chalk23.dim(`
   Transcribing ${audioFile}...`));
   const result = await captureVoice(audioFile, {
     vaultPath: config.vaultPath,
@@ -9054,31 +9826,31 @@ async function captureCommand(audioFile, options) {
     folder: options.folder
   });
   if (result.success) {
-    console.log(chalk22.green(`
+    console.log(chalk23.green(`
   \u2705 Captured: "${result.title}"`));
     console.log(`    Tags: ${result.tags.join(", ")}`);
     console.log(`    File: ${result.filePath}`);
-    console.log(chalk22.dim(`    Transcript: ${result.transcript.slice(0, 100)}...`));
-    console.log(chalk22.dim("\n  \u{1F4A1} Run stellavault index to add to the graph\n"));
+    console.log(chalk23.dim(`    Transcript: ${result.transcript.slice(0, 100)}...`));
+    console.log(chalk23.dim("\n  \u{1F4A1} Run stellavault index to add to the graph\n"));
   } else {
-    console.log(chalk22.red(`
+    console.log(chalk23.red(`
   \u274C Capture failed: ${result.error}
 `));
   }
 }
 
 // packages/cli/dist/commands/ask-cmd.js
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 async function askCommand(question, options) {
   if (!question || question.trim().length < 2) {
-    console.error(chalk23.yellow('Usage: stellavault ask "your question here" [--save]'));
-    console.error(chalk23.dim("\nSearch Mode: finds relevant notes from your vault."));
-    console.error(chalk23.dim("For AI-powered answers, use MCP: claude mcp add stellavault -- stellavault serve"));
+    console.error(chalk24.yellow('Usage: stellavault ask "your question here" [--save]'));
+    console.error(chalk24.dim("\nSearch Mode: finds relevant notes from your vault."));
+    console.error(chalk24.dim("For AI-powered answers, use MCP: claude mcp add stellavault -- stellavault serve"));
     process.exit(1);
   }
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk23.dim("Searching your knowledge (local search mode)..."));
+  console.error(chalk24.dim("Searching your knowledge (local search mode)..."));
   await hub.store.initialize();
   await hub.embedder.initialize();
   const result = await askVault(hub.searchEngine, question, {
@@ -9091,39 +9863,39 @@ async function askCommand(question, options) {
   console.log(result.answer);
   if (result.savedTo) {
     console.log("");
-    console.log(chalk23.green(`Saved to: ${result.savedTo}`));
+    console.log(chalk24.green(`Saved to: ${result.savedTo}`));
   }
   if (result.sources.length > 0 && !options.save) {
     console.log("");
-    console.log(chalk23.dim("Tip: Add --save to file this answer into your vault."));
-    console.log(chalk23.dim("For AI-generated answers: use Claude Code with MCP integration."));
+    console.log(chalk24.dim("Tip: Add --save to file this answer into your vault."));
+    console.log(chalk24.dim("For AI-generated answers: use Claude Code with MCP integration."));
   }
   await hub.store.close?.();
 }
 
 // packages/cli/dist/commands/compile-cmd.js
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import { resolve as resolve15 } from "node:path";
 async function compileCommand(options) {
   const config = loadConfig();
   const vaultPath = config.vaultPath;
   const rawPath = resolve15(vaultPath, options.raw ?? "raw");
   const wikiPath = resolve15(vaultPath, options.wiki ?? "_wiki");
-  console.error(chalk24.dim(`Raw: ${rawPath}`));
-  console.error(chalk24.dim(`Wiki: ${wikiPath}`));
+  console.error(chalk25.dim(`Raw: ${rawPath}`));
+  console.error(chalk25.dim(`Wiki: ${wikiPath}`));
   console.error("");
   const result = compileWiki(rawPath, wikiPath, { force: options.force });
   if (result.rawDocCount === 0) {
-    console.error(chalk24.yellow(`No documents found in ${rawPath}`));
-    console.error(chalk24.dim("Create a raw/ folder in your vault and add .md/.txt files."));
+    console.error(chalk25.yellow(`No documents found in ${rawPath}`));
+    console.error(chalk25.dim("Create a raw/ folder in your vault and add .md/.txt files."));
     return;
   }
-  console.log(chalk24.green(`Compiled ${result.rawDocCount} raw docs \u2192 ${result.wikiArticles.length} wiki articles`));
-  console.log(chalk24.dim(`Concepts: ${result.concepts.length}`));
-  console.log(chalk24.dim(`Index: ${result.indexFile}`));
+  console.log(chalk25.green(`Compiled ${result.rawDocCount} raw docs \u2192 ${result.wikiArticles.length} wiki articles`));
+  console.log(chalk25.dim(`Concepts: ${result.concepts.length}`));
+  console.log(chalk25.dim(`Index: ${result.indexFile}`));
   if (result.concepts.length > 0) {
     console.log("");
-    console.log(chalk24.cyan("Top concepts:"));
+    console.log(chalk25.cyan("Top concepts:"));
     for (const c of result.concepts.slice(0, 10)) {
       console.log(`  ${c}`);
     }
@@ -9131,13 +9903,13 @@ async function compileCommand(options) {
 }
 
 // packages/cli/dist/commands/draft-cmd.js
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 
 // packages/core/dist/intelligence/draft-generator.js
 init_wiki_compiler();
 init_config();
-import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync19, existsSync as existsSync19 } from "node:fs";
-import { join as join24, resolve as resolve16, basename as basename5, extname as extname7 } from "node:path";
+import { writeFileSync as writeFileSync20, mkdirSync as mkdirSync20, existsSync as existsSync21 } from "node:fs";
+import { join as join26, resolve as resolve16, basename as basename5, extname as extname7 } from "node:path";
 function generateDraft(vaultPath, options = {}, folders = DEFAULT_FOLDERS) {
   const { topic, format = "blog", maxSections = 8, blueprint } = options;
   const rawDir = resolve16(vaultPath, folders.fleeting);
@@ -9145,7 +9917,7 @@ function generateDraft(vaultPath, options = {}, folders = DEFAULT_FOLDERS) {
   const litDir = resolve16(vaultPath, folders.literature);
   const allDocs = [];
   for (const dir of [rawDir, wikiDir, litDir]) {
-    if (existsSync19(dir)) {
+    if (existsSync21(dir)) {
       allDocs.push(...scanRawDirectory(dir));
     }
   }
@@ -9213,14 +9985,14 @@ function generateDraft(vaultPath, options = {}, folders = DEFAULT_FOLDERS) {
   }
   const wordCount = body.split(/\s+/).filter(Boolean).length;
   const draftsDir = resolve16(vaultPath, "_drafts");
-  if (!existsSync19(draftsDir))
-    mkdirSync19(draftsDir, { recursive: true });
+  if (!existsSync21(draftsDir))
+    mkdirSync20(draftsDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const slug = (topic ?? "knowledge").replace(/[^a-zA-Z0-9가-힣\s]/g, "").replace(/\s+/g, "-").toLowerCase().slice(0, 40);
   const filename = `${timestamp}-${slug}.md`;
-  const filePath = join24("_drafts", filename);
+  const filePath = join26("_drafts", filename);
   const fullPath = resolve16(vaultPath, filePath);
-  writeFileSync19(fullPath, body, "utf-8");
+  writeFileSync20(fullPath, body, "utf-8");
   return {
     title: draftTitle,
     filePath,
@@ -9377,7 +10149,7 @@ function capitalize(s) {
 async function draftCommand(topic, options) {
   const config = loadConfig();
   if (!config.vaultPath) {
-    console.error(chalk25.red("No vault configured. Run `stellavault init` first."));
+    console.error(chalk26.red("No vault configured. Run `stellavault init` first."));
     process.exit(1);
   }
   const format = options.format ?? "blog";
@@ -9391,40 +10163,40 @@ async function draftCommand(topic, options) {
     }
     const result = generateDraft(config.vaultPath, { topic, format, blueprint }, config.folders);
     if (options.ai) {
-      console.log(chalk25.dim("  AI mode: generating with Claude..."));
+      console.log(chalk26.dim("  AI mode: generating with Claude..."));
       await enhanceWithAI(config.vaultPath, result.filePath, topic ?? "knowledge", format);
     }
-    console.log(chalk25.green(`Draft generated: ${result.title}`));
-    console.log(chalk25.dim(`  Format: ${format}`));
-    console.log(chalk25.dim(`  Mode: ${options.ai ? "AI-enhanced (Claude)" : "rule-based"}`));
-    console.log(chalk25.dim(`  Saved: ${result.filePath}`));
-    console.log(chalk25.dim(`  Words: ${result.wordCount}`));
-    console.log(chalk25.dim(`  Sources: ${result.sourceCount} documents`));
+    console.log(chalk26.green(`Draft generated: ${result.title}`));
+    console.log(chalk26.dim(`  Format: ${format}`));
+    console.log(chalk26.dim(`  Mode: ${options.ai ? "AI-enhanced (Claude)" : "rule-based"}`));
+    console.log(chalk26.dim(`  Saved: ${result.filePath}`));
+    console.log(chalk26.dim(`  Words: ${result.wordCount}`));
+    console.log(chalk26.dim(`  Sources: ${result.sourceCount} documents`));
     if (result.concepts.length > 0) {
-      console.log(chalk25.dim(`  Concepts: ${result.concepts.join(", ")}`));
+      console.log(chalk26.dim(`  Concepts: ${result.concepts.join(", ")}`));
     }
     console.log("");
-    console.log(chalk25.dim(`Next steps:`));
-    console.log(chalk25.dim(`  Edit in Obsidian, then promote:`));
-    console.log(chalk25.cyan(`  stellavault promote ${result.filePath} --to literature`));
+    console.log(chalk26.dim(`Next steps:`));
+    console.log(chalk26.dim(`  Edit in Obsidian, then promote:`));
+    console.log(chalk26.cyan(`  stellavault promote ${result.filePath} --to literature`));
     if (!options.ai) {
-      console.log(chalk25.dim(`  Or use --ai for Claude-enhanced draft, or MCP generate-draft in Claude Code.`));
+      console.log(chalk26.dim(`  Or use --ai for Claude-enhanced draft, or MCP generate-draft in Claude Code.`));
     }
   } catch (err) {
-    console.error(chalk25.red(err instanceof Error ? err.message : "Draft generation failed"));
+    console.error(chalk26.red(err instanceof Error ? err.message : "Draft generation failed"));
     process.exit(1);
   }
 }
 async function enhanceWithAI(vaultPath, draftPath, topic, format) {
-  const { readFileSync: readFileSync18, writeFileSync: writeFileSync22 } = await import("node:fs");
+  const { readFileSync: readFileSync19, writeFileSync: writeFileSync23 } = await import("node:fs");
   const { resolve: resolve22 } = await import("node:path");
   const fullPath = resolve22(vaultPath, draftPath);
-  const scaffold = readFileSync18(fullPath, "utf-8");
+  const scaffold = readFileSync19(fullPath, "utf-8");
   const excerpts = scaffold.split("\n").filter((l) => l.startsWith("> ")).map((l) => l.slice(2)).join("\n");
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
-    console.error(chalk25.yellow("  ANTHROPIC_API_KEY not set. Falling back to rule-based draft."));
-    console.error(chalk25.yellow("  Set it with: export ANTHROPIC_API_KEY=sk-ant-..."));
+    console.error(chalk26.yellow("  ANTHROPIC_API_KEY not set. Falling back to rule-based draft."));
+    console.error(chalk26.yellow("  Set it with: export ANTHROPIC_API_KEY=sk-ant-..."));
     return;
   }
   try {
@@ -9461,31 +10233,31 @@ ${aiContent.text}
 ---
 *Generated by \`stellavault draft --ai\` using Claude API at ${(/* @__PURE__ */ new Date()).toISOString()}*
 `;
-      writeFileSync22(fullPath, enhanced, "utf-8");
+      writeFileSync23(fullPath, enhanced, "utf-8");
     }
   } catch (err) {
-    console.error(chalk25.yellow(`  AI enhancement failed: ${err instanceof Error ? err.message : "unknown"}. Keeping rule-based draft.`));
+    console.error(chalk26.yellow(`  AI enhancement failed: ${err instanceof Error ? err.message : "unknown"}. Keeping rule-based draft.`));
   }
 }
 
 // packages/cli/dist/commands/session-cmd.js
-import chalk26 from "chalk";
-import { writeFileSync as writeFileSync20, mkdirSync as mkdirSync20, existsSync as existsSync20, appendFileSync } from "node:fs";
-import { resolve as resolve17, join as join25 } from "node:path";
+import chalk27 from "chalk";
+import { writeFileSync as writeFileSync21, mkdirSync as mkdirSync21, existsSync as existsSync22, appendFileSync } from "node:fs";
+import { resolve as resolve17, join as join27 } from "node:path";
 async function sessionSaveCommand(options) {
   const config = loadConfig();
   if (!config.vaultPath) {
-    console.error(chalk26.red("No vault configured. Run `stellavault init` first."));
+    console.error(chalk27.red("No vault configured. Run `stellavault init` first."));
     process.exit(1);
   }
   const folders = config.folders;
   const logDir = resolve17(config.vaultPath, folders.fleeting, "_daily-logs");
-  if (!existsSync20(logDir))
-    mkdirSync20(logDir, { recursive: true });
+  if (!existsSync22(logDir))
+    mkdirSync21(logDir, { recursive: true });
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
   const timeStr = now.toTimeString().split(" ")[0];
-  const logFile = join25(logDir, `daily-log-${dateStr}.md`);
+  const logFile = join27(logDir, `daily-log-${dateStr}.md`);
   let summary = options.summary ?? "";
   if (!summary && !process.stdin.isTTY) {
     const chunks = [];
@@ -9495,7 +10267,7 @@ async function sessionSaveCommand(options) {
     summary = Buffer.concat(chunks).toString("utf-8").trim();
   }
   if (!summary) {
-    console.log(chalk26.dim("Enter session summary (Ctrl+D to finish):"));
+    console.log(chalk27.dim("Enter session summary (Ctrl+D to finish):"));
     const chunks = [];
     for await (const chunk of process.stdin) {
       chunks.push(chunk);
@@ -9503,7 +10275,7 @@ async function sessionSaveCommand(options) {
     summary = Buffer.concat(chunks).toString("utf-8").trim();
   }
   if (!summary) {
-    console.error(chalk26.yellow("No summary provided. Skipping."));
+    console.error(chalk27.yellow("No summary provided. Skipping."));
     return;
   }
   const entry = [
@@ -9524,7 +10296,7 @@ async function sessionSaveCommand(options) {
     entry.push("### Action Items", options.actions, "");
   }
   entry.push("---", "");
-  if (!existsSync20(logFile)) {
+  if (!existsSync22(logFile)) {
     const header = [
       "---",
       `title: "Daily Log \u2014 ${dateStr}"`,
@@ -9536,80 +10308,80 @@ async function sessionSaveCommand(options) {
       `# Daily Log \u2014 ${dateStr}`,
       ""
     ].join("\n");
-    writeFileSync20(logFile, header + entry.join("\n"), "utf-8");
+    writeFileSync21(logFile, header + entry.join("\n"), "utf-8");
   } else {
     appendFileSync(logFile, entry.join("\n"), "utf-8");
   }
-  console.log(chalk26.green(`Session saved to daily log: ${dateStr}`));
-  console.log(chalk26.dim(`  File: ${logFile}`));
-  console.log(chalk26.dim(`  Time: ${timeStr}`));
-  console.log(chalk26.dim(`  Words: ${summary.split(/\s+/).length}`));
+  console.log(chalk27.green(`Session saved to daily log: ${dateStr}`));
+  console.log(chalk27.dim(`  File: ${logFile}`));
+  console.log(chalk27.dim(`  Time: ${timeStr}`));
+  console.log(chalk27.dim(`  Words: ${summary.split(/\s+/).length}`));
   try {
     const { compileWiki: compileWiki2 } = await Promise.resolve().then(() => (init_wiki_compiler(), wiki_compiler_exports));
     const rawDir = resolve17(config.vaultPath, folders.fleeting);
     const wikiDir = resolve17(config.vaultPath, folders.wiki);
     compileWiki2(rawDir, wikiDir);
-    console.log(chalk26.dim("  Wiki: auto-compiled"));
+    console.log(chalk27.dim("  Wiki: auto-compiled"));
   } catch {
   }
 }
 
 // packages/cli/dist/commands/flush-cmd.js
-import chalk27 from "chalk";
-import { readdirSync as readdirSync7, readFileSync as readFileSync16, existsSync as existsSync21 } from "node:fs";
-import { resolve as resolve18, join as join26 } from "node:path";
+import chalk28 from "chalk";
+import { readdirSync as readdirSync7, readFileSync as readFileSync17, existsSync as existsSync23 } from "node:fs";
+import { resolve as resolve18, join as join28 } from "node:path";
 async function flushCommand() {
   const config = loadConfig();
   if (!config.vaultPath) {
-    console.error(chalk27.red("No vault configured. Run `stellavault init` first."));
+    console.error(chalk28.red("No vault configured. Run `stellavault init` first."));
     process.exit(1);
   }
   const folders = config.folders;
   const logDir = resolve18(config.vaultPath, folders.fleeting, "_daily-logs");
-  if (!existsSync21(logDir)) {
-    console.log(chalk27.yellow("No daily logs found. Use `stellavault session-save` or let Claude Code hooks capture sessions."));
+  if (!existsSync23(logDir)) {
+    console.log(chalk28.yellow("No daily logs found. Use `stellavault session-save` or let Claude Code hooks capture sessions."));
     return;
   }
   const logFiles = readdirSync7(logDir).filter((f) => f.startsWith("daily-log-") && f.endsWith(".md"));
   if (logFiles.length === 0) {
-    console.log(chalk27.yellow("No daily log files found."));
+    console.log(chalk28.yellow("No daily log files found."));
     return;
   }
-  console.log(chalk27.dim(`Found ${logFiles.length} daily logs`));
+  console.log(chalk28.dim(`Found ${logFiles.length} daily logs`));
   let totalSessions = 0;
   const allContent = [];
   for (const file of logFiles) {
-    const content = readFileSync16(join26(logDir, file), "utf-8");
+    const content = readFileSync17(join28(logDir, file), "utf-8");
     const sessions = content.split(/^## Session/m).slice(1);
     totalSessions += sessions.length;
     allContent.push(content);
   }
-  console.log(chalk27.dim(`Total sessions: ${totalSessions}`));
+  console.log(chalk28.dim(`Total sessions: ${totalSessions}`));
   try {
     const { compileWiki: compileWiki2 } = await Promise.resolve().then(() => (init_wiki_compiler(), wiki_compiler_exports));
     const rawDir = resolve18(config.vaultPath, folders.fleeting);
     const wikiDir = resolve18(config.vaultPath, folders.wiki);
     const result = compileWiki2(rawDir, wikiDir);
-    console.log(chalk27.green(`Flush complete!`));
-    console.log(chalk27.dim(`  Daily logs: ${logFiles.length} files, ${totalSessions} sessions`));
-    console.log(chalk27.dim(`  Wiki articles: ${result.wikiArticles.length}`));
-    console.log(chalk27.dim(`  Concepts extracted: ${result.concepts.length}`));
+    console.log(chalk28.green(`Flush complete!`));
+    console.log(chalk28.dim(`  Daily logs: ${logFiles.length} files, ${totalSessions} sessions`));
+    console.log(chalk28.dim(`  Wiki articles: ${result.wikiArticles.length}`));
+    console.log(chalk28.dim(`  Concepts extracted: ${result.concepts.length}`));
     if (result.concepts.length > 0) {
-      console.log(chalk27.dim(`  Top concepts: ${result.concepts.slice(0, 8).join(", ")}`));
+      console.log(chalk28.dim(`  Top concepts: ${result.concepts.slice(0, 8).join(", ")}`));
     }
-    console.log(chalk27.dim(`  Index: ${result.indexFile}`));
+    console.log(chalk28.dim(`  Index: ${result.indexFile}`));
   } catch (err) {
-    console.error(chalk27.red(`Flush failed: ${err instanceof Error ? err.message : "unknown"}`));
+    console.error(chalk28.red(`Flush failed: ${err instanceof Error ? err.message : "unknown"}`));
     process.exit(1);
   }
-  console.log(chalk27.dim("  Tip: Run `stellavault lint` to check knowledge health"));
+  console.log(chalk28.dim("  Tip: Run `stellavault lint` to check knowledge health"));
 }
 
 // packages/cli/dist/commands/adr-cmd.js
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 async function adrCommand(title, options) {
   if (!title) {
-    console.error(chalk28.yellow('Usage: stellavault adr "Decision Title" --context "..." --options "..." --decision "..." --consequences "..."'));
+    console.error(chalk29.yellow('Usage: stellavault adr "Decision Title" --context "..." --options "..." --decision "..." --consequences "..."'));
     process.exit(1);
   }
   const config = loadConfig();
@@ -9640,25 +10412,25 @@ async function adrCommand(title, options) {
     title: `ADR: ${title}`,
     stage: "literature"
   }, config.folders);
-  console.log(chalk28.green(`ADR created: ${title}`));
-  console.log(chalk28.dim(`  Saved: ${result.savedTo}`));
-  console.log(chalk28.dim(`  Stage: literature`));
-  console.log(chalk28.dim(`  Tags: adr, decision`));
+  console.log(chalk29.green(`ADR created: ${title}`));
+  console.log(chalk29.dim(`  Saved: ${result.savedTo}`));
+  console.log(chalk29.dim(`  Stage: literature`));
+  console.log(chalk29.dim(`  Tags: adr, decision`));
   console.log("");
-  console.log(chalk28.dim(`Find later: stellavault ask "why did we choose ${title}?"`));
+  console.log(chalk29.dim(`Find later: stellavault ask "why did we choose ${title}?"`));
 }
 
 // packages/cli/dist/commands/lint-cmd.js
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 async function lintCommand() {
   const config = loadConfig();
   const hub = createKnowledgeHub(config);
-  console.error(chalk29.dim("Scanning your knowledge base..."));
+  console.error(chalk30.dim("Scanning your knowledge base..."));
   await hub.store.initialize();
   const result = await lintKnowledge(hub.store);
-  const scoreColor = result.score >= 80 ? chalk29.green : result.score >= 50 ? chalk29.yellow : chalk29.red;
+  const scoreColor = result.score >= 80 ? chalk30.green : result.score >= 50 ? chalk30.yellow : chalk30.red;
   console.log("");
-  console.log(chalk29.bold("Knowledge Health Report"));
+  console.log(chalk30.bold("Knowledge Health Report"));
   console.log("\u2500".repeat(40));
   console.log(`Score: ${scoreColor(result.score + "/100")}`);
   console.log(`Documents: ${result.stats.totalDocs}`);
@@ -9668,35 +10440,35 @@ async function lintCommand() {
     const warnings = result.issues.filter((i) => i.severity === "warning");
     const info = result.issues.filter((i) => i.severity === "info");
     if (critical.length > 0) {
-      console.log(chalk29.red(`Critical: ${critical.length}`));
+      console.log(chalk30.red(`Critical: ${critical.length}`));
       for (const i of critical) {
-        console.log(chalk29.red(`  \u2717 ${i.message}`));
+        console.log(chalk30.red(`  \u2717 ${i.message}`));
         if (i.suggestion)
-          console.log(chalk29.dim(`    \u2192 ${i.suggestion}`));
+          console.log(chalk30.dim(`    \u2192 ${i.suggestion}`));
       }
       console.log("");
     }
     if (warnings.length > 0) {
-      console.log(chalk29.yellow(`Warnings: ${warnings.length}`));
+      console.log(chalk30.yellow(`Warnings: ${warnings.length}`));
       for (const i of warnings.slice(0, 10)) {
-        console.log(chalk29.yellow(`  ! ${i.message}`));
+        console.log(chalk30.yellow(`  ! ${i.message}`));
         if (i.suggestion)
-          console.log(chalk29.dim(`    \u2192 ${i.suggestion}`));
+          console.log(chalk30.dim(`    \u2192 ${i.suggestion}`));
       }
       if (warnings.length > 10)
-        console.log(chalk29.dim(`  ... and ${warnings.length - 10} more`));
+        console.log(chalk30.dim(`  ... and ${warnings.length - 10} more`));
       console.log("");
     }
     if (info.length > 0) {
-      console.log(chalk29.dim(`Info: ${info.length}`));
+      console.log(chalk30.dim(`Info: ${info.length}`));
       for (const i of info.slice(0, 5)) {
-        console.log(chalk29.dim(`  \u2139 ${i.message}`));
+        console.log(chalk30.dim(`  \u2139 ${i.message}`));
       }
       console.log("");
     }
   }
   if (result.suggestions.length > 0) {
-    console.log(chalk29.cyan("Suggestions:"));
+    console.log(chalk30.cyan("Suggestions:"));
     for (const s of result.suggestions) {
       console.log(`  \u2192 ${s}`);
     }
@@ -9706,25 +10478,25 @@ async function lintCommand() {
 }
 
 // packages/cli/dist/commands/fleeting-cmd.js
-import chalk30 from "chalk";
-import { writeFileSync as writeFileSync21, mkdirSync as mkdirSync21, existsSync as existsSync22 } from "node:fs";
-import { join as join27, resolve as resolve19 } from "node:path";
+import chalk31 from "chalk";
+import { writeFileSync as writeFileSync22, mkdirSync as mkdirSync22, existsSync as existsSync24 } from "node:fs";
+import { join as join29, resolve as resolve19 } from "node:path";
 async function fleetingCommand(text, options) {
   if (!text || text.trim().length < 2) {
-    console.error(chalk30.yellow('Usage: stellavault fleeting "your idea here" [--tags tag1,tag2]'));
+    console.error(chalk31.yellow('Usage: stellavault fleeting "your idea here" [--tags tag1,tag2]'));
     process.exit(1);
   }
   const config = loadConfig();
   const rawDir = resolve19(config.vaultPath, "raw");
-  if (!existsSync22(rawDir))
-    mkdirSync21(rawDir, { recursive: true });
+  if (!existsSync24(rawDir))
+    mkdirSync22(rawDir, { recursive: true });
   const now = /* @__PURE__ */ new Date();
   const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const slug = text.slice(0, 40).replace(/[^a-zA-Z0-9가-힣\s]/g, "").replace(/\s+/g, "-").toLowerCase();
   const filename = `${timestamp}-${slug}.md`;
-  const filePath = join27(rawDir, filename);
+  const filePath = join29(rawDir, filename);
   if (!resolve19(filePath).startsWith(resolve19(rawDir))) {
-    console.error(chalk30.red("Invalid file path"));
+    console.error(chalk31.red("Invalid file path"));
     process.exit(1);
   }
   const tags = options.tags ? options.tags.split(",").map((t2) => t2.trim()) : [];
@@ -9741,28 +10513,28 @@ async function fleetingCommand(text, options) {
     "---",
     `*Captured via \`stellavault fleeting\` at ${now.toLocaleString("ko-KR")}*`
   ].join("\n");
-  writeFileSync21(filePath, content, "utf-8");
-  console.log(chalk30.green(`Captured: ${filename}`));
-  console.log(chalk30.dim(`Location: raw/${filename}`));
-  console.log(chalk30.dim("Run `stellavault compile` to process into wiki."));
+  writeFileSync22(filePath, content, "utf-8");
+  console.log(chalk31.green(`Captured: ${filename}`));
+  console.log(chalk31.dim(`Location: raw/${filename}`));
+  console.log(chalk31.dim("Run `stellavault compile` to process into wiki."));
 }
 
 // packages/cli/dist/commands/ingest-cmd.js
-import chalk31 from "chalk";
-import { readFileSync as readFileSync17, existsSync as existsSync23, readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
-import { extname as extname8, resolve as resolve20, join as join28 } from "node:path";
+import chalk32 from "chalk";
+import { readFileSync as readFileSync18, existsSync as existsSync25, readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
+import { extname as extname8, resolve as resolve20, join as join30 } from "node:path";
 async function ingestCommand(input, options) {
   if (!input) {
-    console.error(chalk31.yellow("Usage: stellavault ingest <url|file|text|folder/> [--tags t1,t2]"));
+    console.error(chalk32.yellow("Usage: stellavault ingest <url|file|text|folder/> [--tags t1,t2]"));
     process.exit(1);
   }
-  if (existsSync23(input) && statSync5(input).isDirectory()) {
-    const files = readdirSync8(input).filter((f) => /\.(md|txt|pdf|docx|pptx|xlsx|xls|csv|json|xml|html|htm|yaml|yml|rtf)$/i.test(f)).map((f) => join28(input, f));
+  if (existsSync25(input) && statSync5(input).isDirectory()) {
+    const files = readdirSync8(input).filter((f) => /\.(md|txt|pdf|docx|pptx|xlsx|xls|csv|json|xml|html|htm|yaml|yml|rtf)$/i.test(f)).map((f) => join30(input, f));
     if (files.length === 0) {
-      console.error(chalk31.yellow(`No supported files found in ${input}`));
+      console.error(chalk32.yellow(`No supported files found in ${input}`));
       process.exit(1);
     }
-    console.log(chalk31.dim(`Batch ingest: ${files.length} files from ${input}
+    console.log(chalk32.dim(`Batch ingest: ${files.length} files from ${input}
 `));
     let success = 0;
     const failed = [];
@@ -9770,7 +10542,7 @@ async function ingestCommand(input, options) {
       const file = files[i];
       const name = file.split(/[/\\]/).pop() ?? file;
       const progress = `[${i + 1}/${files.length}]`;
-      process.stderr.write(`\r${chalk31.dim(progress)} ${name}...`);
+      process.stderr.write(`\r${chalk32.dim(progress)} ${name}...`);
       try {
         await ingestSingleFile(file, options);
         success++;
@@ -9779,12 +10551,12 @@ async function ingestCommand(input, options) {
       }
     }
     process.stderr.write("\r" + " ".repeat(80) + "\r");
-    console.log(chalk31.green(`Batch complete: ${success}/${files.length} files ingested`));
+    console.log(chalk32.green(`Batch complete: ${success}/${files.length} files ingested`));
     if (failed.length > 0) {
-      console.log(chalk31.yellow(`
+      console.log(chalk32.yellow(`
 Failed (${failed.length}):`));
       for (const f of failed)
-        console.log(chalk31.yellow(`  - ${f}`));
+        console.log(chalk32.yellow(`  - ${f}`));
     }
     return;
   }
@@ -9805,7 +10577,7 @@ async function ingestSingleFile(input, options) {
       const url = new URL(input);
       const host = url.hostname;
       if (/^(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|0\.|localhost|::1)/i.test(host)) {
-        console.error(chalk31.yellow("Private/local URLs are not allowed for security."));
+        console.error(chalk32.yellow("Private/local URLs are not allowed for security."));
         process.exit(1);
       }
     } catch {
@@ -9825,7 +10597,7 @@ async function ingestSingleFile(input, options) {
           source: input
         };
       } catch (err) {
-        console.error(chalk31.yellow(`YouTube extraction failed, falling back to basic URL. (${err instanceof Error ? err.message : "error"})`));
+        console.error(chalk32.yellow(`YouTube extraction failed, falling back to basic URL. (${err instanceof Error ? err.message : "error"})`));
         ingestInput = {
           type: "youtube",
           content: input + "\n",
@@ -9843,7 +10615,7 @@ async function ingestSingleFile(input, options) {
         const text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim().slice(0, 5e3);
         content += text;
       } catch (err) {
-        console.error(chalk31.yellow(`Web fetch failed: saving URL only. (${err instanceof Error ? err.message : "network error"})`));
+        console.error(chalk32.yellow(`Web fetch failed: saving URL only. (${err instanceof Error ? err.message : "network error"})`));
       }
       ingestInput = {
         type: "url",
@@ -9854,7 +10626,7 @@ async function ingestSingleFile(input, options) {
         source: input
       };
     }
-  } else if (existsSync23(input)) {
+  } else if (existsSync25(input)) {
     const ext = extname8(input).toLowerCase();
     const binaryExts = /* @__PURE__ */ new Set([".pdf", ".docx", ".pptx", ".xlsx", ".xls"]);
     const structuredExts = /* @__PURE__ */ new Set([".json", ".csv", ".xml", ".html", ".htm", ".yaml", ".yml", ".rtf"]);
@@ -9862,7 +10634,7 @@ async function ingestSingleFile(input, options) {
       try {
         const { extractFileContent: extractFileContent2 } = await Promise.resolve().then(() => (init_file_extractors(), file_extractors_exports));
         const extracted = await extractFileContent2(resolve20(input));
-        console.log(chalk31.dim(`  Extracted ${extracted.metadata.wordCount} words from ${ext} file`));
+        console.log(chalk32.dim(`  Extracted ${extracted.metadata.wordCount} words from ${ext} file`));
         ingestInput = {
           type: extracted.sourceFormat,
           content: extracted.text,
@@ -9873,10 +10645,10 @@ async function ingestSingleFile(input, options) {
           source: input
         };
       } catch (err) {
-        console.error(chalk31.yellow(`Binary file extraction failed, saving as-is. (${err instanceof Error ? err.message : "error"})`));
+        console.error(chalk32.yellow(`Binary file extraction failed, saving as-is. (${err instanceof Error ? err.message : "error"})`));
         ingestInput = {
           type: "file",
-          content: readFileSync17(input, "utf-8"),
+          content: readFileSync18(input, "utf-8"),
           tags,
           stage,
           title: options.title,
@@ -9887,7 +10659,7 @@ async function ingestSingleFile(input, options) {
       try {
         const { extractFileContent: extractFileContent2 } = await Promise.resolve().then(() => (init_file_extractors(), file_extractors_exports));
         const extracted = await extractFileContent2(resolve20(input));
-        console.log(chalk31.dim(`  Extracted ${extracted.metadata.wordCount} words from ${ext} file`));
+        console.log(chalk32.dim(`  Extracted ${extracted.metadata.wordCount} words from ${ext} file`));
         ingestInput = {
           type: "file",
           content: extracted.text,
@@ -9897,11 +10669,11 @@ async function ingestSingleFile(input, options) {
           source: input
         };
       } catch (err) {
-        const fileContent = readFileSync17(input, "utf-8");
+        const fileContent = readFileSync18(input, "utf-8");
         ingestInput = { type: "file", content: fileContent, tags, stage, title: options.title, source: input };
       }
     } else {
-      const fileContent = readFileSync17(input, "utf-8");
+      const fileContent = readFileSync18(input, "utf-8");
       ingestInput = {
         type: "file",
         content: fileContent,
@@ -9921,103 +10693,103 @@ async function ingestSingleFile(input, options) {
     };
   }
   const result = ingest(config.vaultPath, ingestInput);
-  console.log(chalk31.green(`Ingested: ${result.title}`));
-  console.log(chalk31.dim(`  Stage: ${result.stage}`));
-  console.log(chalk31.dim(`  Saved: ${result.savedTo}`));
-  console.log(chalk31.dim(`  Words: ${result.wordCount}`));
+  console.log(chalk32.green(`Ingested: ${result.title}`));
+  console.log(chalk32.dim(`  Stage: ${result.stage}`));
+  console.log(chalk32.dim(`  Saved: ${result.savedTo}`));
+  console.log(chalk32.dim(`  Words: ${result.wordCount}`));
   if (result.indexCode)
-    console.log(chalk31.dim(`  Index: ${result.indexCode}`));
+    console.log(chalk32.dim(`  Index: ${result.indexCode}`));
   if (result.tags.length > 0)
-    console.log(chalk31.dim(`  Tags: ${result.tags.join(", ")}`));
-  console.log(chalk31.dim("  Wiki: auto-compiled"));
+    console.log(chalk32.dim(`  Tags: ${result.tags.join(", ")}`));
+  console.log(chalk32.dim("  Wiki: auto-compiled"));
   console.log("");
 }
 async function promoteCommand(filePath, options) {
   const config = loadConfig();
   const target = options.to;
   if (!["fleeting", "literature", "permanent"].includes(target)) {
-    console.error(chalk31.red("--to must be: fleeting, literature, or permanent"));
+    console.error(chalk32.red("--to must be: fleeting, literature, or permanent"));
     process.exit(1);
   }
   const newPath = promoteNote(config.vaultPath, filePath, target);
-  console.log(chalk31.green(`Promoted to ${target}: ${newPath}`));
+  console.log(chalk32.green(`Promoted to ${target}: ${newPath}`));
 }
 
 // packages/cli/dist/commands/autopilot-cmd.js
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 import { resolve as resolve21 } from "node:path";
 async function autopilotCommand(options) {
   const config = loadConfig();
   const vaultPath = config.vaultPath;
-  console.log(chalk32.bold("\n  \u2726 Stellavault Autopilot"));
-  console.log(chalk32.dim("  Knowledge flywheel: inbox \u2192 compile \u2192 lint \u2192 repeat\n"));
-  console.log(chalk32.cyan("Step 1/4: Checking inbox..."));
+  console.log(chalk33.bold("\n  \u2726 Stellavault Autopilot"));
+  console.log(chalk33.dim("  Knowledge flywheel: inbox \u2192 compile \u2192 lint \u2192 repeat\n"));
+  console.log(chalk33.cyan("Step 1/4: Checking inbox..."));
   const inbox = getInboxItems(vaultPath);
   if (inbox.length === 0) {
-    console.log(chalk32.dim("  No new items in raw/ folder."));
+    console.log(chalk33.dim("  No new items in raw/ folder."));
   } else {
-    console.log(chalk32.green(`  ${inbox.length} new items found.`));
+    console.log(chalk33.green(`  ${inbox.length} new items found.`));
     for (const item of inbox.slice(0, 5)) {
-      console.log(chalk32.dim(`    - ${item.title} (${item.wordCount} words)`));
+      console.log(chalk33.dim(`    - ${item.title} (${item.wordCount} words)`));
     }
     if (inbox.length > 5)
-      console.log(chalk32.dim(`    ... and ${inbox.length - 5} more`));
+      console.log(chalk33.dim(`    ... and ${inbox.length - 5} more`));
   }
-  console.log(chalk32.cyan("\nStep 2/4: Compiling wiki..."));
+  console.log(chalk33.cyan("\nStep 2/4: Compiling wiki..."));
   const rawPath = resolve21(vaultPath, "raw");
   const wikiPath = resolve21(vaultPath, "_wiki");
   const compileResult = compileWiki(rawPath, wikiPath);
   if (compileResult.rawDocCount > 0) {
-    console.log(chalk32.green(`  Compiled ${compileResult.rawDocCount} raw \u2192 ${compileResult.wikiArticles.length} wiki articles`));
-    console.log(chalk32.dim(`  Concepts: ${compileResult.concepts.length}`));
+    console.log(chalk33.green(`  Compiled ${compileResult.rawDocCount} raw \u2192 ${compileResult.wikiArticles.length} wiki articles`));
+    console.log(chalk33.dim(`  Concepts: ${compileResult.concepts.length}`));
     for (const item of inbox) {
       try {
         archiveFile(resolve21(vaultPath, "raw", item.filePath));
       } catch {
       }
     }
-    console.log(chalk32.dim(`  Archived ${inbox.length} processed items.`));
+    console.log(chalk33.dim(`  Archived ${inbox.length} processed items.`));
   } else {
-    console.log(chalk32.dim("  No raw documents to compile."));
+    console.log(chalk33.dim("  No raw documents to compile."));
   }
-  console.log(chalk32.cyan("\nStep 3/4: Running health check..."));
+  console.log(chalk33.cyan("\nStep 3/4: Running health check..."));
   const hub = createKnowledgeHub(config);
   await hub.store.initialize();
   const lintResult = await lintKnowledge(hub.store);
-  const scoreColor = lintResult.score >= 80 ? chalk32.green : lintResult.score >= 50 ? chalk32.yellow : chalk32.red;
+  const scoreColor = lintResult.score >= 80 ? chalk33.green : lintResult.score >= 50 ? chalk33.yellow : chalk33.red;
   console.log(`  Health: ${scoreColor(lintResult.score + "/100")}`);
   const critical = lintResult.issues.filter((i) => i.severity === "critical").length;
   const warnings = lintResult.issues.filter((i) => i.severity === "warning").length;
   if (critical > 0)
-    console.log(chalk32.red(`  Critical: ${critical}`));
+    console.log(chalk33.red(`  Critical: ${critical}`));
   if (warnings > 0)
-    console.log(chalk32.yellow(`  Warnings: ${warnings}`));
-  console.log(chalk32.cyan("\nStep 4/4: Summary"));
-  console.log(chalk32.dim("\u2500".repeat(40)));
+    console.log(chalk33.yellow(`  Warnings: ${warnings}`));
+  console.log(chalk33.cyan("\nStep 4/4: Summary"));
+  console.log(chalk33.dim("\u2500".repeat(40)));
   console.log(`  Inbox processed: ${inbox.length}`);
   console.log(`  Wiki articles: ${compileResult.wikiArticles.length}`);
   console.log(`  Health score: ${lintResult.score}/100`);
   console.log(`  Issues: ${lintResult.issues.length}`);
   if (lintResult.suggestions.length > 0) {
-    console.log(chalk32.cyan("\n  Suggestions:"));
+    console.log(chalk33.cyan("\n  Suggestions:"));
     for (const s of lintResult.suggestions.slice(0, 3)) {
-      console.log(chalk32.dim(`    \u2192 ${s}`));
+      console.log(chalk33.dim(`    \u2192 ${s}`));
     }
   }
-  console.log(chalk32.dim("\n\u2500".repeat(40)));
-  console.log(chalk32.dim("\n  Next: run `stellavault index` to update search vectors."));
-  console.log(chalk32.green("  Autopilot complete.\n"));
+  console.log(chalk33.dim("\n\u2500".repeat(40)));
+  console.log(chalk33.dim("\n  Next: run `stellavault index` to update search vectors."));
+  console.log(chalk33.green("  Autopilot complete.\n"));
   await hub.store.close?.();
 }
 
 // packages/cli/dist/commands/doctor-cmd.js
-import chalk33 from "chalk";
-import { existsSync as existsSync24, statSync as statSync6 } from "node:fs";
-import { join as join29 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import chalk34 from "chalk";
+import { existsSync as existsSync26, statSync as statSync6 } from "node:fs";
+import { join as join31 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 async function doctorCommand() {
   console.log("");
-  console.log(chalk33.bold("  \u{1FA7A} Stellavault Doctor\n"));
+  console.log(chalk34.bold("  \u{1FA7A} Stellavault Doctor\n"));
   const checks = [];
   const nodeVersion2 = parseInt(process.versions.node.split(".")[0], 10);
   checks.push({
@@ -10027,10 +10799,10 @@ async function doctorCommand() {
     fix: nodeVersion2 < 20 ? "Download Node.js 20+: https://nodejs.org" : void 0
   });
   const configPaths = [
-    join29(process.cwd(), ".stellavault.json"),
-    join29(homedir15(), ".stellavault.json")
+    join31(process.cwd(), ".stellavault.json"),
+    join31(homedir17(), ".stellavault.json")
   ];
-  const configPath = configPaths.find((p) => existsSync24(p));
+  const configPath = configPaths.find((p) => existsSync26(p));
   checks.push({
     name: "Config file",
     pass: !!configPath,
@@ -10041,8 +10813,8 @@ async function doctorCommand() {
   let dbPath = "";
   if (configPath) {
     try {
-      const { readFileSync: readFileSync18 } = await import("node:fs");
-      const config = JSON.parse(readFileSync18(configPath, "utf-8"));
+      const { readFileSync: readFileSync19 } = await import("node:fs");
+      const config = JSON.parse(readFileSync19(configPath, "utf-8"));
       vaultPath = config.vaultPath || "";
       dbPath = config.dbPath || "";
     } catch (err) {
@@ -10055,7 +10827,7 @@ async function doctorCommand() {
     }
   }
   if (vaultPath) {
-    const vaultExists = existsSync24(vaultPath);
+    const vaultExists = existsSync26(vaultPath);
     checks.push({
       name: "Vault path",
       pass: vaultExists,
@@ -10084,7 +10856,7 @@ async function doctorCommand() {
     }
   }
   if (dbPath) {
-    const dbExists = existsSync24(dbPath);
+    const dbExists = existsSync26(dbPath);
     checks.push({
       name: "Database",
       pass: dbExists,
@@ -10099,20 +10871,20 @@ async function doctorCommand() {
       fix: "Re-run: stellavault init"
     });
   }
-  const cacheDir = join29(homedir15(), ".cache", "onnxruntime");
-  const hfCache = join29(homedir15(), ".cache", "huggingface");
-  const xenovaCache = join29(homedir15(), ".cache", "xenova");
-  const modelCached = existsSync24(cacheDir) || existsSync24(hfCache) || existsSync24(xenovaCache) || existsSync24(join29(homedir15(), ".cache", "transformers"));
+  const cacheDir = join31(homedir17(), ".cache", "onnxruntime");
+  const hfCache = join31(homedir17(), ".cache", "huggingface");
+  const xenovaCache = join31(homedir17(), ".cache", "xenova");
+  const modelCached = existsSync26(cacheDir) || existsSync26(hfCache) || existsSync26(xenovaCache) || existsSync26(join31(homedir17(), ".cache", "transformers"));
   checks.push({
     name: "Embedding model cached",
     pass: modelCached,
     detail: modelCached ? "local model files found" : "not downloaded yet",
     fix: !modelCached ? "Will download automatically on first index (~30MB)" : void 0
   });
-  const testDir = join29(homedir15(), ".stellavault");
+  const testDir = join31(homedir17(), ".stellavault");
   try {
-    const { mkdirSync: mkdirSync22 } = await import("node:fs");
-    mkdirSync22(testDir, { recursive: true });
+    const { mkdirSync: mkdirSync23 } = await import("node:fs");
+    mkdirSync23(testDir, { recursive: true });
     checks.push({ name: "Write permission (~/.stellavault)", pass: true, detail: "OK" });
   } catch {
     checks.push({
@@ -10124,20 +10896,20 @@ async function doctorCommand() {
   }
   let passCount = 0;
   for (const c of checks) {
-    const icon = c.pass ? chalk33.green("\u2713") : chalk33.red("\u2717");
-    console.log(`  ${icon} ${c.name}  ${chalk33.dim("\u2014")}  ${c.pass ? chalk33.dim(c.detail) : chalk33.yellow(c.detail)}`);
+    const icon = c.pass ? chalk34.green("\u2713") : chalk34.red("\u2717");
+    console.log(`  ${icon} ${c.name}  ${chalk34.dim("\u2014")}  ${c.pass ? chalk34.dim(c.detail) : chalk34.yellow(c.detail)}`);
     if (c.fix)
-      console.log(`    ${chalk33.dim("Fix:")} ${c.fix}`);
+      console.log(`    ${chalk34.dim("Fix:")} ${c.fix}`);
     if (c.pass)
       passCount++;
   }
   console.log("");
   if (passCount === checks.length) {
-    console.log(chalk33.green.bold(`  All ${checks.length} checks passed. You're good to go! \u2726
+    console.log(chalk34.green.bold(`  All ${checks.length} checks passed. You're good to go! \u2726
 `));
   } else {
     const failCount = checks.length - passCount;
-    console.log(chalk33.yellow(`  ${failCount} issue${failCount > 1 ? "s" : ""} found. Fix them and re-run: stellavault doctor
+    console.log(chalk34.yellow(`  ${failCount} issue${failCount > 1 ? "s" : ""} found. Fix them and re-run: stellavault doctor
 `));
   }
   process.exit(passCount === checks.length ? 0 : 1);
@@ -10162,7 +10934,7 @@ if (nodeVersion < 20) {
   process.exit(1);
 }
 var program = new Command();
-var SV_VERSION = true ? "0.7.4" : "0.0.0-dev";
+var SV_VERSION = true ? "0.8.2" : "0.0.0-dev";
 program.name("stellavault").description("Stellavault \u2014 Self-compiling knowledge base for your Obsidian vault").version(SV_VERSION).option("--json", "Output in JSON format (for scripting)").option("--quiet", "Suppress non-essential output");
 program.command("init").description("Interactive setup wizard \u2014 get started in 3 minutes").action(initCommand);
 program.command("doctor").description("Diagnose setup issues (config, vault, DB, model, Node version)").action(doctorCommand);
@@ -10174,6 +10946,7 @@ program.command("ingest <input>").description("Ingest any input (URL, file, text
 program.command("clip <url>").description("Clip a web page or YouTube video into your vault").option("-f, --folder <path>", "Vault subfolder for clips", "06_Research/clips").action(clipCommand);
 program.command("graph").description("Launch the 3D knowledge graph in your browser").action(graphCommand);
 program.command("serve").alias("mcp").description("Start MCP server (for Claude Code / Claude Desktop). Alias: mcp").action(serveCommand);
+program.command("setup").description("Connect Stellavault to your AI clients (Claude Code/Desktop, Cursor, Windsurf, VS Code) in one command").option("-c, --client <id>", "Target a specific client (repeatable): claude-code, claude-desktop, cursor, windsurf, vscode", (val, prev) => [...prev, val], []).option("--all", "Write configs to all supported clients, even if not detected").option("--command <cmd>", "Override the server command (advanced/dev)").option("--args <args>", "Override server args (space-separated; default: serve)").action((opts) => setupCommand(opts));
 program.command("decay").description("Memory decay report \u2014 find notes you are forgetting").action(decayCommand);
 program.command("brief").description("Daily knowledge briefing (decay + gaps + activity)").action(briefCommand);
 program.command("digest").description("Weekly knowledge activity report").option("-d, --days <n>", "Period in days", "7").option("-v, --visual", "Save as .md with Mermaid charts for Obsidian").action(digestCommand);