@yurtsever/capsa 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/index.js

@@ -7228,6 +7228,9 @@ var DEFAULT_EXCLUDES = [
   ".Trash"
 ];
 var DEFAULT_MAX_DEPTH = 12;
+function isSourceAdapter(adapter) {
+  return typeof adapter.collect === "function";
+}
 function stableId(absPath) {
   return createHash("sha1").update(absPath).digest("hex").slice(0, 12);
 }
@@ -7246,16 +7249,24 @@ async function scan(adapters, options = {}) {
   const items = [];
   const seenItemPaths = /* @__PURE__ */ new Set();
   const scannedRoots = [];
+  const formatAdapters = adapters.filter((a) => !isSourceAdapter(a));
+  const sourceAdapters = adapters.filter(isSourceAdapter);
   const rootSet = /* @__PURE__ */ new Set();
   for (const r of options.roots ?? [env.homeDir])
     rootSet.add(resolve(r));
-  for (const adapter of adapters) {
+  for (const adapter of formatAdapters) {
     for (const r of adapter.globalRoots?.(env) ?? [])
       rootSet.add(resolve(r));
   }
   const roots = [...rootSet].filter((r) => ![...rootSet].some((other) => other !== r && r.startsWith(other + "/")));
+  const addItem = (item) => {
+    if (seenItemPaths.has(item.path))
+      return;
+    seenItemPaths.add(item.path);
+    items.push(item);
+  };
   const handleEntry = async (entry) => {
-    for (const adapter of adapters) {
+    for (const adapter of formatAdapters) {
       let matched = false;
       try {
         matched = adapter.matches(entry);
@@ -7270,12 +7281,8 @@ async function scan(adapters, options = {}) {
       if (!matched)
         continue;
       try {
-        for (const item of await adapter.parse(entry, env)) {
-          if (seenItemPaths.has(item.path))
-            continue;
-          seenItemPaths.add(item.path);
-          items.push(item);
-        }
+        for (const item of await adapter.parse(entry, env))
+          addItem(item);
       } catch (err) {
         issues.push({
           path: entry.absPath,
@@ -7346,6 +7353,18 @@ async function scan(adapters, options = {}) {
     }
     scannedRoots.push(root);
     await walk(root, root, 0);
+    for (const adapter of sourceAdapters) {
+      try {
+        for (const item of await adapter.collect(root, env))
+          addItem(item);
+      } catch (err) {
+        issues.push({
+          path: root,
+          adapter: adapter.id,
+          message: `collect() threw: ${String(err)}`
+        });
+      }
+    }
   }
   return { items, issues, scannedRoots, durationMs: Date.now() - started };
 }
@@ -7396,6 +7415,7 @@ function findProjectRoot(startDir, homeDir) {
 // ../core/dist/chunk.js
 var DEFAULT_MAX_CHARS = 2e3;
 function chunkMarkdown(markdown, maxChars = DEFAULT_MAX_CHARS) {
+  const body = parseFrontmatter(markdown).body;
   const chunks = [];
   const trail = [];
   let buffer = [];
@@ -7405,11 +7425,12 @@ function chunkMarkdown(markdown, maxChars = DEFAULT_MAX_CHARS) {
     buffer = [];
     if (!text)
       return;
+    const headingPath = trail.filter((s) => Boolean(s));
     for (const part of splitLong(text, maxChars)) {
-      chunks.push({ index: chunks.length, headingPath: [...trail], text: part });
+      chunks.push({ index: chunks.length, headingPath, text: part });
     }
   };
-  for (const line of markdown.split(/\r?\n/)) {
+  for (const line of body.split(/\r?\n/)) {
     if (/^```/.test(line.trim()))
       inFence = !inFence;
     const heading = !inFence && /^(#{1,6})\s+(.*\S)\s*$/.exec(line);
@@ -10053,7 +10074,23 @@ function loadSqlite() {
 }
 var DB_DIR = ".capsa";
 var DB_FILE = "index.db";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 5;
+var CONTEXT_LOG_DDL = `
+      -- Every context delivery. This is the measurement for the MVP gate and
+      -- the seed of the organisation tier's audit log. Alone among these
+      -- tables its rows are never dropped, so a row has to stand on its own:
+      -- it records what was delivered (path, heading trail, tokens per chunk)
+      -- rather than chunk ids, which a rebuild hands to different text.
+      CREATE TABLE IF NOT EXISTS context_log (
+        id           INTEGER PRIMARY KEY,
+        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+        source       TEXT NOT NULL,
+        query        TEXT NOT NULL,
+        delivered    TEXT NOT NULL,
+        tokens_est   INTEGER NOT NULL,
+        duration_ms  INTEGER NOT NULL
+      );
+`;
 function dbPath(projectRoot) {
   return join6(projectRoot, DB_DIR, DB_FILE);
 }
@@ -10139,20 +10176,32 @@ var Store = class {
         related    TEXT
       );
 
-      -- Every context delivery. This is the measurement for the MVP gate and
-      -- the seed of the organisation tier's audit log.
-      CREATE TABLE IF NOT EXISTS context_log (
-        id           INTEGER PRIMARY KEY,
-        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-        source       TEXT NOT NULL,
-        query        TEXT NOT NULL,
-        chunk_ids    TEXT NOT NULL,
-        tokens_est   INTEGER NOT NULL,
-        duration_ms  INTEGER NOT NULL
-      );
+      ${CONTEXT_LOG_DDL}
     `);
+    this.migrateContextLog();
     this.db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES ('dimensions', ?)").run(String(this.dimensions));
   }
+  /**
+   * `context_log` outlives every rebuild, so it is the one table that has to
+   * be migrated in place instead of recreated. v5 replaced `chunk_ids` with
+   * `delivered`: a chunk id is a rowid the next `capsa index` reassigns, so an
+   * older row ended up naming whatever text inherited its ids — the measurement
+   * quietly decayed. Rows written before v5 keep everything that still means
+   * something (when, who asked, what for, at what cost) and carry an empty
+   * delivery, because their ids can no longer be resolved honestly.
+   */
+  migrateContextLog() {
+    const columns = this.db.prepare("PRAGMA table_info(context_log)").all();
+    if (columns.some((c) => c.name === "delivered"))
+      return;
+    this.db.exec(`
+      ALTER TABLE context_log RENAME TO context_log_v4;
+      ${CONTEXT_LOG_DDL}
+      INSERT INTO context_log (id, created_at, source, query, delivered, tokens_est, duration_ms)
+        SELECT id, created_at, source, query, '[]', tokens_est, duration_ms FROM context_log_v4;
+      DROP TABLE context_log_v4;
+    `);
+  }
   getItem(path) {
     return this.db.prepare("SELECT * FROM items WHERE path = ?").get(path);
   }
@@ -10235,11 +10284,22 @@ var Store = class {
     return this.db.prepare("SELECT * FROM items ORDER BY kind, rel_path").all();
   }
   logContext(entry) {
-    this.db.prepare("INSERT INTO context_log (source, query, chunk_ids, tokens_est, duration_ms) VALUES (?, ?, ?, ?, ?)").run(entry.source, entry.query, JSON.stringify(entry.chunkIds), entry.tokensEst, entry.durationMs);
+    this.db.prepare("INSERT INTO context_log (source, query, delivered, tokens_est, duration_ms) VALUES (?, ?, ?, ?, ?)").run(entry.source, entry.query, JSON.stringify(entry.delivered), entry.tokensEst, entry.durationMs);
   }
+  /**
+   * Returns the stored row, not just its id: `created_at` is SQL's to write,
+   * and the indexed item dates itself from it.
+   */
   recordDecision(title, body, related) {
     const res = this.db.prepare("INSERT INTO decisions (title, body, related) VALUES (?, ?, ?)").run(title, body, related ? JSON.stringify(related) : null);
-    return Number(res.lastInsertRowid);
+    return this.decision(Number(res.lastInsertRowid));
+  }
+  decision(id) {
+    return this.db.prepare("SELECT * FROM decisions WHERE id = ?").get(id);
+  }
+  /** Every decision, oldest first. The rows survive `reset()`; the items do not. */
+  listDecisions() {
+    return this.db.prepare("SELECT * FROM decisions ORDER BY id").all();
   }
   close() {
     this.db.close();
@@ -10250,9 +10310,164 @@ var Store = class {
 import { createHash as createHash2 } from "crypto";
 import { relative as relative5 } from "path";
 
+// ../adapter-git-log/dist/index.js
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { basename as basename4, join as join7 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULTS = {
+  limit: 200,
+  maxFiles: 50,
+  maxBodyChars: 4e3,
+  includeMerges: false
+};
+var RECORD = "";
+var UNIT = "";
+var FORMAT = `${RECORD}%H${UNIT}%h${UNIT}%an${UNIT}%cI${UNIT}%s${UNIT}%b${UNIT}`;
+var ITEM_DIR = join7(".git", "commits");
+function gitLogAdapter(options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  return {
+    id: "git-log",
+    displayName: "Commit",
+    async collect(root, _env) {
+      if (!existsSync2(join7(root, ".git")))
+        return [];
+      const stdout = await runGitLog(root, opts);
+      const items = [];
+      for (const record2 of stdout.split(RECORD)) {
+        const commit = parseRecord(record2);
+        if (commit)
+          items.push(toItem(root, commit, opts));
+      }
+      return items;
+    }
+  };
+}
+async function runGitLog(root, opts) {
+  const args = [
+    "--no-pager",
+    "log",
+    `--max-count=${opts.limit}`,
+    "--name-only",
+    "--no-color",
+    `--format=${FORMAT}`
+  ];
+  if (!opts.includeMerges)
+    args.push("--no-merges");
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd: root,
+      timeout: 3e4,
+      maxBuffer: 32 * 1024 * 1024,
+      windowsHide: true
+    });
+    return stdout;
+  } catch (err) {
+    const e = err;
+    if (/does not have any commits yet|bad default revision/i.test(String(e.stderr ?? ""))) {
+      return "";
+    }
+    if (e.code === "ENOENT") {
+      throw new Error(`${root} has a .git but git is not on PATH; no commits indexed`);
+    }
+    throw new Error(`git log failed in ${root}: ${firstLine2(e.stderr) || String(err)}`);
+  }
+}
+function parseRecord(record2) {
+  if (!record2.trim())
+    return void 0;
+  const parts = record2.split(UNIT);
+  const [sha, shortSha, author, date5, subject, body] = parts;
+  if (!sha || !shortSha)
+    return void 0;
+  return {
+    sha,
+    shortSha,
+    author: author ?? "",
+    date: date5 ?? "",
+    subject: subject ?? "",
+    body: (body ?? "").trim(),
+    // Everything past the last field is the file list, one path per line.
+    files: parts.slice(6).join(UNIT).split("\n").map((l) => l.trim()).filter(Boolean)
+  };
+}
+function toItem(root, c, opts) {
+  const path = join7(root, ITEM_DIR, `${c.shortSha}.md`);
+  const files = c.files.slice(0, opts.maxFiles);
+  const hidden = c.files.length - files.length;
+  const subject = c.subject || "(no subject)";
+  return {
+    id: stableId(path),
+    format: "git-log",
+    formatLabel: "Commit",
+    name: `${c.shortSha} ${subject}`,
+    // The description becomes the provenance line of every embedded chunk,
+    // so it carries the subject, not the sha.
+    description: subject,
+    path,
+    scope: "project",
+    projectRoot: root,
+    content: renderCommit(c, subject, files, hidden, opts.maxBodyChars),
+    metadata: {
+      sha: c.sha,
+      shortSha: c.shortSha,
+      author: c.author,
+      subject,
+      files: c.files,
+      repo: basename4(root)
+    },
+    knowledge: {
+      kind: "commit",
+      updatedAt: isoDate(c.date),
+      relatedPaths: c.files.length ? c.files : void 0,
+      tags: conventionalTags(subject)
+    }
+  };
+}
+function renderCommit(c, subject, files, hidden, maxBodyChars) {
+  const body = c.body.length > maxBodyChars ? `${c.body.slice(0, maxBodyChars)}
+
+\u2026` : c.body;
+  const lines = [
+    `# ${subject}`,
+    "",
+    `commit \`${c.shortSha}\` \xB7 ${c.author} \xB7 ${c.date.slice(0, 10)}`
+  ];
+  if (body)
+    lines.push("", body);
+  if (files.length) {
+    lines.push("", "## Files", "");
+    for (const f of files)
+      lines.push(`- ${f}`);
+    if (hidden > 0)
+      lines.push(`- \u2026 and ${hidden} more`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function isoDate(raw2) {
+  if (!raw2)
+    return void 0;
+  const t = Date.parse(raw2);
+  return Number.isNaN(t) ? void 0 : new Date(t).toISOString();
+}
+var CONVENTIONAL = /^([a-z]{3,10})(?:\(([^)]{1,40})\))?!?:\s/;
+function conventionalTags(subject) {
+  const m = CONVENTIONAL.exec(subject.toLowerCase());
+  if (!m)
+    return void 0;
+  const tags = [m[1], ...m[2] ? [m[2]] : []];
+  return tags;
+}
+function firstLine2(text) {
+  return (text ?? "").split("\n").find((l) => l.trim()) ?? "";
+}
+
 // ../adapter-runbooks/dist/index.js
 import { readFile as readFile5, stat as stat3 } from "fs/promises";
-import { basename as basename4, dirname as dirname7, relative as relative3, sep as sep4 } from "path";
+import { basename as basename5, dirname as dirname7, relative as relative3, sep as sep4 } from "path";
 var DOC_DIRS = /* @__PURE__ */ new Set(["docs", "doc", "runbooks", "runbook", "wiki", "adr", "decisions"]);
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["tickets", "issues", "todo", "backlog", "plans", "plan", "roadmap", "milestones", "milestone", "node_modules"]);
 function segments(relPath) {
@@ -10283,7 +10498,7 @@ function runbooksAdapter() {
       const relPathInProject = relative3(projectRoot, entry.absPath);
       const fm = parseFrontmatter(raw2);
       const data = fm.data;
-      const title = data["title"] || firstHeading(raw2) || basename4(entry.name, ".md");
+      const title = data["title"] || firstHeading(raw2) || basename5(entry.name, ".md");
       const kindFromPath = segments(relPathInProject).some((p) => ["adr", "decisions"].includes(p.toLowerCase())) ? "decision" : "runbook";
       const tags = parseTags(data["tags"]);
       return [
@@ -10291,7 +10506,7 @@ function runbooksAdapter() {
           id: stableId(entry.absPath),
           format: "runbooks",
           formatLabel: "Runbook",
-          name: `${basename4(projectRoot)}${sep4}${relPathInProject}`,
+          name: `${basename5(projectRoot)}${sep4}${relPathInProject}`,
           description: title,
           path: entry.absPath,
           scope: "project",
@@ -10325,7 +10540,7 @@ function firstHeading(raw2) {
 
 // ../adapter-tickets/dist/index.js
 import { readFile as readFile6, stat as stat4 } from "fs/promises";
-import { basename as basename5, dirname as dirname8, relative as relative4, sep as sep5 } from "path";
+import { basename as basename6, dirname as dirname8, relative as relative4, sep as sep5 } from "path";
 var TICKET_DIRS = /* @__PURE__ */ new Set(["tickets", "issues", "todo", "backlog"]);
 var PLAN_DIRS = /* @__PURE__ */ new Set(["plans", "plan", "roadmap", "milestones", "milestone"]);
 var CHECKBOX = /^\s*[-*+]\s+\[( |x|X)\]\s+/gm;
@@ -10386,14 +10601,14 @@ function ticketsAdapter() {
       const data = fm.data;
       const derived2 = deriveStatus(raw2);
       const status = normaliseStatus(data["status"]) ?? derived2.status;
-      const title = data["title"] || firstHeading2(raw2) || basename5(entry.name, ".md");
+      const title = data["title"] || firstHeading2(raw2) || basename6(entry.name, ".md");
       const tags = parseTags2(data["tags"]);
       return [
         {
           id: stableId(entry.absPath),
           format: "tickets",
           formatLabel: isPlan ? "Plan" : "Ticket",
-          name: `${basename5(projectRoot)}${sep5}${relPathInProject}`,
+          name: `${basename6(projectRoot)}${sep5}${relPathInProject}`,
           description: title,
           path: entry.absPath,
           scope: "project",
@@ -10430,6 +10645,66 @@ function firstHeading2(raw2) {
   return void 0;
 }
 
+// ../index/dist/decision.js
+import { join as join8 } from "path";
+var ITEM_DIR2 = join8(".capsa", "decisions");
+function decisionPath(projectRoot, id) {
+  return join8(projectRoot, ITEM_DIR2, `decision-${id}.md`);
+}
+function decisionItem(projectRoot, row) {
+  const path = decisionPath(projectRoot, row.id);
+  const related = parseRelated(row.related);
+  return {
+    id: stableId(path),
+    format: "decision",
+    formatLabel: "Decision",
+    name: row.title,
+    // The description becomes the provenance line of every embedded chunk.
+    description: row.title,
+    path,
+    scope: "project",
+    projectRoot,
+    content: renderDecision(row, related),
+    metadata: { decisionId: row.id, author: row.author, createdAt: row.created_at, related },
+    knowledge: {
+      kind: "decision",
+      // Written once, never edited: the day it was made is the day it last
+      // changed, so recency ranks it from `created_at`.
+      updatedAt: row.created_at,
+      // No lifecycle to report. "unknown" is the neutral weight (1.0) and
+      // says so out loud instead of leaving the column blank.
+      status: "unknown",
+      relatedPaths: related.length ? related : void 0
+    }
+  };
+}
+function renderDecision(row, related) {
+  const lines = [
+    `# ${row.title}`,
+    "",
+    `decision \`#${row.id}\` \xB7 ${row.author} \xB7 ${row.created_at.slice(0, 10)}`,
+    "",
+    row.body.trim()
+  ];
+  if (related.length) {
+    lines.push("", "## Related", "");
+    for (const p of related)
+      lines.push(`- ${p}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function parseRelated(json2) {
+  if (!json2)
+    return [];
+  try {
+    const parsed = JSON.parse(json2);
+    return Array.isArray(parsed) ? parsed.filter((p) => typeof p === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
 // ../index/dist/indexer.js
 function knowledgeAdapters() {
   return [
@@ -10437,7 +10712,8 @@ function knowledgeAdapters() {
     claudeSkillsAdapter(),
     cursorRulesAdapter(),
     runbooksAdapter(),
-    ticketsAdapter()
+    ticketsAdapter(),
+    gitLogAdapter()
   ];
 }
 function openStore(projectRoot, embedder) {
@@ -10467,26 +10743,15 @@ async function indexProject(projectRoot, embedder, onProgress) {
       }
       if (existing)
         store.deleteItem(existing.id);
-      const chunks = chunkMarkdown(item.content);
-      const searchTexts = chunks.map((c) => withContext(item, c.headingPath, c.text));
-      const vectors = searchTexts.length ? await embedder.embed(searchTexts) : [];
-      const k = item.knowledge;
-      store.upsertItem({
-        id: item.id,
-        format: item.format,
-        kind: k?.kind ?? "instruction",
-        name: item.name,
-        path: item.path,
-        rel_path: relative5(projectRoot, item.path),
-        content_hash: hash2,
-        status: k?.status ?? null,
-        updated_at: k?.updatedAt ?? null,
-        tags: k?.tags ? JSON.stringify(k.tags) : null
-      });
-      chunks.forEach((c, i) => store.insertChunk(item.id, c.index, c.headingPath, c.text, vectors[i], searchTexts[i]));
+      await indexItem(store, embedder, item, projectRoot, hash2);
       indexed++;
       onProgress?.({ phase: "embed", scanned: items.length, indexed, skipped });
     }
+    const decisions = await indexDecisions(store, embedder, projectRoot);
+    for (const path of decisions.paths)
+      seen.add(path);
+    indexed += decisions.indexed;
+    skipped += decisions.skipped;
     let removed = 0;
     for (const row of store.listItems()) {
       if (!seen.has(row.path)) {
@@ -10495,7 +10760,7 @@ async function indexProject(projectRoot, embedder, onProgress) {
       }
     }
     const out = {
-      scanned: items.length,
+      scanned: items.length + decisions.paths.length,
       indexed,
       skipped,
       removed,
@@ -10508,6 +10773,53 @@ async function indexProject(projectRoot, embedder, onProgress) {
     store.close();
   }
 }
+async function indexDecisions(store, embedder, projectRoot) {
+  const out = { paths: [], indexed: 0, skipped: 0 };
+  for (const row of store.listDecisions()) {
+    const item = decisionItem(projectRoot, row);
+    out.paths.push(item.path);
+    const hash2 = sha1(item.content);
+    const existing = store.getItem(item.path);
+    if (existing && existing.content_hash === hash2) {
+      out.skipped++;
+      continue;
+    }
+    if (existing)
+      store.deleteItem(existing.id);
+    await indexItem(store, embedder, item, projectRoot, hash2);
+    out.indexed++;
+  }
+  return out;
+}
+async function recordDecision(store, embedder, projectRoot, input2) {
+  const row = store.recordDecision(input2.title, input2.body, input2.related);
+  const item = decisionItem(projectRoot, row);
+  try {
+    await indexItem(store, embedder, item, projectRoot, sha1(item.content));
+    return { id: row.id, indexed: true };
+  } catch (err) {
+    return { id: row.id, indexed: false, reason: err.message };
+  }
+}
+async function indexItem(store, embedder, item, projectRoot, hash2) {
+  const chunks = chunkMarkdown(item.content);
+  const searchTexts = chunks.map((c) => withContext(item, c.headingPath, c.text));
+  const vectors = searchTexts.length ? await embedder.embed(searchTexts) : [];
+  const k = item.knowledge;
+  store.upsertItem({
+    id: item.id,
+    format: item.format,
+    kind: k?.kind ?? "instruction",
+    name: item.name,
+    path: item.path,
+    rel_path: relative5(projectRoot, item.path),
+    content_hash: hash2,
+    status: k?.status ?? null,
+    updated_at: k?.updatedAt ?? null,
+    tags: k?.tags ? JSON.stringify(k.tags) : null
+  });
+  chunks.forEach((c, i) => store.insertChunk(item.id, c.index, c.headingPath, c.text, vectors[i], searchTexts[i]));
+}
 function withContext(item, headingPath, text) {
   const kind = item.knowledge?.kind ?? "instruction";
   const head = [kind, item.description ?? item.name, ...headingPath].filter(Boolean).join(" \u203A ");
@@ -10720,7 +11032,7 @@ async function retrieve(store, embedder, query, options = {}) {
   store.logContext({
     source: options.source ?? "unknown",
     query,
-    chunkIds: chunks.map((c) => c.chunkId),
+    delivered: chunks.map((c) => ({ rel_path: c.relPath, heading_path: c.headingPath, tokens: c.tokens })),
     tokensEst: tokens,
     durationMs
   });
@@ -10769,7 +11081,7 @@ function projectState(store) {
   const live = (i) => (i.kind === "ticket" || i.kind === "plan") && (i.status === "open" || i.status === "in-progress");
   const rank = (i) => i.status === "in-progress" ? 0 : 1;
   const open2 = items.filter(live).sort((a, b) => rank(a) - rank(b) || a.rel_path.localeCompare(b.rel_path)).map((i) => ({ relPath: i.rel_path, name: i.name, status: i.status ?? "unknown", updatedAt: i.updated_at }));
-  const recentlyChanged = [...items].sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "")).slice(0, 10).map((i) => ({ relPath: i.rel_path, kind: i.kind, updatedAt: i.updated_at }));
+  const recentlyChanged = items.filter((i) => i.kind !== "commit").sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "")).slice(0, 10).map((i) => ({ relPath: i.rel_path, kind: i.kind, updatedAt: i.updated_at }));
   const decisions = store.db.prepare("SELECT id, created_at, title FROM decisions ORDER BY id DESC LIMIT 10").all().map((d) => ({ id: d.id, createdAt: d.created_at, title: d.title }));
   return { counts, open: open2, recentlyChanged, decisions };
 }
@@ -40115,8 +40427,13 @@ _capsa: ${result.chunks.length} chunks, ~${result.tokensEst} tokens, ${result.du
   }, async ({ title, body, related }) => {
     const store = openStore(options.projectRoot, embedder);
     try {
-      const id = store.recordDecision(title, body, related);
-      return { content: [{ type: "text", text: `Recorded decision #${id}: ${title}` }] };
+      const { id, indexed, reason } = await recordDecision(store, embedder, options.projectRoot, {
+        title,
+        body,
+        related
+      });
+      const note = indexed ? "" : ` \u2014 not searchable yet (${reason}); run \`capsa index\` once that is fixed`;
+      return { content: [{ type: "text", text: `Recorded decision #${id}: ${title}${note}` }] };
     } finally {
       store.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yurtsever/capsa",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.6",
   "description": "Your project's knowledge in one capsule. Local-first project memory and cockpit for AI coding agents: indexes runbooks, tickets, plans and instruction files, serves the smallest relevant context over MCP.",
   "type": "module",
   "license": "MIT",