@owrede/vault-memory 2.1.0 → 2.2.1

package/dist/cli.js

@@ -89,7 +89,7 @@ function extractResourceLength(handle) {
   if (firstSlash === -1) return 0;
   return afterScheme.length - (firstSlash + 1);
 }
-var ServerConfigSchema, VaultConfigSchema, BriefOllamaConfigSchema, BriefConfigSchema, ContractsMcpClientConfigSchema, ContractsConfigSchema, DEFAULT_CONTRACTS_CONFIG, PluginConfigSchema, DEFAULT_PLUGIN_CONFIG, MemorySinkConfigSchema, MemoryConfigSchema, AppConfigSchema, DEFAULT_CONFIG;
+var ServerConfigSchema, ContextFitConfigSchema, VaultConfigSchema, BriefOllamaConfigSchema, BriefConfigSchema, ContractsMcpClientConfigSchema, ContractsConfigSchema, DEFAULT_CONTRACTS_CONFIG, PluginConfigSchema, DEFAULT_PLUGIN_CONFIG, MemorySinkConfigSchema, MemoryConfigSchema, AppConfigSchema, DEFAULT_CONFIG;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
@@ -102,9 +102,17 @@ var init_loader = __esm({
       reranker_backend: z.enum(["onnx", "ollama"]).optional(),
       reranker_model_dir: z.string().optional()
     });
+    ContextFitConfigSchema = z.object({
+      command: z.string().min(1).optional(),
+      tokenizer: z.string().min(1).optional(),
+      method: z.enum(["exact", "bm25", "sid", "graph", "hierarchy", "hybrid"]).optional()
+    });
     VaultConfigSchema = z.object({
       name: z.string().min(1),
       path: z.string().min(1),
+      // ADR-008: retrieval engine. Omitted ⇒ "ollama" (back-compat default).
+      backend: z.enum(["ollama", "contextfit"]).optional(),
+      contextfit: ContextFitConfigSchema.optional(),
       embedding_model: z.string().optional(),
       secondary_embedding_model: z.string().optional(),
       write_enabled: z.boolean().optional(),
@@ -228,7 +236,8 @@ async function addVault(opts) {
       name: proposedName,
       path: resolvedPath,
       writeEnabled: opts.writeEnabled ?? false,
-      excludeGlobs: opts.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS
+      excludeGlobs: opts.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS,
+      ...opts.backend ? { backend: opts.backend } : {}
     });
     await ensureFileExists(cfgFile);
     await appendToFile(cfgFile, block);
@@ -252,13 +261,21 @@ function renderVaultBlock(input) {
     `# Added by vault-memory add-vault on ${(/* @__PURE__ */ new Date()).toISOString()}`,
     "[[vaults]]",
     `name = ${JSON.stringify(input.name)}`,
-    `path = ${JSON.stringify(input.path)}`,
+    `path = ${JSON.stringify(input.path)}`
+  ];
+  if (input.backend === "contextfit") {
+    lines.push(
+      `# ADR-008: CPU-only, token-native engine (no Ollama/embeddings/GPU).`,
+      `backend = "contextfit"`
+    );
+  }
+  lines.push(
     `write_enabled = ${input.writeEnabled}`,
     `exclude_globs = [`,
     ...input.excludeGlobs.map((g) => `  ${JSON.stringify(g)},`),
     `]`,
     ""
-  ];
+  );
   return lines.join("\n");
 }
 async function ensureFileExists(path7) {
@@ -1303,7 +1320,7 @@ function backfillSectionsFromChunks(db) {
        @parent_id, @ord, @chunk_id_first, @chunk_id_last, @created_at)
   `);
   const lookupExistingSection = db.prepare(
-    "SELECT id FROM sections WHERE note_id = ? AND anchor = ?"
+    "SELECT id FROM sections WHERE note_id = ? AND heading_path = ? AND anchor = ?"
   );
   let backfilled = 0;
   const now = Date.now();
@@ -1339,7 +1356,11 @@ function backfillSectionsFromChunks(db) {
       if (info.changes > 0) {
         insertedIds.push(Number(info.lastInsertRowid));
       } else {
-        const existing2 = lookupExistingSection.get(note.id, s.anchor);
+        const existing2 = lookupExistingSection.get(
+          note.id,
+          JSON.stringify(s.heading_path),
+          s.anchor
+        );
         insertedIds.push(existing2 ? Number(existing2.id) : null);
       }
     }
@@ -1671,6 +1692,11 @@ function runMigration014(db, _ctx) {
       ON contract_audit(verb);
   `);
 }
+function runMigration015(db, _ctx) {
+  db.exec(
+    "DROP INDEX IF EXISTS sections_note_anchor; CREATE UNIQUE INDEX IF NOT EXISTS sections_note_headingpath_anchor ON sections(note_id, heading_path, anchor);"
+  );
+}
 var INITIAL_SCHEMA, MIGRATION_002_ALIASES, MIGRATION_003_FIX_DELETE_FKS, MIGRATION_004_VARIABLE_DIMS, MIGRATION_006_BODY_HASH, MIGRATION_007_DOC_URI_ADD, MIGRATIONS;
 var init_schema = __esm({
   "src/db/schema.ts"() {
@@ -1946,6 +1972,11 @@ CREATE INDEX IF NOT EXISTS idx_notes_doc_uri ON notes(doc_uri);
         version: 14,
         description: "contract_audit table \u2014 Phase 6 / CON-* / Q-AUD",
         run: runMigration014
+      },
+      {
+        version: 15,
+        description: "section identity = (note_id, heading_path, anchor) \u2014 context-aware, no longer collapse byte-identical siblings in different contexts (ADR-032 revised)",
+        run: runMigration015
       }
     ];
   }
