indelible-mcp 4.9.6 → 4.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "4.9.6",
+  "version": "4.9.7",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -3305,16 +3305,16 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
     let resolvedHistoryPath = "~/.claude/projects/<project>/memory/session-history.md";
     try {
       const projectsDir = join10(homedir10(), ".claude", "projects");
-      const { readdirSync: readdirSync3, statSync: statSync6 } = await import("fs");
+      const { readdirSync: readdirSync3, statSync: statSync7 } = await import("fs");
       let newestProject = null;
       let newestTime = 0;
       for (const project of readdirSync3(projectsDir)) {
         const projectPath = join10(projectsDir, project);
         try {
-          if (!statSync6(projectPath).isDirectory()) continue;
+          if (!statSync7(projectPath).isDirectory()) continue;
           for (const file of readdirSync3(projectPath)) {
             if (!file.endsWith(".jsonl")) continue;
-            const fStat = statSync6(join10(projectPath, file));
+            const fStat = statSync7(join10(projectPath, file));
             if (fStat.mtimeMs > newestTime) {
               newestTime = fStat.mtimeMs;
               newestProject = projectPath;
@@ -3887,11 +3887,12 @@ __export(recall_index_exports, {
   readGaps: () => readGaps,
   readIndex: () => readIndex,
   redactSecrets: () => redactSecrets,
+  resetGaps: () => resetGaps,
   resolveSaveType: () => resolveSaveType,
   searchIndex: () => searchIndex,
   searchIndexSemantic: () => searchIndexSemantic
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync12, appendFileSync as appendFileSync3 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync8, appendFileSync as appendFileSync3 } from "fs";
 import { join as join18 } from "path";
 import { homedir as homedir15 } from "os";
 function ensureDirs() {
@@ -3961,6 +3962,33 @@ function readIndex(address) {
 function readGaps(address) {
   return readJsonlMap(gapsPath(address));
 }
+async function resetGaps(address, reasons = []) {
+  const set = new Set(reasons);
+  let removed = 0;
+  await withFileLock(gapsLock(address), () => {
+    let raw;
+    try {
+      raw = readFileSync12(gapsPath(address), "utf8");
+    } catch {
+      return;
+    }
+    const kept = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let r;
+      try {
+        r = JSON.parse(line);
+      } catch {
+        kept.push(line);
+        continue;
+      }
+      if (set.has(r.reason)) removed++;
+      else kept.push(line);
+    }
+    if (removed) writeFileSync8(gapsPath(address), kept.length ? kept.join("\n") + "\n" : "");
+  });
+  return removed;
+}
 async function appendJsonl(path, lockPath, records) {
   if (!records.length) return;
   ensureDirs();
@@ -4186,81 +4214,6 @@ var init_recall_index = __esm({
   }
 });
 
-// mcp-server/lib/semantic/fetch-pack.js
-var fetch_pack_exports = {};
-__export(fetch_pack_exports, {
-  fetchPack: () => fetchPack
-});
-import { createHash as createHash5 } from "crypto";
-import { createWriteStream, existsSync as existsSync18, mkdirSync as mkdirSync8, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
-import { join as join20 } from "path";
-async function sha256File(path) {
-  const { createReadStream: createReadStream3 } = await import("fs");
-  return new Promise((resolve3, reject) => {
-    const h = createHash5("sha256");
-    createReadStream3(path).on("data", (d) => h.update(d)).on("end", () => resolve3(h.digest("hex"))).on("error", reject);
-  });
-}
-async function fetchToTmp(url, tmpPath, timeoutMs) {
-  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), redirect: "follow" });
-  if (!res.ok || !res.body) throw new PackError("FETCH_FAIL", `HTTP ${res.status} for ${url}`);
-  const { Readable } = await import("stream");
-  const { pipeline } = await import("stream/promises");
-  await pipeline(Readable.fromWeb(res.body), createWriteStream(tmpPath));
-}
-async function fetchPack({ profile = PROFILE, timeoutMs = 3e5, onProgress = null } = {}) {
-  const dir = packDir(profile);
-  mkdirSync8(dir, { recursive: true, mode: 448 });
-  const fetched = [];
-  const skipped = [];
-  for (const f of PACK_FILES) {
-    const finalPath = join20(dir, f.name);
-    if (existsSync18(finalPath) && statSync3(finalPath).size === f.bytes) {
-      skipped.push(f.name);
-      continue;
-    }
-    const tmpPath = `${finalPath}.tmp-${process.pid}`;
-    try {
-      if (onProgress) onProgress({ file: f.name, bytes: f.bytes, state: "fetching" });
-      await fetchToTmp(f.url, tmpPath, timeoutMs);
-      const gotHash = await sha256File(tmpPath);
-      if (gotHash !== f.sha256) {
-        throw new PackError(
-          "HASH_MISMATCH",
-          `${f.name}: expected ${f.sha256.slice(0, 12)}\u2026, got ${gotHash.slice(0, 12)}\u2026 \u2014 refusing (upstream drifted or tampered)`
-        );
-      }
-      const gotSize = statSync3(tmpPath).size;
-      if (gotSize !== f.bytes) {
-        throw new PackError("HASH_MISMATCH", `${f.name}: expected ${f.bytes} bytes, got ${gotSize}`);
-      }
-      renameSync3(tmpPath, finalPath);
-      fetched.push(f.name);
-      if (onProgress) onProgress({ file: f.name, bytes: f.bytes, state: "verified" });
-    } catch (err) {
-      try {
-        rmSync(tmpPath, { force: true });
-      } catch {
-      }
-      if (err instanceof PackError) throw err;
-      throw new PackError("FETCH_FAIL", `${f.name}: ${err.message}`);
-    }
-  }
-  return { ok: true, fetched, skipped, dir };
-}
-var PackError;
-var init_fetch_pack = __esm({
-  "mcp-server/lib/semantic/fetch-pack.js"() {
-    init_manifest();
-    PackError = class extends Error {
-      constructor(code, message) {
-        super(message);
-        this.code = code;
-      }
-    };
-  }
-});
-
 // mcp-server/lib/semantic/map-model.js
 function computeMapLayout(dated) {
   const n = dated.length;
@@ -4434,7 +4387,16 @@ function computeMapLayout(dated) {
   for (let c = 0; c < K; c++) {
     const members = dated.filter((s) => s.c === c);
     const label = nameOf(members, 3);
-    clusterInfo.push({ c, label, count: members.length, ...centroidOf(members) });
+    const mDates = members.map((s) => s.date).sort();
+    clusterInfo.push({
+      c,
+      label,
+      count: members.length,
+      member_txIds: members.map((s) => s.txId),
+      first_touched: mDates.length ? mDates[0].slice(0, 10) : null,
+      last_touched: mDates.length ? mDates[mDates.length - 1].slice(0, 10) : null,
+      ...centroidOf(members)
+    });
     const sub = kmeansLocal(members, 3);
     if (sub) {
       for (let sc = 0; sc < 3; sc++) {
@@ -4475,8 +4437,15 @@ function computeMapLayout(dated) {
   }
   const hMax = Math.max(...heat);
   for (let i = 0; i < n; i++) heat[i] = Math.log1p(heat[i]) / Math.log1p(hMax);
-  const pts = dated.map((s, i) => ({ x: +s.X.toFixed(4), y: +s.Y.toFixed(4), z: +s.Z.toFixed(4), h: +heat[i].toFixed(3), m: s.date.slice(0, 7), d: s.date.slice(0, 10), t: s.title, c: s.c }));
-  const nc = (c) => ({ label: c.label, count: c.count, x: +NORM(c.cx, "x").toFixed(4), y: +NORM(c.cy, "y").toFixed(4), z: +NORM(c.cz, "z").toFixed(4) });
+  const pts = dated.map((s, i) => ({ id: s.txId, x: +s.X.toFixed(4), y: +s.Y.toFixed(4), z: +s.Z.toFixed(4), h: +heat[i].toFixed(3), m: s.date.slice(0, 7), d: s.date.slice(0, 10), t: s.title, c: s.c }));
+  const nc = (c) => ({
+    label: c.label,
+    count: c.count,
+    x: +NORM(c.cx, "x").toFixed(4),
+    y: +NORM(c.cy, "y").toFixed(4),
+    z: +NORM(c.cz, "z").toFixed(4),
+    ...c.member_txIds ? { member_txIds: c.member_txIds, first_touched: c.first_touched, last_touched: c.last_touched } : {}
+  });
   const cls = clusterInfo.map(nc);
   const subs = subLabels.map(nc);
   return {
@@ -4504,13 +4473,20 @@ var build_map_exports = {};
 __export(build_map_exports, {
   buildSemanticMap: () => buildSemanticMap
 });
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, readdirSync, statSync as statSync4 } from "node:fs";
-import { join as join21 } from "node:path";
-import { homedir as homedir17 } from "node:os";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, readdirSync, statSync as statSync3, renameSync as renameSync3 } from "node:fs";
+import { join as join19, dirname as dirname4 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+function persistModel(outPath, model) {
+  const modelPath = join19(dirname4(outPath), "SEMANTIC_MAP.json");
+  const tmp = `${modelPath}.tmp-${process.pid}`;
+  writeFileSync9(tmp, JSON.stringify({ ...model, generated_at: (/* @__PURE__ */ new Date()).toISOString() }));
+  renameSync3(tmp, modelPath);
+  return modelPath;
+}
 function buildSemanticMap({
   addr,
-  dir = join21(homedir17(), ".indelible", "recall-index"),
-  outPath = join21(homedir17(), ".indelible", "SEMANTIC_MAP.html"),
+  dir = join19(homedir16(), ".indelible", "recall-index"),
+  outPath = join19(homedir16(), ".indelible", "SEMANTIC_MAP.html"),
   log = () => {
   }
 } = {}) {
@@ -4521,7 +4497,7 @@ function buildSemanticMap({
     } catch {
       cands = [];
     }
-    const sized = cands.map((f) => ({ f, s: statSync4(join21(dir, f)).size })).sort((a, b) => b.s - a.s);
+    const sized = cands.map((f) => ({ f, s: statSync3(join19(dir, f)).size })).sort((a, b) => b.s - a.s);
     if (!sized.length) {
       const e = new Error("no .embeds.jsonl found \u2014 run `indelible-mcp semantic-fetch` first");
       e.code = "NO_INDEX";
@@ -4532,7 +4508,7 @@ function buildSemanticMap({
   log("address: " + addr);
   let embedsRaw;
   try {
-    embedsRaw = readFileSync15(join21(dir, addr + ".embeds.jsonl"), "utf8");
+    embedsRaw = readFileSync14(join19(dir, addr + ".embeds.jsonl"), "utf8");
   } catch {
     const e = new Error(`no semantic index for ${addr} \u2014 run \`indelible-mcp semantic-fetch\` first`);
     e.code = "NO_INDEX";
@@ -4574,7 +4550,7 @@ function buildSemanticMap({
   log("sessions with vectors: " + sessions.length);
   const meta = /* @__PURE__ */ new Map();
   try {
-    for (const line of readFileSync15(join21(dir, addr + ".jsonl"), "utf8").split("\n")) {
+    for (const line of readFileSync14(join19(dir, addr + ".jsonl"), "utf8").split("\n")) {
       if (!line.trim()) continue;
       let r;
       try {
@@ -4597,16 +4573,18 @@ function buildSemanticMap({
   log(`dated: ${dated.length} | span: ${span.from} \u2192 ${span.to}`);
   if (dated.length < MIN_FOR_MAP) {
     const html2 = sparsePage(addr, sessions.length, dated.length);
-    writeFileSync8(outPath, html2);
+    writeFileSync9(outPath, html2);
+    persistModel(outPath, { sparse: true, count: dated.length, span });
     log(`wrote ${outPath} (sparse floor, ${dated.length}/${MIN_FOR_MAP})`);
     return { path: outPath, sessions: sessions.length, dated: dated.length, K: 0, districts: 0, sparse: true, span };
   }
   log("PCA + k-means + density (shared compute)...");
   const model = computeMapLayout(dated);
   const html = renderHtml(model);
-  writeFileSync8(outPath, html);
-  log(`wrote ${outPath} (${Math.round(html.length / 1024)} KB)`);
-  return { path: outPath, sessions: sessions.length, dated: dated.length, K: model.K, districts: model.subs.length, sparse: false, span };
+  writeFileSync9(outPath, html);
+  const modelPath = persistModel(outPath, model);
+  log(`wrote ${outPath} (${Math.round(html.length / 1024)} KB) + ${modelPath}`);
+  return { path: outPath, modelPath, sessions: sessions.length, dated: dated.length, K: model.K, districts: model.subs.length, sparse: false, span };
 }
 function sparsePage(addr, total, dated) {
   return `<!doctype html><meta charset="utf-8"><title>Indelible \u2014 The Shape of the Work</title>
@@ -4731,6 +4709,81 @@ var init_build_map = __esm({
   }
 });
 
+// mcp-server/lib/semantic/fetch-pack.js
+var fetch_pack_exports = {};
+__export(fetch_pack_exports, {
+  fetchPack: () => fetchPack
+});
+import { createHash as createHash5 } from "crypto";
+import { createWriteStream, existsSync as existsSync19, mkdirSync as mkdirSync8, renameSync as renameSync4, rmSync, statSync as statSync5 } from "fs";
+import { join as join22 } from "path";
+async function sha256File(path) {
+  const { createReadStream: createReadStream3 } = await import("fs");
+  return new Promise((resolve3, reject) => {
+    const h = createHash5("sha256");
+    createReadStream3(path).on("data", (d) => h.update(d)).on("end", () => resolve3(h.digest("hex"))).on("error", reject);
+  });
+}
+async function fetchToTmp(url, tmpPath, timeoutMs) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), redirect: "follow" });
+  if (!res.ok || !res.body) throw new PackError("FETCH_FAIL", `HTTP ${res.status} for ${url}`);
+  const { Readable } = await import("stream");
+  const { pipeline } = await import("stream/promises");
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(tmpPath));
+}
+async function fetchPack({ profile = PROFILE, timeoutMs = 3e5, onProgress = null } = {}) {
+  const dir = packDir(profile);
+  mkdirSync8(dir, { recursive: true, mode: 448 });
+  const fetched = [];
+  const skipped = [];
+  for (const f of PACK_FILES) {
+    const finalPath = join22(dir, f.name);
+    if (existsSync19(finalPath) && statSync5(finalPath).size === f.bytes) {
+      skipped.push(f.name);
+      continue;
+    }
+    const tmpPath = `${finalPath}.tmp-${process.pid}`;
+    try {
+      if (onProgress) onProgress({ file: f.name, bytes: f.bytes, state: "fetching" });
+      await fetchToTmp(f.url, tmpPath, timeoutMs);
+      const gotHash = await sha256File(tmpPath);
+      if (gotHash !== f.sha256) {
+        throw new PackError(
+          "HASH_MISMATCH",
+          `${f.name}: expected ${f.sha256.slice(0, 12)}\u2026, got ${gotHash.slice(0, 12)}\u2026 \u2014 refusing (upstream drifted or tampered)`
+        );
+      }
+      const gotSize = statSync5(tmpPath).size;
+      if (gotSize !== f.bytes) {
+        throw new PackError("HASH_MISMATCH", `${f.name}: expected ${f.bytes} bytes, got ${gotSize}`);
+      }
+      renameSync4(tmpPath, finalPath);
+      fetched.push(f.name);
+      if (onProgress) onProgress({ file: f.name, bytes: f.bytes, state: "verified" });
+    } catch (err) {
+      try {
+        rmSync(tmpPath, { force: true });
+      } catch {
+      }
+      if (err instanceof PackError) throw err;
+      throw new PackError("FETCH_FAIL", `${f.name}: ${err.message}`);
+    }
+  }
+  return { ok: true, fetched, skipped, dir };
+}
+var PackError;
+var init_fetch_pack = __esm({
+  "mcp-server/lib/semantic/fetch-pack.js"() {
+    init_manifest();
+    PackError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
 // mcp-server/lib/timecard.js
 var timecard_exports = {};
 __export(timecard_exports, {
@@ -4787,10 +4840,10 @@ init_config_customer();
 init_api_client();
 import { createInterface as createInterface3 } from "node:readline";
 import { execSync as execSync2 } from "node:child_process";
-import { homedir as homedir18 } from "node:os";
-import { join as join22, dirname as dirname5, resolve as resolve2 } from "node:path";
+import { homedir as homedir19 } from "node:os";
+import { join as join23, dirname as dirname6, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, existsSync as existsSync19, mkdirSync as mkdirSync9, readdirSync as readdirSync2, statSync as statSync5 } from "node:fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync10, existsSync as existsSync20, mkdirSync as mkdirSync9, readdirSync as readdirSync2, statSync as statSync6 } from "node:fs";
 
 // mcp-server/lib/guardrails-run.js
 function contextFromInput(input) {
@@ -8302,32 +8355,108 @@ async function recallContext({ from_date = null, to_date = null, query = null, d
   };
 }
 
+// mcp-server/tools/map_themes.js
+init_config_customer();
+import { readFileSync as readFileSync15, existsSync as existsSync17, statSync as statSync4 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir17 } from "os";
+var MODEL_PATH = join20(homedir17(), ".indelible", "SEMANTIC_MAP.json");
+var TXIDS_OVERVIEW = 5;
+var TXIDS_DEEP = 60;
+async function mapThemes({ sample_titles = 5, sort = "size", theme = null } = {}) {
+  const config = await loadConfig();
+  const addr = config?.address;
+  if (!addr) return { success: false, error: "No wallet configured \u2014 run setup_wallet first." };
+  const indexPath2 = join20(homedir17(), ".indelible", "recall-index", `${addr}.jsonl`);
+  let fresh = false;
+  try {
+    fresh = existsSync17(MODEL_PATH) && (!existsSync17(indexPath2) || statSync4(MODEL_PATH).mtimeMs >= statSync4(indexPath2).mtimeMs);
+  } catch {
+  }
+  if (!fresh) {
+    try {
+      const { buildSemanticMap: buildSemanticMap2 } = await Promise.resolve().then(() => (init_build_map(), build_map_exports));
+      buildSemanticMap2({ addr, log: () => {
+      } });
+    } catch (e) {
+      if (e.code === "NO_INDEX") {
+        return { success: false, error: "No semantic index yet. Run `indelible-mcp semantic-fetch` once in a terminal (one-time, ~50MB, builds your index + map locally), then ask again." };
+      }
+      return { success: false, error: `Could not build the map model: ${e.message}` };
+    }
+  }
+  let model;
+  try {
+    model = JSON.parse(readFileSync15(MODEL_PATH, "utf8"));
+  } catch (e) {
+    return { success: false, error: `Could not read the map model (${e.message}) \u2014 run \`indelible-mcp map\` to regenerate it.` };
+  }
+  if (model.sparse) {
+    return { success: true, sparse: true, mapped_sessions: model.count || 0, themes: [], message: `Only ${model.count || 0} mapped sessions so far \u2014 themes appear once a couple dozen are saved. The map grows as you save.` };
+  }
+  const now = Date.now();
+  const nTitles = Math.max(0, Math.min(20, Number(sample_titles) || 5));
+  const themeFilter = theme ? String(theme).toLowerCase() : null;
+  const txidCap = themeFilter ? TXIDS_DEEP : TXIDS_OVERVIEW;
+  let themes = model.cls.map((c, i) => {
+    const members = model.pts.filter((p) => p.c === i).sort((a, b) => a.d < b.d ? 1 : -1);
+    const last = c.last_touched || members[0]?.d || null;
+    const txids = c.member_txIds ? [...c.member_txIds].reverse() : members.map((p) => p.id);
+    return {
+      theme: c.label,
+      sessions: c.count,
+      first_touched: c.first_touched || members[members.length - 1]?.d || null,
+      last_touched: last,
+      days_since_touched: last ? Math.max(0, Math.floor((now - Date.parse(last)) / 864e5)) : null,
+      sample_titles: members.slice(0, nTitles).map((p) => `${p.d} \xB7 ${p.t || "(untitled)"}`),
+      member_txids: txids.slice(0, txidCap),
+      member_txids_truncated: txids.length > txidCap ? txids.length : false
+    };
+  });
+  if (themeFilter) {
+    const matched = themes.filter((t) => t.theme.toLowerCase().includes(themeFilter));
+    if (!matched.length) {
+      return { success: false, error: `No theme matches "${theme}". Themes: ${themes.map((t) => t.theme).join(" | ")}` };
+    }
+    themes = matched;
+  }
+  themes.sort(sort === "cold" ? (a, b) => (b.days_since_touched ?? -1) - (a.days_since_touched ?? -1) : (a, b) => b.sessions - a.sessions);
+  return {
+    success: true,
+    generated_at: model.generated_at || null,
+    mapped_sessions: model.count,
+    span: model.span || null,
+    themes,
+    note: themeFilter ? 'To read this theme, call recall_context with depth:"full" and txids from member_txids (up to 20 per call, newest first).' : `Overview shows ${TXIDS_OVERVIEW} txids per theme. To drill a theme, call map_themes again with theme:"<name fragment>" for its ${TXIDS_DEEP} newest txids, then recall_context depth:"full" (\u226420 txids per call).`
+  };
+}
+
 // mcp-server/tools/report_bug.js
-import { readFileSync as readFileSync14, existsSync as existsSync17 } from "fs";
-import { join as join19, dirname as dirname4 } from "path";
-import { homedir as homedir16 } from "os";
+import { readFileSync as readFileSync16, existsSync as existsSync18 } from "fs";
+import { join as join21, dirname as dirname5 } from "path";
+import { homedir as homedir18 } from "os";
 import { fileURLToPath } from "url";
 import os from "os";
 var INTAKE_URL = process.env.INDELIBLE_BUG_INTAKE || "https://indelible.one/api/bug-report";
-var INDELIBLE_DIR = join19(homedir16(), ".indelible");
+var INDELIBLE_DIR = join21(homedir18(), ".indelible");
 function getMcpVersion(injected) {
   if (injected) return injected;
   const candidates = [];
   try {
-    candidates.push(join19(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json"));
+    candidates.push(join21(dirname5(fileURLToPath(import.meta.url)), "..", "..", "package.json"));
   } catch {
   }
   try {
-    candidates.push(join19(dirname4(fileURLToPath(import.meta.url)), "..", "package.json"));
+    candidates.push(join21(dirname5(fileURLToPath(import.meta.url)), "..", "package.json"));
   } catch {
   }
-  candidates.push(join19(homedir16(), "AppData", "Roaming", "npm", "node_modules", "indelible-mcp", "package.json"));
+  candidates.push(join21(homedir18(), "AppData", "Roaming", "npm", "node_modules", "indelible-mcp", "package.json"));
   candidates.push("/usr/local/lib/node_modules/indelible-mcp/package.json");
   candidates.push("/usr/lib/node_modules/indelible-mcp/package.json");
   for (const p of candidates) {
     try {
-      if (!existsSync17(p)) continue;
-      const pkg = JSON.parse(readFileSync14(p, "utf8"));
+      if (!existsSync18(p)) continue;
+      const pkg = JSON.parse(readFileSync16(p, "utf8"));
       if (pkg && pkg.name === "indelible-mcp" && pkg.version) return pkg.version;
     } catch {
     }
@@ -8336,7 +8465,7 @@ function getMcpVersion(injected) {
 }
 function readJson(path) {
   try {
-    return existsSync17(path) ? JSON.parse(readFileSync14(path, "utf8")) : null;
+    return existsSync18(path) ? JSON.parse(readFileSync16(path, "utf8")) : null;
   } catch {
     return null;
   }
@@ -8346,9 +8475,9 @@ function getWalletAddress(config) {
 }
 function getRecentReceipts(n = 5) {
   try {
-    const p = join19(INDELIBLE_DIR, "save-log.jsonl");
-    if (!existsSync17(p)) return [];
-    const lines = readFileSync14(p, "utf8").trim().split("\n").filter(Boolean).slice(-n);
+    const p = join21(INDELIBLE_DIR, "save-log.jsonl");
+    if (!existsSync18(p)) return [];
+    const lines = readFileSync16(p, "utf8").trim().split("\n").filter(Boolean).slice(-n);
     return lines.map((l) => {
       try {
         const e = JSON.parse(l);
@@ -8377,7 +8506,7 @@ async function reportBug(args2 = {}, mcpVersion) {
   if (!summary || !description) {
     return { success: false, error: "summary and description are required (you supply the narrative; the tool supplies the facts)." };
   }
-  const config = readJson(join19(INDELIBLE_DIR, "config.json")) || {};
+  const config = readJson(join21(INDELIBLE_DIR, "config.json")) || {};
   const payload = {
     // AI-supplied narrative (defensively redacted + length-capped)
     summary: redactSecrets2(summary).slice(0, 200),
@@ -8647,16 +8776,16 @@ init_wall_stub();
 init_wall_stub();
 init_wall_stub();
 init_wall_stub();
-var PROJECT_ROOT_FOR_CLONE_CHECK = resolve2(dirname5(fileURLToPath2(import.meta.url)), "../..");
-var CONTEXT_FILE2 = join22(homedir18(), ".indelible", "indelible-context.jsonl");
+var PROJECT_ROOT_FOR_CLONE_CHECK = resolve2(dirname6(fileURLToPath2(import.meta.url)), "../..");
+var CONTEXT_FILE2 = join23(homedir19(), ".indelible", "indelible-context.jsonl");
 function installHooks() {
-  const claudeDir = join22(homedir18(), ".claude");
-  const settingsPath = join22(claudeDir, "settings.local.json");
-  if (!existsSync19(claudeDir)) mkdirSync9(claudeDir, { recursive: true });
+  const claudeDir = join23(homedir19(), ".claude");
+  const settingsPath = join23(claudeDir, "settings.local.json");
+  if (!existsSync20(claudeDir)) mkdirSync9(claudeDir, { recursive: true });
   let settings = {};
-  if (existsSync19(settingsPath)) {
+  if (existsSync20(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync16(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync17(settingsPath, "utf8"));
     } catch {
       settings = {};
     }
@@ -8707,13 +8836,13 @@ function installHooks() {
     });
     installed.push("PreToolUse:guardrails");
   }
-  writeFileSync9(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync10(settingsPath, JSON.stringify(settings, null, 2));
   return { settingsPath, installed, alreadyInstalled: installed.length === 0 };
 }
 function runPreToolUseGuard() {
   let code = 0;
   try {
-    const raw = readFileSync16(0, "utf8").trim();
+    const raw = readFileSync17(0, "utf8").trim();
     if (!raw) process.exit(0);
     const hit = evaluate(JSON.parse(raw));
     if (hit) {
@@ -8913,6 +9042,7 @@ Commands:
       const { packPresent: packPresent2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
       const { fetchPack: fetchPack2 } = await Promise.resolve().then(() => (init_fetch_pack(), fetch_pack_exports));
       const { rebuildVectorSidecar: rebuildVectorSidecar2 } = await Promise.resolve().then(() => (init_vec_store(), vec_store_exports));
+      const { buildIndexWindow: buildIndexWindow2, resetGaps: resetGaps2 } = await Promise.resolve().then(() => (init_recall_index(), recall_index_exports));
       try {
         if (!packPresent2()) {
           console.log("Fetching the semantic model pack (~50MB, one time, hash-verified)...");
@@ -8926,15 +9056,37 @@ Commands:
           console.log(JSON.stringify({ success: false, error: "No wallet configured \u2014 run setup first." }));
           break;
         }
+        const wif = await getWif();
+        if (!wif) {
+          console.log("Wallet is locked \u2014 cannot read your history to build the map/recall index yet. Run setup_wallet to unlock, then re-run. (Pack is ready; embedding whatever is already indexed.)");
+        } else {
+          const retried = await resetGaps2(cfg.address, ["FETCH_TIMEOUT", "NOT_ON_CHAIN", "WALLET_LOCKED"]);
+          if (retried) console.log(`  re-attempting ${retried} previously-skipped sessions...`);
+          console.log(`Reading your on-chain history for ${cfg.address} (one-time, resumable, all local)...`);
+          let indexed = 0;
+          for (; ; ) {
+            const r = await buildIndexWindow2(cfg.address, wif, { maxDecrypt: 150 });
+            indexed += r.indexed;
+            console.log(`  indexed ${indexed} sessions; ${r.remaining} to go`);
+            if (r.remaining === 0 || r.indexed === 0 && r.gapped === 0) break;
+          }
+        }
         console.log(`Backfilling meaning-vectors for ${cfg.address} (resumable \u2014 re-run to continue)...`);
-        let total = 0;
+        let total = 0, cov = { vecs: 0, indexed: 0 };
         for (; ; ) {
           const r = await rebuildVectorSidecar2(cfg.address, { maxEmbed: 100 });
           total += r.embedded;
-          console.log(`  embedded ${total} sessions; remaining ${r.remaining}; coverage ${r.coverage.vecs}/${r.coverage.indexed}`);
+          cov = r.coverage || cov;
+          console.log(`  embedded ${total} sessions; remaining ${r.remaining}; coverage ${cov.vecs}/${cov.indexed}`);
           if (r.remaining === 0 || r.embedded === 0) break;
         }
-        console.log(JSON.stringify({ success: true, message: "Semantic recall enabled \u2014 meaning-based search is live in recall_context.", embedded: total }));
+        if (cov.vecs > 0) {
+          console.log(JSON.stringify({ success: true, message: "Semantic recall + map ready \u2014 run `indelible-mcp map` to see the shape of your work.", embedded: total, mapped: cov.vecs }));
+        } else if (!wif) {
+          console.log(JSON.stringify({ success: false, error: "Wallet is locked \u2014 nothing to map yet. Run setup_wallet to unlock, then re-run to build your map." }));
+        } else {
+          console.log(JSON.stringify({ success: true, message: "No saved sessions to map yet \u2014 your map grows as you save. Save a few conversations, then re-run this.", embedded: 0, mapped: 0 }));
+        }
       } catch (e) {
         console.log(JSON.stringify({ success: false, error: e.code === "HASH_MISMATCH" ? `Integrity check failed: ${e.message}` : e.message }));
       }
@@ -8942,9 +9094,9 @@ Commands:
     }
     case "map": {
       const { buildSemanticMap: buildSemanticMap2 } = await Promise.resolve().then(() => (init_build_map(), build_map_exports));
-      const { join: join23 } = await import("node:path");
-      const { homedir: homedir19 } = await import("node:os");
-      const out = join23(homedir19(), ".indelible", "SEMANTIC_MAP.html");
+      const { join: join24 } = await import("node:path");
+      const { homedir: homedir20 } = await import("node:os");
+      const out = join24(homedir20(), ".indelible", "SEMANTIC_MAP.html");
       try {
         const cfg = await loadConfig();
         const r = buildSemanticMap2({ addr: cfg?.address, outPath: out, log: (m) => process.stderr.write(`[map] ${m}
@@ -8958,7 +9110,7 @@ Commands:
   ${r.path}`);
         }
       } catch (e) {
-        if (e.code === "NO_INDEX") console.log("No semantic index yet. Run `indelible-mcp semantic-fetch` first (one-time, ~50MB, all local), then `indelible-mcp map`.");
+        if (e.code === "NO_INDEX") console.log("No map yet. Run `indelible-mcp semantic-fetch` to build it from your saved history (one-time, ~50MB, all local). If you just ran that and still see this, you have not saved any sessions yet \u2014 your map grows as you save.");
         else console.log(JSON.stringify({ success: false, error: e.message }));
       }
       break;
@@ -8969,7 +9121,7 @@ Commands:
 }
 function printHelp() {
   console.log(`
-Indelible MCP \u2014 Blockchain memory for Claude Code (v4.9.6)
+Indelible MCP \u2014 Blockchain memory for Claude Code (v4.9.7)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -9018,19 +9170,19 @@ Learn more: https://indelible.one
 `);
 }
 function findNewestTranscript() {
-  const projectsDir = join22(homedir18(), ".claude", "projects");
-  if (!existsSync19(projectsDir)) return null;
+  const projectsDir = join23(homedir19(), ".claude", "projects");
+  if (!existsSync20(projectsDir)) return null;
   let newestTime = 0;
   let newest = null;
   try {
     for (const project of readdirSync2(projectsDir)) {
-      const projectPath = join22(projectsDir, project);
+      const projectPath = join23(projectsDir, project);
       try {
-        if (!statSync5(projectPath).isDirectory()) continue;
+        if (!statSync6(projectPath).isDirectory()) continue;
         for (const file of readdirSync2(projectPath)) {
           if (!file.endsWith(".jsonl")) continue;
-          const p = join22(projectPath, file);
-          const t = statSync5(p).mtimeMs;
+          const p = join23(projectPath, file);
+          const t = statSync6(p).mtimeMs;
           if (t > newestTime) {
             newestTime = t;
             newest = p;
@@ -9053,13 +9205,13 @@ async function printTimeCard() {
     };
     try {
       const t = findNewestTranscript();
-      if (t) f.lastSeen = phraseDelta2(Date.now() - statSync5(t).mtimeMs);
+      if (t) f.lastSeen = phraseDelta2(Date.now() - statSync6(t).mtimeMs);
     } catch {
     }
     try {
-      const gPath = join22(homedir18(), ".indelible", "goals.json");
-      if (existsSync19(gPath)) {
-        const g = JSON.parse(readFileSync16(gPath, "utf8"));
+      const gPath = join23(homedir19(), ".indelible", "goals.json");
+      if (existsSync20(gPath)) {
+        const g = JSON.parse(readFileSync17(gPath, "utf8"));
         const active = (g.goals || []).filter((x) => x.status === "active");
         if (active.length) {
           const oldest = active.reduce((a, b) => new Date(a.created_at) < new Date(b.created_at) ? a : b);
@@ -9095,21 +9247,21 @@ async function runPreCompactSave() {
     process.stderr.write("Indelible: MCP disabled, skipping save\n");
     process.exit(0);
   }
-  const target = transcriptPath && existsSync19(transcriptPath) ? transcriptPath : findNewestTranscript() || CONTEXT_FILE2;
+  const target = transcriptPath && existsSync20(transcriptPath) ? transcriptPath : findNewestTranscript() || CONTEXT_FILE2;
   const result = await saveSession(target, `Auto-save before ${trigger} compaction`);
   if (result.success) {
     process.stderr.write(`Indelible: Saved ${result.newMessages} messages (${result.saveType}) tx:${result.txId?.slice(0, 12)}...
 `);
   } else if (result.gated && result.upsell) {
-    const upsellMarker = join22(homedir18(), ".indelible", ".upsell-shown");
+    const upsellMarker = join23(homedir19(), ".indelible", ".upsell-shown");
     let shownRecently = false;
     try {
-      shownRecently = Date.now() - statSync5(upsellMarker).mtimeMs < 24 * 60 * 60 * 1e3;
+      shownRecently = Date.now() - statSync6(upsellMarker).mtimeMs < 24 * 60 * 60 * 1e3;
     } catch {
     }
     if (!shownRecently) {
       try {
-        writeFileSync9(upsellMarker, (/* @__PURE__ */ new Date()).toISOString());
+        writeFileSync10(upsellMarker, (/* @__PURE__ */ new Date()).toISOString());
       } catch {
       }
       process.stderr.write("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
@@ -9131,20 +9283,20 @@ async function runPreCompactSave() {
   process.exit(0);
 }
 function findMemoryDir() {
-  const projectsDir = join22(homedir18(), ".claude", "projects");
-  if (!existsSync19(projectsDir)) return null;
+  const projectsDir = join23(homedir19(), ".claude", "projects");
+  if (!existsSync20(projectsDir)) return null;
   let newestTime = 0;
   let newestProject = null;
   const projects = readdirSync2(projectsDir);
   for (const project of projects) {
-    const projectPath = join22(projectsDir, project);
+    const projectPath = join23(projectsDir, project);
     try {
-      const pStat = statSync5(projectPath);
+      const pStat = statSync6(projectPath);
       if (!pStat.isDirectory()) continue;
       const files = readdirSync2(projectPath);
       for (const file of files) {
         if (!file.endsWith(".jsonl")) continue;
-        const fStat = statSync5(join22(projectPath, file));
+        const fStat = statSync6(join23(projectPath, file));
         if (fStat.mtimeMs > newestTime) {
           newestTime = fStat.mtimeMs;
           newestProject = projectPath;
@@ -9153,7 +9305,7 @@ function findMemoryDir() {
     } catch {
     }
   }
-  return newestProject ? join22(newestProject, "memory") : null;
+  return newestProject ? join23(newestProject, "memory") : null;
 }
 async function runPostCompactRestore() {
   await printTimeCard();
@@ -9203,10 +9355,10 @@ async function runPostCompactRestore() {
     try {
       const memoryDir = findMemoryDir();
       if (memoryDir && (config.memory_file_txid || config.session_history_txid)) {
-        if (!existsSync19(memoryDir)) mkdirSync9(memoryDir, { recursive: true });
+        if (!existsSync20(memoryDir)) mkdirSync9(memoryDir, { recursive: true });
         if (config.memory_file_txid) {
-          const memPath = join22(memoryDir, "MEMORY.md");
-          if (!existsSync19(memPath)) {
+          const memPath = join23(memoryDir, "MEMORY.md");
+          if (!existsSync20(memPath)) {
             const memResult = await loadFile(config.memory_file_txid, { outputPath: memPath });
             if (memResult.success) {
               process.stderr.write(`Indelible: MEMORY.md restored from chain (file was missing)
@@ -9215,8 +9367,8 @@ async function runPostCompactRestore() {
           }
         }
         if (config.session_history_txid) {
-          const histPath = join22(memoryDir, "session-history.md");
-          if (!existsSync19(histPath)) {
+          const histPath = join23(memoryDir, "session-history.md");
+          if (!existsSync20(histPath)) {
             const histResult = await loadFile(config.session_history_txid, { outputPath: histPath });
             if (histResult.success) {
               process.stderr.write(`Indelible: session-history.md restored from chain (file was missing)
@@ -9232,9 +9384,9 @@ async function runPostCompactRestore() {
     try {
       const histDir = findMemoryDir();
       if (histDir) {
-        const histPath = join22(histDir, "session-history.md");
-        if (existsSync19(histPath)) {
-          const histContent = readFileSync16(histPath, "utf-8");
+        const histPath = join23(histDir, "session-history.md");
+        if (existsSync20(histPath)) {
+          const histContent = readFileSync17(histPath, "utf-8");
           const lines = histContent.split("\n");
           const entryStarts = [];
           for (let i = 0; i < lines.length; i++) {
@@ -9276,7 +9428,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "4.9.6",
+  version: "4.9.7",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [
@@ -9579,6 +9731,19 @@ var TOOLS = [
       required: []
     }
   },
+  {
+    name: "map_themes",
+    description: 'The table of contents of your mind: the semantic map THEME structure as data \u2014 every theme (continent) with label, session count, first/last touched, days since touched, sample titles, and member txids. Use it to answer "what have I been working on", "which themes have gone cold", then drill into a theme with recall_context depth:"full" txids:[...member_txids] (up to 20 per call). Reads the locally persisted map model (single source with the rendered map); 100% local, nothing leaves the machine. Requires the semantic index (`indelible-mcp semantic-fetch`, one-time).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        sample_titles: { type: "number", description: "How many recent titles to include per theme (default 5, max 20)." },
+        sort: { type: "string", enum: ["size", "cold"], description: '"size" (default) = biggest themes first; "cold" = longest-untouched first.' },
+        theme: { type: "string", description: "Drill ONE theme: a fragment of its name (case-insensitive). Returns just that theme with its 60 newest member txids (the overview shows 5 per theme)." }
+      },
+      required: []
+    }
+  },
   {
     name: "report_bug",
     description: `File an ACCURATE bug report to the Indelible team. You supply ONLY the narrative (summary, description, severity, optional tool_name/last_error). The tool auto-attaches the real MCP version, wallet address, recent save receipts, and environment \u2014 so DO NOT invent versions, txids, URLs, or destinations; leave the facts to the tool. Before filing: (1) triage transients \u2014 retry "No UTXOs"/"gateway unreachable" blips (usually an unconfirmed change UTXO) before reporting; (2) do not file known/already-fixed issues (the server auto-matches these); (3) get the user's OK first. Returns status:"filed" (ticket_id) or status:"known_issue" (instant triage).`,
@@ -9735,6 +9900,9 @@ async function handleMcpRequest(request) {
               ranking: args2?.ranking || "blend"
             });
             break;
+          case "map_themes":
+            result = await mapThemes({ sample_titles: args2?.sample_titles, sort: args2?.sort || "size", theme: args2?.theme || null });
+            break;
           case "report_bug":
             result = await reportBug({
               summary: args2?.summary,
@@ -9838,11 +10006,11 @@ async function runWizard() {
     }
     let mcpOk = false;
     for (const cfgPath of [
-      join22(homedir18(), ".claude.json"),
-      join22(homedir18(), ".claude", "settings.json")
+      join23(homedir19(), ".claude.json"),
+      join23(homedir19(), ".claude", "settings.json")
     ]) {
       try {
-        const s = JSON.parse(readFileSync16(cfgPath, "utf8"));
+        const s = JSON.parse(readFileSync17(cfgPath, "utf8"));
         if (s?.mcpServers?.indelible) {
           mcpOk = true;
           break;
@@ -9852,10 +10020,10 @@ async function runWizard() {
     }
     console.log(mcpOk ? "  \u2713 MCP registered with Claude Code" : "  \u2717 MCP not registered");
     if (!mcpOk) allGood = false;
-    const hooksPath = join22(homedir18(), ".claude", "settings.local.json");
+    const hooksPath = join23(homedir19(), ".claude", "settings.local.json");
     let hooksOk = false;
     try {
-      const s = JSON.parse(readFileSync16(hooksPath, "utf8"));
+      const s = JSON.parse(readFileSync17(hooksPath, "utf8"));
       hooksOk = s?.hooks?.PreCompact?.some(
         (h) => h.hooks?.some((hh) => hh.command?.includes("indelible-mcp")) || h.command?.includes("indelible-mcp")
       ) && s?.hooks?.SessionStart?.some(