indelible-mcp 4.9.6 → 4.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "4.9.6",
+  "version": "4.9.8",
   "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

@@ -1489,6 +1489,13 @@ function appendReceipt(receipt, meta = {}) {
       trigger: meta.trigger || "interactive",
       // interactive | auto (background/hook)
       label: meta.label || null,
+      // g-363 self-reconciling ledger (Ben's ask, 2026-07-16): persist the content
+      // identity so a stranded receipt can ALWAYS be reconciled by content — even
+      // months later, after the 60-min tx-cache has pruned. This is the durable
+      // targetKey for findByContentKey; null for saves with no single content hash
+      // (e.g. session deltas). Cheap to write, and it removes the biggest
+      // "cannot learn content key" unresolvable bucket for good.
+      contentHash: receipt.contentHash ?? receipt.content_hash ?? meta.contentHash ?? null,
       surfaced: false
       // has the IDE shown this entry yet?
     };
@@ -3305,16 +3312,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 +3894,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 +3969,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 +4221,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;
@@ -4373,17 +4333,37 @@ function computeMapLayout(dated) {
   };
   const globalTF = /* @__PURE__ */ new Map();
   for (const s of dated) for (const w of grams(s.title)) globalTF.set(w, (globalTF.get(w) || 0) + 1);
-  function nameOf(members, nTerms) {
+  function nameOf(members, nTerms, allowFallback = false) {
     const tf = /* @__PURE__ */ new Map();
     for (const s of members) for (const w of grams(s.title)) tf.set(w, (tf.get(w) || 0) + 1);
-    const scored = [...tf.entries()].filter(([w, f]) => f >= 3).map(([w, f]) => [w, (w.includes(" ") ? 1.6 : 1) * f * f / (globalTF.get(w) || 1)]).sort((a, b) => b[1] - a[1]);
+    const minF = Math.min(3, Math.max(1, Math.round(members.length * 0.2)));
+    const scored = [...tf.entries()].filter(([w, f]) => f >= minF).map(([w, f]) => [w, (w.includes(" ") ? 1.6 : 1) * f * f / (globalTF.get(w) || 1)]).sort((a, b) => b[1] - a[1]);
     const picked = [];
     for (const [w] of scored) {
       if (picked.some((p) => p.includes(w) || w.includes(p))) continue;
       picked.push(w);
       if (picked.length >= nTerms) break;
     }
-    return picked.join(" \xB7 ") || "(misc)";
+    if (picked.length) return picked.join(" \xB7 ");
+    if (!allowFallback) return "(misc)";
+    let best = "";
+    let bestScore = -1;
+    for (const s of members) {
+      let sc = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (const w of grams(s.title)) {
+        if (!seen.has(w)) {
+          seen.add(w);
+          sc += (tf.get(w) || 0) / (globalTF.get(w) || 1);
+        }
+      }
+      if (sc > bestScore) {
+        bestScore = sc;
+        best = s.title || "";
+      }
+    }
+    const distinct = tok(best).sort((a, b) => (globalTF.get(a) || 1) - (globalTF.get(b) || 1)).slice(0, nTerms);
+    return distinct.length ? distinct.join(" \xB7 ") : "(untitled)";
   }
   const centroidOf = (members) => ({
     cx: members.reduce((a, s) => a + s.x, 0) / (members.length || 1),
@@ -4391,7 +4371,7 @@ function computeMapLayout(dated) {
     cz: members.reduce((a, s) => a + s.z, 0) / (members.length || 1)
   });
   function kmeansLocal(members, k) {
-    if (members.length < k * 25) return null;
+    if (members.length < k * 3) return null;
     const c0 = [members[Math.floor(rnd() * members.length)].v.slice()];
     while (c0.length < k) {
       const d = members.map((s) => Math.min(...c0.map((c) => dist2(s.v, c))));
@@ -4433,13 +4413,29 @@ function computeMapLayout(dated) {
   const subLabels = [];
   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 sub = kmeansLocal(members, 3);
+    const label = nameOf(
+      members,
+      3,
+      /* allowFallback */
+      true
+    );
+    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 subK = members.length >= 30 ? 3 : 2;
+    const subFloor = members.length >= 75 ? 25 : Math.max(4, Math.round(members.length * 0.15));
+    const sub = members.length >= 12 ? kmeansLocal(members, subK) : null;
     if (sub) {
-      for (let sc = 0; sc < 3; sc++) {
+      for (let sc = 0; sc < subK; sc++) {
         const m = members.filter((_, i) => sub[i] === sc);
-        if (m.length < 25) continue;
+        if (m.length < subFloor) continue;
         const sl = nameOf(m, 2);
         if (sl === "(misc)" || sl === label) continue;
         subLabels.push({ label: sl, count: m.length, ...centroidOf(m) });
@@ -4475,8 +4471,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 +4507,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 +4531,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 +4542,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 +4584,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 +4607,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>
@@ -4670,8 +4682,8 @@ function draw(){
   const vg=g.createRadialGradient(W/2,H/2,H*0.2,W/2,H/2,Math.max(W,H)*0.75);
   vg.addColorStop(0,'#0e0a07');vg.addColorStop(1,'#070503');g.fillStyle=vg;g.fillRect(0,0,W,H);
   projected=P.map(p=>({p,q:proj(p)}));
-  // time thread
-  g.strokeStyle='rgba(244,168,58,0.04)';g.beginPath();
+  // time thread \u2014 opacity scales with map size (a few segments need more alpha than 5,000)
+  g.strokeStyle='rgba(244,168,58,'+Math.min(0.28,Math.max(0.04,4/P.length))+')';g.beginPath();
   projected.forEach((e,i)=>{i?g.lineTo(e.q.X,e.q.Y):g.moveTo(e.q.X,e.q.Y)});g.stroke();
   // points: crisp everywhere. Heat = the DOT'S OWN color from the density ramp
   // (no additive accumulation \u2014 that both lagged and blew the core out to mush).
@@ -4731,6 +4743,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 +4874,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) {
@@ -5543,7 +5630,27 @@ async function _run({ dir, key, address, contentKey, build, broadcast, checkConf
   });
   prune(dir, now()).catch((e) => process.stderr.write(`[build-cache] prune failed (non-fatal): ${e?.message}
 `));
-  const write = await broadcast(fresh.txHex);
+  let write;
+  try {
+    write = await broadcast(fresh.txHex);
+  } catch (err) {
+    let seen = null;
+    try {
+      seen = await checkConfirmation2(fresh.txId);
+    } catch {
+    }
+    if (seen && (seen.confirmed || seen.inMempool || seen.exists === true)) {
+      process.stderr.write(`[g-363] broadcast ack failed but ${fresh.txId.slice(0, 12)}\u2026 is on-chain/mempool \u2014 slow-ack recovered, no rival (${err?.message || "timeout"})
+`);
+      return {
+        ...fresh,
+        write: { txid: fresh.txId, via: "chain-verified", source: "slow-ack-recovered", confirmed: !!seen.confirmed },
+        reused: false,
+        alreadyOnChain: true
+      };
+    }
+    throw err;
+  }
   if (write?.txid && fresh.txId && write.txid.toLowerCase() !== fresh.txId.toLowerCase()) {
     process.stderr.write(`[g-363 TRIPWIRE] bridge-computed txid ${write.txid} differs from built txid ${fresh.txId} \u2014 possible transit mutation, receipt kept as built
 `);
@@ -5800,7 +5907,7 @@ async function saveFile(filePath, options = {}) {
     }
     const chunkCount = encrypted.length <= MAX_CHUNK_SIZE ? 1 : Math.ceil(encrypted.length / MAX_CHUNK_SIZE);
     const receipt = buildReceipt(_finalWrite, { txId: masterTxId, fee: _saveFee, txSize: _finalSize });
-    appendReceipt(receipt, { trigger: "interactive", saveType: "file" });
+    appendReceipt(receipt, { trigger: "interactive", saveType: "file", contentHash: `sha256:${contentHash}` });
     return {
       success: true,
       txId: masterTxId,
@@ -7064,22 +7171,25 @@ async function findByContentKey({
   excludeTxids = [],
   maxScan = 400,
   confirmedOnly = false,
-  stopAtFirst = true
+  stopAtFirst = true,
+  matchCap = 10
 }) {
-  if (!address || !targetKey) return { matches: [], scanned: 0, truncated: false };
+  if (!address || !targetKey) return { matches: [], scanned: 0, truncated: false, fetchFailures: 0, classification: "absent" };
   const exclude = new Set(excludeTxids.map((t) => String(t).toLowerCase()));
   let history = [];
   try {
     history = await getHistory(address);
   } catch {
-    return { matches: [], scanned: 0, truncated: false, error: "history-unreachable" };
+    return { matches: [], scanned: 0, truncated: false, fetchFailures: 0, classification: "inconclusive-history-unreachable", error: "history-unreachable" };
   }
-  if (!Array.isArray(history)) return { matches: [], scanned: 0, truncated: false };
+  if (!Array.isArray(history)) return { matches: [], scanned: 0, truncated: false, fetchFailures: 0, classification: "absent" };
   const ordered = [...history].sort((a, b) => (b.height || 0) - (a.height || 0));
   const truncated = ordered.length > maxScan;
   const candidates = ordered.slice(0, maxScan);
   const matches = [];
   let scanned = 0;
+  let fetchFailures = 0;
+  let confirmedFound = false;
   for (const h of candidates) {
     const txid = (h.tx_hash || h.txid || "").toString();
     if (!txid || exclude.has(txid.toLowerCase())) continue;
@@ -7089,23 +7199,62 @@ async function findByContentKey({
     try {
       payload = await fetchPayload(txid);
     } catch {
+      fetchFailures++;
       continue;
     }
     if (payloadContentKey(payload) === targetKey) {
-      matches.push({ txid, height: h.height || null });
-      if (stopAtFirst) break;
+      const height = h.height || null;
+      matches.push({ txid, height });
+      if (height > 0) confirmedFound = true;
+      if (stopAtFirst && confirmedFound) break;
+      if (matches.length >= matchCap) break;
     }
   }
-  return { matches, scanned, truncated };
+  matches.sort((a, b) => {
+    const ac = a.height > 0 ? 1 : 0, bc = b.height > 0 ? 1 : 0;
+    if (ac !== bc) return bc - ac;
+    return (b.height || 0) - (a.height || 0);
+  });
+  const result = stopAtFirst && matches.length ? [matches[0]] : matches;
+  let classification;
+  if (result.length) classification = "found";
+  else if (truncated) classification = "inconclusive-truncated";
+  else if (fetchFailures > 0) classification = "inconclusive-fetch-degraded";
+  else classification = "absent";
+  return { matches: result, scanned, truncated, fetchFailures, classification };
 }
 
 // mcp-server/tools/load_file.js
 var TX_CACHE_DIR3 = join12(homedir12(), ".indelible", "tx-cache");
+var SAVE_LOG_PATH = join12(homedir12(), ".indelible", "save-log.jsonl");
+async function contentKeyFromSaveLog(txid) {
+  try {
+    const raw = await readFile6(SAVE_LOG_PATH, "utf-8");
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let e;
+      try {
+        e = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (e.txid === txid && e.contentHash) return String(e.contentHash).replace(/^sha256:/, "");
+    }
+  } catch {
+  }
+  return null;
+}
 async function healStrandedTxid(strandedTxId, config) {
   try {
+    let targetKey = null;
     const cachedRaw = await readFile6(join12(TX_CACHE_DIR3, `${strandedTxId.trim()}.json`), "utf-8").catch(() => null);
-    if (!cachedRaw) return null;
-    const targetKey = payloadContentKey(JSON.parse(cachedRaw));
+    if (cachedRaw) {
+      try {
+        targetKey = payloadContentKey(JSON.parse(cachedRaw));
+      } catch {
+      }
+    }
+    if (!targetKey) targetKey = await contentKeyFromSaveLog(strandedTxId.trim());
     const address = config?.address;
     if (!targetKey || !address) return null;
     const { matches } = await findByContentKey({
@@ -8302,32 +8451,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 +8561,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 +8571,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);
@@ -8373,11 +8598,11 @@ function redactSecrets2(s) {
   return redactCredentials(String(s));
 }
 async function reportBug(args2 = {}, mcpVersion) {
-  const { summary, description, severity = "medium", tool_name = null, last_error = null } = args2;
+  const { summary, description, severity = "medium", tool_name = null, last_error = null, still_file = false } = args2;
   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),
@@ -8385,6 +8610,10 @@ async function reportBug(args2 = {}, mcpVersion) {
     severity: ["low", "medium", "high"].includes(severity) ? severity : "medium",
     tool_name: tool_name ? String(tool_name).slice(0, 80) : null,
     last_error: redactSecrets2(last_error),
+    // User override: "no, my case is genuinely different." When true, the intake
+    // files a real ticket + pages the team even if the report matches a known,
+    // already-fixed issue — so a false match can never trap a real report.
+    still_file: still_file === true,
     // Machine-pulled facts (the AI cannot get these wrong)
     mcp_version: getMcpVersion(mcpVersion),
     wallet_address: getWalletAddress(config),
@@ -8404,9 +8633,17 @@ async function reportBug(args2 = {}, mcpVersion) {
     }
     const data = await resp.json().catch(() => ({}));
     if (data.known_issue) {
-      return { success: true, status: "known_issue", issue_id: data.issue_id || null, message: data.message || "Matched a known, already-fixed issue." };
+      return {
+        success: true,
+        status: "known_issue",
+        issue_id: data.issue_id || null,
+        message: data.message || "Matched a known, already-fixed issue.",
+        // The team was already notified (the intake never swallows), but if the
+        // narrative describes something genuinely different, the user can escalate.
+        override_hint: "If this does not match your situation, call report_bug again with still_file: true to open a ticket and page the team anyway."
+      };
     }
-    return { success: true, status: "filed", ticket_id: data.ticket_id || null, message: data.message || "Bug report sent to the Indelible team." };
+    return { success: true, status: "filed", ticket_id: data.ticket_id || null, forced: !!data.forced, message: data.message || "Bug report sent to the Indelible team." };
   } catch (err) {
     return { success: false, error: `could not reach intake (${err.message}). Fallback: save_file the report on-chain and share the txid.` };
   }
@@ -8647,16 +8884,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 +8944,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 +9150,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 +9164,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 +9202,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 +9218,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 +9229,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.8)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -9018,19 +9278,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 +9313,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 +9355,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 +9391,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 +9413,7 @@ function findMemoryDir() {
     } catch {
     }
   }
-  return newestProject ? join22(newestProject, "memory") : null;
+  return newestProject ? join23(newestProject, "memory") : null;
 }
 async function runPostCompactRestore() {
   await printTimeCard();
@@ -9203,10 +9463,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 +9475,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 +9492,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 +9536,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "4.9.6",
+  version: "4.9.8",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [
@@ -9579,6 +9839,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).`,
@@ -9589,7 +9862,8 @@ var TOOLS = [
         description: { type: "string", description: "What you were doing, what went wrong, and exact repro steps." },
         severity: { type: "string", enum: ["low", "medium", "high"], description: "User-facing impact." },
         tool_name: { type: "string", description: "Which Indelible tool/command failed (optional)." },
-        last_error: { type: "string", description: "The exact error string you saw (optional)." }
+        last_error: { type: "string", description: "The exact error string you saw (optional)." },
+        still_file: { type: "boolean", description: "Set true ONLY to override a known-issue match \u2014 files a ticket and pages the team even if the report looks like an already-fixed issue. Use when the user says their case is genuinely different." }
       },
       required: ["summary", "description"]
     }
@@ -9735,13 +10009,17 @@ 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,
               description: args2?.description,
               severity: args2?.severity || "medium",
               tool_name: args2?.tool_name || null,
-              last_error: args2?.last_error || null
+              last_error: args2?.last_error || null,
+              still_file: args2?.still_file === true
             });
             break;
           case "share_session":
@@ -9838,11 +10116,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 +10130,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(