@@ -3050,6 +3081,9 @@ var init_sections = __esm({
         this._getByAnchor = db.prepare(
           "SELECT * FROM sections WHERE note_id = ? AND anchor = ?"
         );
+        this._getByIdentity = db.prepare(
+          "SELECT * FROM sections WHERE note_id = ? AND heading_path = ? AND anchor = ?"
+        );
         this._findContainingChunk = db.prepare(
           // `chunk_id` is monotonically increasing per note; chunk_id_first
           // and chunk_id_last carve disjoint ranges (or both NULL for a
@@ -3073,6 +3107,7 @@ var init_sections = __esm({
       _deleteByNote;
       _getByNote;
       _getByAnchor;
+      _getByIdentity;
       _findContainingChunk;
       _countByNote;
       /**
@@ -3105,14 +3140,15 @@ var init_sections = __esm({
         return ids;
       }
       /**
-       * Insert one section, collision-safe. Returns the id of the row that
-       * now owns (note_id, anchor): the freshly inserted row, or — when a
-       * same-anchor sibling already won the unique slot — that surviving
-       * row's id (so callers can resolve parent_id linkage). Mirrors the
-       * backfill behavior in src/sections/backfill.ts. The live indexer
-       * uses this instead of `insertMany` so duplicate-anchor sibling
-       * headings can't abort the whole index run
-       * (see ISSUE-indexer-duplicate-anchor.md).
+       * Insert one section, collision-safe. Returns the id of the row that now
+       * owns the identity (note_id, heading_path, anchor): the freshly inserted
+       * row, or — when a same-context byte-identical sibling already won the
+       * unique slot — that surviving row's id (so callers can resolve parent_id
+       * linkage). Per ADR-032 (revised), a collision now requires BOTH same anchor
+       * AND same heading_path, so differently-placed identical sections persist as
+       * distinct rows. Mirrors src/sections/backfill.ts. The live indexer uses
+       * this instead of `insertMany` so duplicate sibling headings can't abort the
+       * whole index run (see ISSUE-indexer-duplicate-anchor.md).
        */
       insertOneResolving(r) {
         const info = this._insert.run({
@@ -3128,7 +3164,7 @@ var init_sections = __esm({
           created_at: Date.now()
         });
         if (info.changes > 0) return Number(info.lastInsertRowid);
-        const existing = this._getByAnchor.get(r.note_id, r.anchor);
+        const existing = this._getByIdentity.get(r.note_id, r.heading_path, r.anchor);
         return existing ? Number(existing.id) : null;
       }
       deleteByNote(noteId) {
@@ -4922,6 +4958,290 @@ var init_hybrid = __esm({
   }
 });
 
+// src/adapters/retrieval/contextfit/cli.ts
+import spawn from "cross-spawn";
+function runContextFit(cfg, subcommandArgs, timeoutMs) {
+  const globalArgs = ["--kb", cfg.kbPath];
+  if (cfg.tokenizer) globalArgs.push("--tokenizer", cfg.tokenizer);
+  const args2 = [...globalArgs, ...subcommandArgs];
+  return new Promise((resolve7, reject) => {
+    let child;
+    try {
+      child = spawn(cfg.command, args2, { stdio: ["pipe", "pipe", "pipe"] });
+    } catch (err) {
+      const e = err;
+      reject(
+        new ContextFitError(
+          `contextfit spawn failed: ${e.message}`,
+          e.code === "ENOENT" ? "ENOENT" : "NONZERO_EXIT"
+        )
+      );
+      return;
+    }
+    child.stdin?.end();
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGKILL");
+      reject(new ContextFitError(`contextfit timed out after ${timeoutMs}ms`, "TIMEOUT"));
+    }, timeoutMs);
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (err.code === "ENOENT") {
+        reject(
+          new ContextFitError(
+            `contextfit not found (tried '${cfg.command}'). Install it with \`pipx install contextfit\` (or pip), or set the command path.`,
+            "ENOENT"
+          )
+        );
+      } else {
+        reject(new ContextFitError(`contextfit spawn failed: ${err.message}`));
+      }
+    });
+    child.on("close", (codeNum) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (codeNum === 0) {
+        resolve7({ stdout, stderr });
+      } else {
+        reject(
+          new ContextFitError(
+            `contextfit exited ${codeNum}: ${stderr.trim() || stdout.trim() || "(no output)"}`,
+            "NONZERO_EXIT"
+          )
+        );
+      }
+    });
+  });
+}
+async function runContextFitWithRetry(cfg, subcommandArgs, timeoutMs) {
+  try {
+    return await runContextFit(cfg, subcommandArgs, timeoutMs);
+  } catch (err) {
+    const isEbadf = err instanceof ContextFitError && /EBADF/.test(err.message);
+    if (!isEbadf) throw err;
+    await new Promise((r) => setTimeout(r, 50));
+    return runContextFit(cfg, subcommandArgs, timeoutMs);
+  }
+}
+async function contextFitIngest(cfg, source, opts = {}) {
+  const args2 = ["ingest", source, "--rebuild-index-after-ingest"];
+  if (opts.chunkSize !== void 0) args2.push("--chunk-size", String(opts.chunkSize));
+  if (opts.overlap !== void 0) args2.push("--overlap", String(opts.overlap));
+  const { stdout } = await runContextFitWithRetry(cfg, args2, cfg.timeoutMs ?? 6e5);
+  return stdout;
+}
+async function contextFitQuery(cfg, query, opts = {}) {
+  const args2 = ["query", query, "--json"];
+  if (opts.topK !== void 0) args2.push("--top-k", String(opts.topK));
+  if (opts.method !== void 0) args2.push("--method", opts.method);
+  const { stdout } = await runContextFitWithRetry(cfg, args2, cfg.timeoutMs ?? 3e4);
+  return parseQueryOutput(stdout);
+}
+function parseQueryOutput(stdout) {
+  const start = stdout.indexOf("{");
+  if (start === -1) {
+    throw new ContextFitError(
+      `contextfit query produced no JSON: ${stdout.slice(0, 200)}`,
+      "BAD_JSON"
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout.slice(start));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new ContextFitError(`contextfit query JSON parse failed: ${msg}`, "BAD_JSON");
+  }
+  const obj = parsed;
+  if (!Array.isArray(obj.chunks)) {
+    throw new ContextFitError(
+      `contextfit query JSON missing 'chunks' array (got keys: ${Object.keys(obj ?? {}).join(", ")})`,
+      "BAD_JSON"
+    );
+  }
+  return {
+    query: typeof obj.query === "string" ? obj.query : "",
+    method: typeof obj.method === "string" ? obj.method : "hybrid",
+    retrieved_chunks: typeof obj.retrieved_chunks === "number" ? obj.retrieved_chunks : obj.chunks.length,
+    chunks: obj.chunks
+  };
+}
+async function contextFitProbe(cfg) {
+  try {
+    await new Promise((resolve7, reject) => {
+      const child = spawn(cfg.command, ["--help"], { stdio: ["pipe", "pipe", "pipe"] });
+      child.stdin?.end();
+      child.on("error", reject);
+      child.on(
+        "close",
+        (c) => c === 0 ? resolve7() : reject(new Error(`exit ${c}`))
+      );
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ContextFitError;
+var init_cli = __esm({
+  "src/adapters/retrieval/contextfit/cli.ts"() {
+    "use strict";
+    init_esm_shims();
+    ContextFitError = class extends Error {
+      constructor(message, code = "NONZERO_EXIT") {
+        super(message);
+        this.code = code;
+      }
+      code;
+      name = "ContextFitError";
+    };
+  }
+});
+
+// src/adapters/retrieval/contextfit/index.ts
+var contextfit_exports = {};
+__export(contextfit_exports, {
+  cliConfigForVault: () => cliConfigForVault,
+  contextFitKbDir: () => contextFitKbDir,
+  indexVaultWithContextFit: () => indexVaultWithContextFit,
+  searchVaultWithContextFit: () => searchVaultWithContextFit,
+  sourceToNotePath: () => sourceToNotePath
+});
+import { homedir as homedir4 } from "os";
+import { rm } from "fs/promises";
+import { join as join4, relative, isAbsolute } from "path";
+function contextFitKbDir(vaultName) {
+  return join4(homedir4(), ".vault-memory", "contextfit", vaultName);
+}
+function cliConfigForVault(vault) {
+  const cfg = {
+    command: vault.contextfit?.command ?? DEFAULT_COMMAND,
+    kbPath: contextFitKbDir(vault.name)
+  };
+  if (vault.contextfit?.tokenizer) cfg.tokenizer = vault.contextfit.tokenizer;
+  return cfg;
+}
+async function indexVaultWithContextFit(vault, opts = {}) {
+  const log = opts.onProgress ?? (() => {
+  });
+  const cfg = cliConfigForVault(vault);
+  const start = Date.now();
+  log(`ContextFit: ingesting ${vault.path} \u2192 ${cfg.kbPath}`);
+  const available = await contextFitProbe({ command: cfg.command });
+  if (!available) {
+    return {
+      status: "failed",
+      stats: "",
+      durationMs: Date.now() - start,
+      error: `ContextFit CLI not runnable (tried '${cfg.command}'). Install with \`pipx install contextfit\` or set [[vaults]].contextfit.command.`
+    };
+  }
+  try {
+    await rm(cfg.kbPath, { recursive: true, force: true });
+    const stats = await contextFitIngest(cfg, vault.path);
+    log(stats.trim().split("\n").slice(-3).join(" \xB7 "));
+    return { status: "completed", stats, durationMs: Date.now() - start };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { status: "failed", stats: "", durationMs: Date.now() - start, error: message };
+  }
+}
+function sourceToNotePath(source, vaultPath) {
+  if (!source) return null;
+  const rel = isAbsolute(source) ? relative(vaultPath, source) : source;
+  if (rel.startsWith("..")) return null;
+  return rel.split(/[\\/]/).join("/");
+}
+function chunkToHit(chunk, vault) {
+  const notePath = sourceToNotePath(chunk.metadata?.source, vault.path);
+  if (notePath === null) return null;
+  const base = notePath.split("/").pop() ?? notePath;
+  const noteTitle = base.replace(/\.md$/i, "");
+  const hit = {
+    vault: vault.name,
+    notePath,
+    noteTitle,
+    chunkText: chunk.preview ?? "",
+    chunkIdx: chunk.chunk_id,
+    headingPath: null,
+    score: chunk.score,
+    scoreBreakdown: { contextfit: chunk.score }
+  };
+  return hit;
+}
+async function searchVaultWithContextFit(vault, query, opts = {}) {
+  const cfg = cliConfigForVault(vault);
+  const method = vault.contextfit?.method ?? "hybrid";
+  const result = await contextFitQuery(cfg, query, {
+    topK: opts.topK ?? 10,
+    method
+  });
+  const hits = [];
+  for (const chunk of result.chunks) {
+    const hit = chunkToHit(chunk, vault);
+    if (hit) hits.push(hit);
+  }
+  return hits;
+}
+var DEFAULT_COMMAND;
+var init_contextfit = __esm({
+  "src/adapters/retrieval/contextfit/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_cli();
+    DEFAULT_COMMAND = "contextfit";
+  }
+});
+
+// src/search/dispatch.ts
+function isContextFit(vault) {
+  return vault.config.backend === "contextfit";
+}
+async function searchVaults(opts) {
+  const topK = opts.topK ?? 10;
+  const cfVaults = opts.vaults.filter(isContextFit);
+  const ollamaVaults = opts.vaults.filter((v) => !isContextFit(v));
+  if (cfVaults.length === 0) {
+    return hybridSearch(opts);
+  }
+  const { searchVaultWithContextFit: searchVaultWithContextFit2 } = await Promise.resolve().then(() => (init_contextfit(), contextfit_exports));
+  const cfPromise = Promise.all(
+    cfVaults.map(
+      (v) => searchVaultWithContextFit2(v.config, opts.query, { topK }).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[search:${v.config.name}] ContextFit query failed: ${msg}`);
+        return [];
+      })
+    )
+  );
+  const ollamaPromise = ollamaVaults.length > 0 ? hybridSearch({ ...opts, vaults: ollamaVaults }) : Promise.resolve([]);
+  const [cfResultsNested, ollamaResults] = await Promise.all([cfPromise, ollamaPromise]);
+  const cfResults = cfResultsNested.flat();
+  const merged = [...ollamaResults, ...cfResults];
+  merged.sort((a, b) => b.score - a.score);
+  return merged.slice(0, topK);
+}
+var init_dispatch = __esm({
+  "src/search/dispatch.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hybrid();
+  }
+});
+
 // src/search/glob.ts
 function compile(pattern) {
   const cached = cache.get(pattern);
@@ -4969,6 +5289,7 @@ var init_search = __esm({
     "use strict";
     init_esm_shims();
     init_hybrid();
+    init_dispatch();
     init_glob();
   }
 });
@@ -5014,7 +5335,7 @@ var init_reranker = __esm({
 // src/rerank/onnx-reranker.ts
 import { readFile as readFile3 } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function sigmoid(x) {
   return 1 / (1 + Math.exp(-x));
 }
@@ -5092,8 +5413,8 @@ var init_onnx_reranker = __esm({
         if (this.loaded) return this.loaded;
         if (this.loading) return this.loading;
         this.loading = (async () => {
-          const modelPath = join4(this.modelDir, "model_quantized.onnx");
-          const tokenizerPath = join4(this.modelDir, "tokenizer.json");
+          const modelPath = join5(this.modelDir, "model_quantized.onnx");
+          const tokenizerPath = join5(this.modelDir, "tokenizer.json");
           if (!existsSync(modelPath)) {
             throw new Error(
               `OnnxReranker: model file not found at ${modelPath}. Run: curl -L https://huggingface.co/onnx-community/bge-reranker-v2-m3-ONNX/resolve/main/onnx/model_quantized.onnx -o ${modelPath}`
@@ -6419,53 +6740,62 @@ async function indexVault(vault, options) {
   const mode = options.mode ?? "incremental";
   const log = options.onProgress ?? (() => {
   });
-  log(`Probing Ollama model: ${options.embeddingModel}`);
-  const health = await options.ollama.healthCheck();
-  if (!health.ok) {
-    throw new Error(`Ollama unreachable: ${health.error ?? "unknown error"}`);
-  }
-  const modelExists = await options.ollama.modelExists(options.embeddingModel);
-  if (!modelExists) {
-    throw new Error(
-      `Embedding model "${options.embeddingModel}" not found in Ollama. Available: ${health.models?.join(", ") ?? "(none)"}. Run: ollama pull ${options.embeddingModel}`
-    );
-  }
-  const probe = await options.ollama.embed({
-    model: options.embeddingModel,
-    texts: ["probe"]
-  });
-  const dim = probe.dim;
-  const modelRow = vault.db.models.upsert({
-    name: options.embeddingModel,
-    provider: "ollama",
-    dim
-  });
+  const embedMode = options.embeddings ?? "ollama";
+  const ollama = options.ollama;
+  let dim = 0;
+  let modelRow = null;
   let secondaryModelRow = null;
-  if (options.secondaryEmbeddingModel) {
-    const secName = options.secondaryEmbeddingModel;
-    log(`Probing secondary (shadow) model: ${secName}`);
-    const secExists = await options.ollama.modelExists(secName);
-    if (!secExists) {
+  if (embedMode === "ollama") {
+    if (!ollama) {
+      throw new Error("indexVault: embeddings='ollama' requires an OllamaClient (options.ollama).");
+    }
+    log(`Probing Ollama model: ${options.embeddingModel}`);
+    const health = await ollama.healthCheck();
+    if (!health.ok) {
+      throw new Error(`Ollama unreachable: ${health.error ?? "unknown error"}`);
+    }
+    const modelExists = await ollama.modelExists(options.embeddingModel);
+    if (!modelExists) {
       throw new Error(
-        `Secondary embedding model "${secName}" not found in Ollama. Run: ollama pull ${secName}`
+        `Embedding model "${options.embeddingModel}" not found in Ollama. Available: ${health.models?.join(", ") ?? "(none)"}. Run: ollama pull ${options.embeddingModel}`
       );
     }
-    const secProbe = await options.ollama.embed({
-      model: secName,
+    const probe = await ollama.embed({
+      model: options.embeddingModel,
       texts: ["probe"]
     });
-    const row = vault.db.models.upsert({
-      name: secName,
+    dim = probe.dim;
+    modelRow = vault.db.models.upsert({
+      name: options.embeddingModel,
       provider: "ollama",
-      dim: secProbe.dim,
-      active: false
+      dim
     });
-    secondaryModelRow = { id: row.id, dim: row.dim };
+    if (options.secondaryEmbeddingModel) {
+      const secName = options.secondaryEmbeddingModel;
+      log(`Probing secondary (shadow) model: ${secName}`);
+      const secExists = await ollama.modelExists(secName);
+      if (!secExists) {
+        throw new Error(
+          `Secondary embedding model "${secName}" not found in Ollama. Run: ollama pull ${secName}`
+        );
+      }
+      const secProbe = await ollama.embed({
+        model: secName,
+        texts: ["probe"]
+      });
+      const row = vault.db.models.upsert({
+        name: secName,
+        provider: "ollama",
+        dim: secProbe.dim,
+        active: false
+      });
+      secondaryModelRow = { id: row.id, dim: row.dim };
+    }
   }
   vault.db.audit.startRun({
     runId,
     vaultName: vault.config.name,
-    modelId: modelRow.id,
+    modelId: modelRow?.id ?? null,
     trigger: mode === "full" ? "manual-full" : "manual-incremental"
   });
   let notesIndexed = 0;
@@ -6556,36 +6886,38 @@ async function indexVault(vault, options) {
           `[indexer:${vault.config.name}] section build failed for ${parsed.relativePath}: ${message} \u2014 skipping sections for this note`
         );
       }
-      const embedResult = await options.ollama.embed({
-        model: options.embeddingModel,
-        texts: chunks.map((c) => c.text)
-      });
-      if (embedResult.dim !== dim) {
-        throw new Error(`Embedding dimension mismatch: expected ${dim}, got ${embedResult.dim}`);
-      }
-      const embeddingInputs = chunkIds.map((chunkId, i) => ({
-        chunkId,
-        modelId: modelRow.id,
-        vector: embedResult.vectors[i]
-      }));
-      vault.db.embeddings.insertBatch(embeddingInputs);
-      if (secondaryModelRow) {
-        const secEmbed = await options.ollama.embed({
-          model: options.secondaryEmbeddingModel,
+      if (embedMode === "ollama") {
+        const embedResult = await ollama.embed({
+          model: options.embeddingModel,
           texts: chunks.map((c) => c.text)
         });
-        if (secEmbed.dim !== secondaryModelRow.dim) {
-          throw new Error(
-            `Secondary embedding dimension mismatch: expected ${secondaryModelRow.dim}, got ${secEmbed.dim}`
+        if (embedResult.dim !== dim) {
+          throw new Error(`Embedding dimension mismatch: expected ${dim}, got ${embedResult.dim}`);
+        }
+        const embeddingInputs = chunkIds.map((chunkId, i) => ({
+          chunkId,
+          modelId: modelRow.id,
+          vector: embedResult.vectors[i]
+        }));
+        vault.db.embeddings.insertBatch(embeddingInputs);
+        if (secondaryModelRow) {
+          const secEmbed = await ollama.embed({
+            model: options.secondaryEmbeddingModel,
+            texts: chunks.map((c) => c.text)
+          });
+          if (secEmbed.dim !== secondaryModelRow.dim) {
+            throw new Error(
+              `Secondary embedding dimension mismatch: expected ${secondaryModelRow.dim}, got ${secEmbed.dim}`
+            );
+          }
+          vault.db.embeddings.insertBatch(
+            chunkIds.map((chunkId, i) => ({
+              chunkId,
+              modelId: secondaryModelRow.id,
+              vector: secEmbed.vectors[i]
+            }))
           );
         }
-        vault.db.embeddings.insertBatch(
-          chunkIds.map((chunkId, i) => ({
-            chunkId,
-            modelId: secondaryModelRow.id,
-            vector: secEmbed.vectors[i]
-          }))
-        );
       }
       insertWikilinks(vault, noteId, parsed.wikilinks, firstPassResolver);
       writeAllEdges(vault, noteId, parsed, firstPassResolver);
@@ -6850,16 +7182,24 @@ async function indexNote(options) {
       isNew: false
     };
   }
-  const activeModel = vault.db.models.getActive();
-  if (!activeModel) {
-    throw new Error(
-      `single-indexer: no active embedding model in DB. Run a full index first to register "${embeddingModel}".`
-    );
-  }
-  if (activeModel.name !== embeddingModel) {
-    throw new Error(
-      `single-indexer: active model "${activeModel.name}" does not match requested "${embeddingModel}". Run a full re-index to switch models.`
-    );
+  const embedMode = options.embeddings ?? "ollama";
+  let activeModel = null;
+  if (embedMode === "ollama") {
+    if (!ollama) {
+      throw new Error("single-indexer: embeddings='ollama' requires an OllamaClient.");
+    }
+    const am = vault.db.models.getActive();
+    if (!am) {
+      throw new Error(
+        `single-indexer: no active embedding model in DB. Run a full index first to register "${embeddingModel}".`
+      );
+    }
+    if (am.name !== embeddingModel) {
+      throw new Error(
+        `single-indexer: active model "${am.name}" does not match requested "${embeddingModel}". Run a full re-index to switch models.`
+      );
+    }
+    activeModel = am;
   }
   const upsert = vault.db.notes.upsertByPath({
     path: parsed.relativePath,
@@ -6872,6 +7212,7 @@ async function indexNote(options) {
     wordCount: parsed.wordCount
   });
   vault.db.aliases.setForNote(upsert.id, extractAliases(parsed.frontmatter));
+  vault.db.sections.deleteByNote(upsert.id);
   vault.db.chunks.deleteByNote(upsert.id);
   vault.db.wikilinks.deleteByNote(upsert.id);
   vault.db.edges.deleteByNote(upsert.id);
@@ -6901,41 +7242,52 @@ async function indexNote(options) {
       chunkIdFragment: computeChunkIdFragment(c.text)
     }))
   );
-  const embedResult = await ollama.embed({
-    model: embeddingModel,
-    texts: chunks.map((c) => c.text)
-  });
-  if (embedResult.dim !== activeModel.dim) {
-    throw new Error(
-      `single-indexer: embedding dim ${embedResult.dim} does not match registered dim ${activeModel.dim} for model "${embeddingModel}".`
+  try {
+    buildSectionsForNote(vault, upsert.id, parsed.content, chunkIds);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `[single-indexer:${vault.config.name}] section build failed for ${parsed.relativePath}: ${message}
+`
     );
   }
-  vault.db.embeddings.insertBatch(
-    chunkIds.map((chunkId, i) => ({
-      chunkId,
-      modelId: activeModel.id,
-      vector: embedResult.vectors[i]
-    }))
-  );
-  if (secondaryName) {
-    const secondaryModel = vault.db.models.getByName(secondaryName);
-    if (secondaryModel && secondaryModel.id !== activeModel.id) {
-      const secEmbed = await ollama.embed({
-        model: secondaryName,
-        texts: chunks.map((c) => c.text)
-      });
-      if (secEmbed.dim !== secondaryModel.dim) {
-        throw new Error(
-          `single-indexer: shadow embedding dim ${secEmbed.dim} does not match registered dim ${secondaryModel.dim} for "${secondaryName}".`
+  if (embedMode === "ollama") {
+    const embedResult = await ollama.embed({
+      model: embeddingModel,
+      texts: chunks.map((c) => c.text)
+    });
+    if (embedResult.dim !== activeModel.dim) {
+      throw new Error(
+        `single-indexer: embedding dim ${embedResult.dim} does not match registered dim ${activeModel.dim} for model "${embeddingModel}".`
+      );
+    }
+    vault.db.embeddings.insertBatch(
+      chunkIds.map((chunkId, i) => ({
+        chunkId,
+        modelId: activeModel.id,
+        vector: embedResult.vectors[i]
+      }))
+    );
+    if (secondaryName) {
+      const secondaryModel = vault.db.models.getByName(secondaryName);
+      if (secondaryModel && secondaryModel.id !== activeModel.id) {
+        const secEmbed = await ollama.embed({
+          model: secondaryName,
+          texts: chunks.map((c) => c.text)
+        });
+        if (secEmbed.dim !== secondaryModel.dim) {
+          throw new Error(
+            `single-indexer: shadow embedding dim ${secEmbed.dim} does not match registered dim ${secondaryModel.dim} for "${secondaryName}".`
+          );
+        }
+        vault.db.embeddings.insertBatch(
+          chunkIds.map((chunkId, i) => ({
+            chunkId,
+            modelId: secondaryModel.id,
+            vector: secEmbed.vectors[i]
+          }))
         );
       }
-      vault.db.embeddings.insertBatch(
-        chunkIds.map((chunkId, i) => ({
-          chunkId,
-          modelId: secondaryModel.id,
-          vector: secEmbed.vectors[i]
-        }))
-      );
     }
   }
   insertWikilinks2(vault, upsert.id, parsed.wikilinks);
@@ -7027,6 +7379,7 @@ async function catchupVault(options) {
   });
   let reindexed = 0;
   const knownPaths = /* @__PURE__ */ new Set();
+  const isContextFit2 = vault.config.backend === "contextfit";
   for (const file of files) {
     const parsed = await parseNote(file, vault.config.path).catch(() => null);
     if (!parsed) continue;
@@ -7039,7 +7392,7 @@ async function catchupVault(options) {
       vault,
       absolutePath: file,
       embeddingModel: options.embeddingModel,
-      ollama: options.ollama
+      ...isContextFit2 ? { embeddings: "none" } : { ollama: options.ollama }
     });
     if (result.status === "indexed") {
       reindexed++;
@@ -7056,6 +7409,13 @@ async function catchupVault(options) {
       }
     }
   }
+  if (isContextFit2 && (reindexed > 0 || removed > 0)) {
+    const { indexVaultWithContextFit: indexVaultWithContextFit2 } = await Promise.resolve().then(() => (init_contextfit(), contextfit_exports));
+    const r = await indexVaultWithContextFit2(vault.config, { onProgress: log });
+    log(
+      r.status === "completed" ? `catch-up: ContextFit KB rebuilt (${r.durationMs}ms)` : `catch-up: ContextFit KB rebuild failed: ${r.error}`
+    );
+  }
   return {
     scanned: files.length,
     reindexed,
@@ -7063,9 +7423,9 @@ async function catchupVault(options) {
     durationMs: Date.now() - started
   };
 }
-function joinAbs(root, relative5) {
-  if (root.endsWith("/")) return `${root}${relative5}`;
-  return `${root}/${relative5}`;
+function joinAbs(root, relative6) {
+  if (root.endsWith("/")) return `${root}${relative6}`;
+  return `${root}/${relative6}`;
 }
 var init_catchup = __esm({
   "src/indexer/catchup.ts"() {
@@ -7317,10 +7677,10 @@ var init_indexer2 = __esm({
 
 // src/adapters/delivery/obsidian-fs/fs.ts
 import { promises as fs5 } from "fs";
-import { dirname, isAbsolute, resolve as resolve6, sep as sep5 } from "path";
+import { dirname, isAbsolute as isAbsolute2, resolve as resolve6, sep as sep5 } from "path";
 import { randomBytes } from "crypto";
 async function atomicWriteFile(absPath, content) {
-  if (!isAbsolute(absPath)) {
+  if (!isAbsolute2(absPath)) {
     throw new Error(`atomicWriteFile requires an absolute path: ${absPath}`);
   }
   const parent = dirname(absPath);
@@ -7342,7 +7702,7 @@ async function safeJoinInsideVault(vaultRoot, relativePath) {
   if (typeof relativePath !== "string" || relativePath.length === 0) {
     throw new OutsideVaultError(relativePath, vaultRoot);
   }
-  if (isAbsolute(relativePath)) {
+  if (isAbsolute2(relativePath)) {
     throw new OutsideVaultError(relativePath, vaultRoot);
   }
   const root = resolve6(vaultRoot);
@@ -9902,14 +10262,14 @@ var init_get = __esm({
 
 // src/brief/lock.ts
 import { open, readFile as readFile5, unlink, mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
 function lockDir(rootOverride) {
-  if (rootOverride !== void 0) return join6(rootOverride, "locks");
-  return join6(homedir4(), ".vault-memory", "locks");
+  if (rootOverride !== void 0) return join7(rootOverride, "locks");
+  return join7(homedir5(), ".vault-memory", "locks");
 }
 function lockPath(vaultName, rootOverride) {
-  return join6(lockDir(rootOverride), `${vaultName}.lock`);
+  return join7(lockDir(rootOverride), `${vaultName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -10415,7 +10775,7 @@ async function searchSections(deps, args2) {
     const resolution = deps.sectionForHit(hit.vault, hit.notePath, hit.chunkIdx);
     if (!resolution) continue;
     if (resolution.headingPath.length === 0) continue;
-    const key = `${resolution.noteId}#${resolution.anchor}`;
+    const key = `${resolution.noteId}#${resolution.headingPath.join("\0")}#${resolution.anchor}`;
     const existing = sectionMap.get(key);
     if (!existing) {
       sectionMap.set(key, {
@@ -10746,6 +11106,9 @@ var init_watcher = __esm({
       queue;
       opts;
       started = false;
+      /** ADR-008: debounce timer for ContextFit KB re-ingest (coalesces bursts). */
+      cfReingestTimer = null;
+      cfReingestInFlight = false;
       constructor(options) {
         this.opts = {
           vault: options.vault,
@@ -10793,12 +11156,51 @@ var init_watcher = __esm({
         if (!this.started) return;
         this.started = false;
         this.queue.shutdown();
+        if (this.cfReingestTimer) {
+          clearTimeout(this.cfReingestTimer);
+          this.cfReingestTimer = null;
+        }
         if (this.fsWatcher) {
           await this.fsWatcher.close();
           this.fsWatcher = null;
         }
       }
       // ─── internal ──────────────────────────────────────────────────────────
+      /**
+       * ADR-008: schedule a debounced full ContextFit KB re-ingest. Per-note
+       * changes update the SQLite layer immediately (via indexNote); the ContextFit
+       * search KB is rebuilt in one coalesced pass ~1.5s after the last change so a
+       * burst of edits triggers a single re-ingest. CPU-only and fast.
+       */
+      scheduleContextFitReingest() {
+        if (this.cfReingestTimer) clearTimeout(this.cfReingestTimer);
+        this.cfReingestTimer = setTimeout(() => {
+          this.cfReingestTimer = null;
+          void this.runContextFitReingest();
+        }, 1500);
+      }
+      async runContextFitReingest() {
+        if (this.cfReingestInFlight) {
+          this.scheduleContextFitReingest();
+          return;
+        }
+        this.cfReingestInFlight = true;
+        try {
+          const { indexVaultWithContextFit: indexVaultWithContextFit2 } = await Promise.resolve().then(() => (init_contextfit(), contextfit_exports));
+          const r = await indexVaultWithContextFit2(this.opts.vault.config, {});
+          if (r.status === "completed") {
+            this.opts.log(`ContextFit KB refreshed (${r.durationMs}ms)`);
+          } else {
+            this.opts.log(`ContextFit KB refresh failed: ${r.error}`);
+          }
+        } catch (err) {
+          this.opts.log(
+            `ContextFit KB refresh error: ${err instanceof Error ? err.message : String(err)}`
+          );
+        } finally {
+          this.cfReingestInFlight = false;
+        }
+      }
       onFsEvent(absolutePath, kind) {
         if (!absolutePath.endsWith(".md")) return;
         const relativePath = this.toRelative(absolutePath);
@@ -10817,10 +11219,12 @@ var init_watcher = __esm({
       }
       async handleFlush(event) {
         const relativePath = this.toRelative(event.path);
+        const isContextFit2 = this.opts.vault.config.backend === "contextfit";
         if (event.kind === "delete") {
           const result2 = removeNote(this.opts.vault, event.path);
           if (result2.removed) {
             this.opts.log(`removed ${relativePath}`);
+            if (isContextFit2) this.scheduleContextFitReingest();
           } else {
             this.opts.log(`delete event for unknown ${relativePath} (skip)`);
           }
@@ -10831,13 +11235,16 @@ var init_watcher = __esm({
           absolutePath: event.path,
           embeddingModel: this.opts.embeddingModel,
           secondaryEmbeddingModel: this.opts.secondaryEmbeddingModel,
-          ollama: this.opts.ollama
+          // ADR-008: ContextFit vaults build the SQLite layer without embeddings;
+          // their search KB is refreshed by the debounced re-ingest below.
+          ...isContextFit2 ? { embeddings: "none" } : { ollama: this.opts.ollama }
         });
         switch (result.status) {
           case "indexed":
             this.opts.log(
               `indexed ${relativePath} (${result.isNew ? "new" : "updated"}, ${result.chunksCreated} chunks)`
             );
+            if (isContextFit2) this.scheduleContextFitReingest();
             break;
           case "unchanged":
             break;
@@ -14521,6 +14928,13 @@ async function handleWriteNote(registry, vault, parsed) {
     if (res.observedValue !== void 0) out.observedValue = res.observedValue;
     return out;
   }
+  if (vault.config.backend === "contextfit") {
+    try {
+      const { indexVaultWithContextFit: indexVaultWithContextFit2 } = await Promise.resolve().then(() => (init_contextfit(), contextfit_exports));
+      await indexVaultWithContextFit2(vault.config, {});
+    } catch {
+    }
+  }
   const noteRow = vault.db.notes.getByPath(parsed.path);
   return {
     ok: true,
@@ -14734,7 +15148,12 @@ function handleSearchText(manager, activeVault, query, vaultFilter, topK, exclud
   const fanK = hasExclude ? topK * 3 : topK;
   const sanitized = FtsQueries.sanitize(query);
   const allHits = [];
+  const skippedContextFit = [];
   for (const vault of targets) {
+    if (vault.config.backend === "contextfit") {
+      skippedContextFit.push(vault.config.name);
+      continue;
+    }
     const ftsHits = vault.db.fts.search(sanitized, fanK, true);
     for (const hit of ftsHits) {
       const chunk = vault.db.chunks.getById(hit.chunkId);
@@ -14759,9 +15178,14 @@ function handleSearchText(manager, activeVault, query, vaultFilter, topK, exclud
     hits: allHits.slice(0, topK),
     count: allHits.length
   };
-  if (skipped.length > 0) {
-    out.note = `Skipped vault(s) currently indexing: ${skipped.join(", ")}.`;
+  const notes = [];
+  if (skipped.length > 0) notes.push(`Skipped vault(s) currently indexing: ${skipped.join(", ")}.`);
+  if (skippedContextFit.length > 0) {
+    notes.push(
+      `search_text is not supported for ContextFit vault(s): ${skippedContextFit.join(", ")} \u2014 use search_hybrid or search_semantic instead.`
+    );
   }
+  if (notes.length > 0) out.note = notes.join(" ");
   return out;
 }
 async function handleSearchHybrid(manager, ollama, defaultModel, activeVault, query, vaultFilter, topK, rrfK, excludePaths, reranker, recencyWeight = 0, authorityWeight = 0, halfLifeDays = 30, includeSuperseded = false, displayUrlFor2, expandOpts, expandDeps) {
@@ -14774,7 +15198,7 @@ async function handleSearchHybrid(manager, ollama, defaultModel, activeVault, qu
   }
   const hasExclude = excludePaths !== void 0 && excludePaths.length > 0;
   const innerTopK = hasExclude ? topK * 3 : topK;
-  const hits = await hybridSearch({
+  const hits = await searchVaults({
     query,
     embeddingModel: defaultModel,
     ollama,
@@ -14812,7 +15236,7 @@ async function handleSearchCompat(manager, registry, ollama, defaultModel, activ
       note: skipped.length > 0 ? `All eligible vaults are indexing; skipped: ${skipped.join(", ")}.` : "No vaults configured."
     };
   }
-  const hits = await hybridSearch({
+  const hits = await searchVaults({
     query,
     embeddingModel: defaultModel,
     ollama,
@@ -15729,7 +16153,7 @@ __export(server_exports, {
 });
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { join as joinPath } from "path";
 async function discoverMemorySinks(configured, vaults) {
   if (configured.length > 0) {
@@ -15796,19 +16220,20 @@ async function serve(options = {}) {
   const activeVault = process.env.VAULT_MEMORY_ACTIVE_VAULT?.trim() || void 0;
   const rerankerBackend = config.server.reranker_backend ?? (config.server.reranker_model ? "onnx" : void 0);
   const reranker = config.server.reranker_model ? rerankerBackend === "ollama" ? new OllamaReranker({ ollama, model: config.server.reranker_model }) : new OnnxReranker({
-    modelDir: config.server.reranker_model_dir ?? joinPath(homedir5(), ".vault-memory", "models", "bge-reranker-v2-m3")
+    modelDir: config.server.reranker_model_dir ?? joinPath(homedir6(), ".vault-memory", "models", "bge-reranker-v2-m3")
   }) : void 0;
   const watchers = /* @__PURE__ */ new Map();
   const briefDaemons = /* @__PURE__ */ new Map();
   const startCatchupAndWatchers = async () => {
     for (const vault of manager.list()) {
-      if (!vault.config.embedding_model && !vault.db.models.getActive()) continue;
+      const isContextFit2 = vault.config.backend === "contextfit";
+      if (!isContextFit2 && !vault.config.embedding_model && !vault.db.models.getActive()) continue;
       const modelName = vault.config.embedding_model ?? defaultModel;
       try {
         const result = await catchupVault({
           vault,
           embeddingModel: modelName,
-          ollama,
+          ...isContextFit2 ? {} : { ollama },
           log: (m) => process.stderr.write(`[catchup:${vault.config.name}] ${m}
 `)
         });
@@ -16891,6 +17316,36 @@ async function runIndex(rest) {
   });
   const targets = vaultName ? [manager.require(vaultName)] : manager.list();
   for (const vault of targets) {
+    if (vault.config.backend === "contextfit") {
+      const { indexVaultWithContextFit: indexVaultWithContextFit2 } = await Promise.resolve().then(() => (init_contextfit(), contextfit_exports));
+      console.error(
+        `
+\u2192 Indexing "${vault.config.name}" with ContextFit (CPU-only, no embeddings)`
+      );
+      const sqlite = await indexVault2(vault, {
+        mode,
+        embeddingModel: "contextfit",
+        embeddings: "none",
+        onProgress: (msg) => console.error(`  ${msg}`)
+      });
+      if (sqlite.status !== "completed") {
+        console.error(`\u2717 ${vault.config.name}: SQLite layer failed \u2014 ${sqlite.error}`);
+        process.exitCode = 1;
+        continue;
+      }
+      const cfResult = await indexVaultWithContextFit2(vault.config, {
+        onProgress: (msg) => console.error(`  ${msg}`)
+      });
+      if (cfResult.status === "completed") {
+        console.error(
+          `\u2713 ${vault.config.name}: ${sqlite.notesIndexed} notes (SQLite) + ContextFit KB \xB7 ${sqlite.durationMs + cfResult.durationMs}ms`
+        );
+      } else {
+        console.error(`\u2717 ${vault.config.name}: ContextFit KB failed \u2014 ${cfResult.error}`);
+        process.exitCode = 1;
+      }
+      continue;
+    }
     const model = vault.config.embedding_model ?? config.server.default_embedding_model ?? "qwen3-embedding";
     console.error(`
 \u2192 Indexing "${vault.config.name}" (${mode}) with ${model}`);
@@ -16918,6 +17373,8 @@ async function runAddVault(rest) {
   let name;
   let writeEnabled = false;
   let skipIndex = false;
+  let backend;
+  const USAGE = "Usage: vault-memory add-vault <path> [--name <name>] [--write] [--backend ollama|contextfit] [--no-index]";
   for (let i = 0; i < rest.length; i++) {
     const arg = rest[i];
     if (arg === "--name") {
@@ -16925,24 +17382,37 @@ async function runAddVault(rest) {
       i++;
     } else if (arg === "--write" || arg === "--write-enabled") {
       writeEnabled = true;
+    } else if (arg === "--backend") {
+      const v = rest[i + 1];
+      i++;
+      if (v !== "ollama" && v !== "contextfit") {
+        console.error(`--backend must be "ollama" or "contextfit" (got: ${v ?? "<missing>"})`);
+        process.exit(2);
+      }
+      backend = v;
     } else if (arg === "--no-index") {
       skipIndex = true;
     } else if (arg === "--help" || arg === "-h") {
-      console.error(`Usage: vault-memory add-vault <path> [--name <name>] [--write] [--no-index]
+      console.error(`${USAGE}
 
 Registers a vault in ~/.vault-memory/config.toml, writes a .mcp.json
-into the vault root, and runs an initial index. Idempotent.`);
+into the vault root, and runs an initial index. Idempotent.
+
+--backend contextfit  Use the CPU-only, token-native ContextFit engine
+                      (no Ollama / embeddings / GPU). Requires the
+                      \`contextfit\` CLI (pipx install contextfit). Ideal for
+                      resource-limited / non-GPU hosts (e.g. a Synology NAS).`);
       return;
     } else if (arg && !arg.startsWith("--") && path7 === null) {
       path7 = arg;
     }
   }
   if (path7 === null) {
-    console.error("Usage: vault-memory add-vault <path> [--name <name>] [--write] [--no-index]");
+    console.error(USAGE);
     process.exit(2);
   }
-  console.error(`\u2192 Registering vault: ${path7}`);
-  const result = await addVault2({ path: path7, name, writeEnabled });
+  console.error(`\u2192 Registering vault: ${path7}${backend ? ` (backend: ${backend})` : ""}`);
+  const result = await addVault2({ path: path7, name, writeEnabled, ...backend ? { backend } : {} });
   for (const step of result.steps) {
     switch (step.kind) {
       case "config-added":