@llmnesia/mcp 0.2.10 → 0.2.12

package/README.md

@@ -160,6 +160,15 @@ the canonical conversation and active index have accepted it. Malformed input
 is kept under `inbox/quarantine/` for inspection. Older releases archived every
 successful payload and may also have left versioned indexes behind.
 
+Valid blank-text turns are retained with their message metadata. If an older
+importer quarantined a backup containing those turns, close connected MCP
+clients and run `llmnesia-mcp retry-quarantine`. The command validates each
+entire file before retrying, updates the active index, and moves successfully
+recovered originals into `inbox/recovered/` without deleting their contents.
+Files with unresolved malformed records remain quarantined. The warning clears
+on the next MCP read once no pending or quarantined files remain. This does not
+require rebuilding local history.
+
 No maintenance command is required. After an upgrade, the MCP service waits
 through a three-day compatibility window, then reclaims the historical files
 automatically while the service is ready and idle. Work is single-process,
@@ -187,6 +196,7 @@ Once registered, your MCP client gains eight tools over the corpus:
 | Tool | Purpose |
 | --- | --- |
 | `search_conversations` | Full-text search across every past conversation. Returns ranked matches with highlighted snippets. Supports `platform`, `title`, `date_from`/`date_to` filters and a `match_mode` (`any` / `all` / `phrase`) for when a wrong hit matters. |
+| `get_conversation_image` | Read a retained local raster image using the message and image index returned by `get_conversation`. No private provider URL fetching or OCR. |
 | `get_conversation` | Fetch the full transcript of one conversation by its id (the `id` field from search results). The response carries `contentFingerprint`, the current fingerprint of the returned transcript (see below). |
 | `list_conversations` | List conversations by chronology, including oldest-first for questions about the user's earliest chat. |
 | `list_recent` | List the most recently updated conversations with title, summary, and platform. |
@@ -214,7 +224,7 @@ items (`limit` can go lower):
   "items": [
     { "id": "claude:rust-borrow", "platform": "claude",
       "title": "Debugging a Rust borrow checker error",
-      "fingerprint": "fp1:9af3c0d7…" }
+      "fingerprint": "fp2:9af3c0d7…" }
   ],
   "nextCursor": "inv1.eyJzIjoi…"
 }
@@ -229,12 +239,15 @@ Cursors are opaque, they do not survive an MCP server restart, and an expired
 or unknown cursor returns a clear error telling the caller to begin a new
 scan.
 
-The fingerprint is `fp1:` followed by a SHA-256 hex digest. It covers exactly:
+Images are now included in the fingerprint. Clients comparing an older `fp1` inventory should refresh it once. Local raster copies are bounded to 2 MiB per image and 8 MiB per captured conversation. Vault sync retains URL metadata only. Protected or expired images without a retained copy need recapture or a supported bundled export.
+
+The fingerprint is `fp2:` followed by a SHA-256 hex digest. It covers exactly:
 
 - the conversation title, and the user's local alias (`localTitle`) when set;
 - every message in `msgIndex` order: its index, role, stored `text`, and
-  `formattedText` when present (because `get_conversation` prefers it, a
-  backfill that adds it changes what a caller would receive).
+  `formattedText` when present;
+- image references, metadata and retained local bytes. Image-only changes are
+  visible to an inventory client even when transcript text is unchanged.
 
 It deliberately excludes every timestamp, including the provider's
 `updatedAt`: historical imports can retain old source dates, and a genuinely
@@ -322,6 +335,7 @@ llmnesia-mcp uninstall     # remove manifests, config, client entries
 llmnesia-mcp init          # create an empty corpus
 llmnesia-mcp ingest <…>    # ingest an NDJSON backup file
 llmnesia-mcp drain         # ingest everything in <corpus>/inbox
+llmnesia-mcp retry-quarantine # repair eligible files; retain original backups
 llmnesia-mcp watch         # ingest new inbox deltas live (Ctrl+C to stop)
 llmnesia-mcp stats         # corpus summary
 llmnesia-mcp compact --dry-run # exact read-only storage/savings report

package/dist/{chunk-XRA6OJC5.js → chunk-3QDA3XWA.js}

@@ -3,7 +3,45 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   VERSION
-} from "./chunk-GLCLSBT6.js";
+} from "./chunk-SEBISBN5.js";
+
+// src/images.ts
+var MAX_BYTES = 2 * 1024 * 1024;
+function decodeImage(value) {
+  if (typeof value !== "string" || value.length > Math.ceil(MAX_BYTES * 4 / 3) + 80) return null;
+  const match = /^data:(image\/(?:png|jpeg|webp|gif));base64,([A-Za-z0-9+/]+={0,2})$/.exec(value);
+  if (!match || match[2].length % 4 !== 0) return null;
+  const bytes = Buffer.from(match[2], "base64");
+  if (!bytes.length || bytes.length > MAX_BYTES || bytes.toString("base64") !== match[2]) return null;
+  const head = bytes.toString("latin1", 0, 12);
+  const valid = match[1] === "image/png" ? head.startsWith("\x89PNG\r\n\n") : match[1] === "image/jpeg" ? head.startsWith("\xFF\xD8\xFF") : match[1] === "image/gif" ? /^GIF8[79]a/.test(head) : head.startsWith("RIFF") && head.slice(8, 12) === "WEBP";
+  if (!valid) return null;
+  return { mimeType: match[1], data: match[2] };
+}
+function normalizeImages(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 12).flatMap((raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const row = raw;
+    const dataUrl = decodeImage(row.dataUrl) ? row.dataUrl : void 0;
+    let url = "";
+    try {
+      if (typeof row.url === "string" && row.url.length <= 8e3) {
+        const parsed = new URL(row.url);
+        if (["http:", "https:"].includes(parsed.protocol)) url = parsed.href;
+      }
+    } catch {
+    }
+    if (!url && !dataUrl) return [];
+    return [{
+      url,
+      ...dataUrl ? { dataUrl } : {},
+      ...typeof row.alt === "string" ? { alt: row.alt.slice(0, 500) } : {},
+      ...typeof row.width === "number" && row.width > 0 && row.width <= 2e4 ? { width: row.width } : {},
+      ...typeof row.height === "number" && row.height > 0 && row.height <= 2e4 ? { height: row.height } : {}
+    }];
+  });
+}
 
 // src/config.ts
 import { readFileSync } from "fs";
@@ -147,6 +185,31 @@ import { dirname, join as join3 } from "path";
 import { promisify } from "util";
 import { gzip as gzipCallback, gunzip as gunzipCallback, gunzipSync } from "zlib";
 
+// src/sourceHealth.ts
+function parseSourceHealth(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const row = value;
+  if (!["claude_code", "codex", "zcode"].includes(String(row.source))) return null;
+  if (row.connection !== "connected" && row.connection !== "disconnected") return null;
+  if (!["ok", "partial", "missing", "error", "unknown"].includes(String(row.state))) return null;
+  const time = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+  if (!time(row.observedAt) || !time(row.lastAttemptAt)) return null;
+  if (row.observedAt > Date.now() + 3e5 || row.lastAttemptAt > row.observedAt) return null;
+  if (row.lastSuccessfulSyncAt !== null && (!time(row.lastSuccessfulSyncAt) || row.lastSuccessfulSyncAt > row.observedAt)) return null;
+  if (row.lastCaptureAt !== null && (!time(row.lastCaptureAt) || row.lastCaptureAt > row.observedAt)) return null;
+  if (!time(row.failedSessions)) return null;
+  return {
+    source: row.source,
+    observedAt: row.observedAt,
+    connection: row.connection,
+    state: row.state,
+    lastAttemptAt: row.lastAttemptAt,
+    lastSuccessfulSyncAt: row.lastSuccessfulSyncAt,
+    lastCaptureAt: row.lastCaptureAt,
+    failedSessions: row.failedSessions
+  };
+}
+
 // src/serialize.ts
 function canonicalizeConversation(record) {
   return {
@@ -244,6 +307,8 @@ function canonicalMessageDoc(m) {
     role: m.role,
     text: m.text
   };
+  const images = normalizeImages(m.images);
+  if (images.length) out.images = images;
   assignIfDefined(out, "formattedText", m.formattedText);
   assignIfDefined(out, "model", m.model);
   out.createdAt = m.createdAt;
@@ -403,7 +468,7 @@ var Corpus = class {
     return this.enqueueWrite(async () => {
       const canonical = canonicalizeMemory(memory);
       const file = this.paths.memoryFile(canonical.memoryId);
-      const existing = await readJsonIfExists(file);
+      const existing = await readMemoryIfExists(file);
       if (existing) {
         if (existing.source !== "agent") {
           return { memoryId: canonical.memoryId, outcome: "refused" };
@@ -418,44 +483,48 @@ var Corpus = class {
   }
   /** Read a memory by memoryId, or null when it has never been written. */
   async getMemory(memoryId) {
-    const record = await readJsonIfExists(this.paths.memoryFile(memoryId));
+    const record = await readMemoryIfExists(this.paths.memoryFile(memoryId));
     return record && record.memoryId === memoryId ? record : null;
   }
   /** Async-iterate every stored memory (used by the index rebuild). */
-  async *iterateMemories() {
+  async *iterateMemories(options = {}) {
     let files;
     try {
       files = await fs.readdir(this.paths.memoriesDir);
-    } catch {
+    } catch (error) {
+      if (options.strict) throw error;
       return;
     }
     for (const name of files.sort()) {
       if (!name.endsWith(".json")) {
         continue;
       }
-      const record = await readJsonIfExists(join3(this.paths.memoriesDir, name));
+      const file = join3(this.paths.memoriesDir, name);
+      const record = options.strict ? await readRequiredJson(file, isMemoryRecord) : await readJsonIfExists(file);
       if (record?.memoryId) {
         yield record;
       }
     }
   }
   /** Platform subdirectory names under conversations/. */
-  async listPlatforms() {
+  async listPlatforms(options = {}) {
     try {
       const entries = await fs.readdir(this.paths.conversationsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-    } catch {
+    } catch (error) {
+      if (options.strict) throw error;
       return [];
     }
   }
   /** Async-iterate every stored conversation (used by reindex + stats). */
-  async *iterate() {
-    for (const platform of await this.listPlatforms()) {
+  async *iterate(options = {}) {
+    for (const platform of await this.listPlatforms(options)) {
       const dir = this.paths.platformDir(platform);
       let files;
       try {
         files = await fs.readdir(dir);
-      } catch {
+      } catch (error) {
+        if (options.strict) throw error;
         continue;
       }
       const stems = /* @__PURE__ */ new Set();
@@ -466,7 +535,8 @@ var Corpus = class {
       for (const stem of [...stems].sort()) {
         const record = await readBestConversationFiles(
           join3(dir, `${stem}.json.gz`),
-          join3(dir, `${stem}.json`)
+          join3(dir, `${stem}.json`),
+          options.strict
         );
         if (record) {
           yield record;
@@ -581,14 +651,46 @@ var Corpus = class {
     return { conversationCount, messageCount, byPlatform };
   }
   /** Refresh meta.json's conversationCount / lastIngestAt after an ingest run. */
-  async touchIngestMeta(receipt) {
+  async touchIngestMeta(receipt, sources = {}) {
     const { conversationCount } = await this.stats();
+    const previous = (await this.readMeta())?.sourceLastIngestAt ?? {};
+    const sourceLastIngestAt = { ...previous };
+    for (const [source, at] of Object.entries(sources)) {
+      sourceLastIngestAt[source] = Math.max(previous[source] ?? 0, at);
+    }
     await this.writeMeta({
       lastIngestAt: Date.now(),
       conversationCount,
+      sourceLastIngestAt,
       ...receipt ? { lastIngestReceipt: receipt } : {}
     });
   }
+  async readSourceHealth() {
+    try {
+      const rows = JSON.parse(await fs.readFile(join3(this.paths.root, "source-health-v1.json"), "utf8"));
+      return Array.isArray(rows) ? rows.flatMap((value) => {
+        const parsed = parseSourceHealth(value);
+        return parsed ? [parsed] : [];
+      }) : [];
+    } catch {
+      return [];
+    }
+  }
+  async recordSourceHealth(value) {
+    const row = parseSourceHealth(value);
+    if (!row) return false;
+    await this.enqueueWrite(async () => {
+      const current = new Map((await this.readSourceHealth()).map((entry) => [entry.source, entry]));
+      if ((current.get(row.source)?.observedAt ?? -1) >= row.observedAt) return;
+      current.set(row.source, row);
+      await writeFileAtomic(
+        join3(this.paths.root, "source-health-v1.json"),
+        `${JSON.stringify([...current.values()])}
+`
+      );
+    });
+    return true;
+  }
   enqueueWrite(fn) {
     const run = this.writeChain.then(fn, fn);
     this.writeChain = run.then(
@@ -629,6 +731,31 @@ async function readJsonIfExists(file) {
     return null;
   }
 }
+function isConversationRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  const c = record.conversation;
+  return !!c && typeof c.docId === "string" && !!c.docId && typeof c.platform === "string" && typeof c.title === "string" && typeof c.url === "string" && Number.isFinite(c.createdAt) && Array.isArray(record.messages) && record.messages.every((m) => m && typeof m.text === "string" && typeof m.role === "string" && Number.isFinite(m.msgIndex));
+}
+function isMemoryRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const m = value;
+  return typeof m.memoryId === "string" && !!m.memoryId && typeof m.kind === "string" && typeof m.label === "string" && typeof m.text === "string" && typeof m.source === "string" && typeof m.enabled === "boolean" && typeof m.pinned === "boolean" && Number.isFinite(m.createdAt) && Number.isFinite(m.updatedAt);
+}
+async function readRequiredJson(file, validate, compressed = false) {
+  const raw = await fs.readFile(file);
+  const value = JSON.parse((compressed ? await gunzip(raw) : raw).toString("utf8"));
+  if (!validate(value)) throw new Error(`Invalid canonical record at ${file}`);
+  return value;
+}
+async function readMemoryIfExists(file) {
+  try {
+    return await readRequiredJson(file, isMemoryRecord);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
 function serializeConversation(record) {
   return `${JSON.stringify(canonicalizeConversation(record), null, 2)}
 `;
@@ -644,7 +771,19 @@ async function readCompressedConversationIfExists(file) {
     return null;
   }
 }
-async function readBestConversationFiles(compressedFile, legacyFile) {
+async function readBestConversationFiles(compressedFile, legacyFile, strict = false) {
+  if (strict) {
+    const copies = await Promise.allSettled([
+      readRequiredJson(compressedFile, isConversationRecord, true),
+      readRequiredJson(legacyFile, isConversationRecord)
+    ]);
+    const valid = copies.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+    if (valid.length > 0) return pickNewerConversation(valid[0], valid[1] ?? null);
+    throw new Error(
+      `Cannot rebuild the index: no readable conversation at ${compressedFile} or ${legacyFile}`,
+      { cause: copies.find((result) => result.status === "rejected") }
+    );
+  }
   const [compressed, legacy] = await Promise.all([
     readCompressedConversationIfExists(compressedFile),
     readPlainConversationIfExists(legacyFile)
@@ -665,6 +804,8 @@ function readBestConversationFilesSync(compressedFile, legacyFile) {
   return pickNewerConversation(compressed, legacy);
 }
 function pickNewerConversation(a, b) {
+  if (!isConversationRecord(a)) a = null;
+  if (!isConversationRecord(b)) b = null;
   if (!a) return b;
   if (!b) return a;
   const aChanged = a.conversation.corpusChangedAt ?? a.conversation.updatedAt ?? 0;
@@ -735,11 +876,15 @@ async function upsertIndexedConversation(corpus, record, index) {
     if (!saved) {
       throw new Error(`Saved conversation '${result.docId}' could not be read for indexing`);
     }
-    index.upsertConversation(saved);
+    index.upsertConversation(saved, () => {
+      const current = corpus.getFromPlatformSync(record.conversation.platform, result.docId);
+      if (!current) throw new Error(`Saved conversation '${result.docId}' could not be read for indexing`);
+      return current;
+    });
   }
   return result;
 }
-async function ingestFile(corpus, file, index) {
+async function ingestFile(corpus, file, index, options = {}) {
   const report = { ...EMPTY_REPORT };
   let current = null;
   let buffered = [];
@@ -748,7 +893,11 @@ async function ingestFile(corpus, file, index) {
       return;
     }
     const record = { conversation: current, messages: buffered };
-    const result = await upsertIndexedConversation(corpus, record, index);
+    const result = options.validateOnly ? { docId: current.docId, outcome: "skipped" } : await upsertIndexedConversation(corpus, record, index);
+    if (result.outcome !== "skipped") {
+      report.sourceLastIngestAt ??= {};
+      report.sourceLastIngestAt[record.conversation.platform] = Date.now();
+    }
     tally(report, result);
     report.conversations += 1;
     report.messages += buffered.length;
@@ -777,6 +926,12 @@ async function ingestFile(corpus, file, index) {
     if (type === "meta") {
       continue;
     }
+    if (type === "source_health") {
+      await flush();
+      const valid = options.validateOnly ? Boolean(parseSourceHealth(record.health)) : await corpus.recordSourceHealth(record.health);
+      if (!valid) report.malformedLines += 1;
+      continue;
+    }
     if (type === "conversation") {
       await flush();
       current = coerceConversation(record.conversation);
@@ -798,7 +953,9 @@ async function ingestFile(corpus, file, index) {
       } else {
         report.malformedLines += 1;
       }
+      continue;
     }
+    report.malformedLines += 1;
   }
   await flush();
   return report;
@@ -806,9 +963,34 @@ async function ingestFile(corpus, file, index) {
 async function pendingInboxFiles(corpus) {
   try {
     return (await fs2.readdir(corpus.paths.inboxDir, { withFileTypes: true })).filter((e) => e.isFile() && isNdjson(e.name)).map((e) => e.name).sort();
-  } catch {
-    return [];
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function retryQuarantine(corpus, index) {
+  await corpus.init();
+  const entries = (await fs2.readdir(corpus.paths.quarantineDir, { withFileTypes: true })).filter((entry) => entry.isFile() && isNdjson(entry.name)).map((entry) => entry.name).sort();
+  const result = { files: entries.length, recovered: 0, remaining: 0, failed: 0, archiveDir: null };
+  for (const name of entries) {
+    const src = join4(corpus.paths.quarantineDir, name);
+    try {
+      if ((await ingestFile(corpus, src, void 0, { validateOnly: true })).malformedLines > 0) continue;
+      const report = await ingestFile(corpus, src, index);
+      if (report.malformedLines > 0) continue;
+      if (!result.archiveDir) {
+        const recoveredDir = join4(corpus.paths.inboxDir, "recovered");
+        await fs2.mkdir(recoveredDir, { recursive: true, mode: 448 });
+        result.archiveDir = await fs2.mkdtemp(join4(recoveredDir, "quarantine-"));
+      }
+      await fs2.rename(src, join4(result.archiveDir, name));
+      result.recovered += 1;
+    } catch {
+      result.failed += 1;
+    }
   }
+  result.remaining = (await fs2.readdir(corpus.paths.quarantineDir, { withFileTypes: true })).filter((entry) => entry.isFile()).length;
+  return result;
 }
 async function drainInbox(corpus, index, options = {}) {
   await corpus.init();
@@ -845,7 +1027,7 @@ async function drainInbox(corpus, index, options = {}) {
       }
     }
   }
-  if (total.files > 0) {
+  if (total.conversations > 0) {
     await corpus.touchIngestMeta({
       files: total.files,
       conversations: total.conversations,
@@ -853,7 +1035,7 @@ async function drainInbox(corpus, index, options = {}) {
       malformedLines: total.malformedLines,
       discarded: total.discarded,
       quarantined: total.quarantined
-    });
+    }, total.sourceLastIngestAt);
   }
   return total;
 }
@@ -898,12 +1080,12 @@ function coerceConversation(value) {
     return null;
   }
   const c = value;
-  if (typeof c.docId !== "string" || !c.docId) {
+  if (typeof c.docId !== "string" || !c.docId || typeof c.platform !== "string" || !c.platform || typeof c.title !== "string" || typeof c.url !== "string" || typeof c.createdAt !== "number" || !Number.isFinite(c.createdAt)) {
     return null;
   }
   const conversation = { ...c };
-  if (typeof conversation.updatedAt !== "number") {
-    conversation.updatedAt = typeof conversation.contentUpdatedAt === "number" ? conversation.contentUpdatedAt : 0;
+  if (typeof conversation.updatedAt !== "number" || !Number.isFinite(conversation.updatedAt)) {
+    conversation.updatedAt = typeof conversation.contentUpdatedAt === "number" && Number.isFinite(conversation.contentUpdatedAt) ? conversation.contentUpdatedAt : 0;
   }
   return conversation;
 }
@@ -912,11 +1094,12 @@ function coerceMessage(docId, value) {
     return null;
   }
   const m = value;
-  const text = typeof m.text === "string" ? m.text : "";
-  if (!text.trim()) {
-    return null;
-  }
-  const msgIndex = typeof m.msgIndex === "number" ? m.msgIndex : 0;
+  if (!Number.isSafeInteger(m.msgIndex) || m.msgIndex < 0) return null;
+  const formattedText = typeof m.formattedText === "string" ? m.formattedText : "";
+  const text = typeof m.text === "string" && m.text.trim() ? m.text : formattedText.trim() ? formattedText : typeof m.text === "string" ? m.text : "";
+  const images = normalizeImages(m.images);
+  if (typeof m.text !== "string" && !formattedText.trim() && !images.length) return null;
+  const msgIndex = m.msgIndex;
   const message = {
     // The backup line omits msgKey; reconstruct the extension's convention.
     msgKey: `${docId}:${msgIndex}`,
@@ -924,6 +1107,7 @@ function coerceMessage(docId, value) {
     msgIndex,
     role: coerceRole(m.role),
     text,
+    ...images.length ? { images } : {},
     createdAt: typeof m.createdAt === "number" ? m.createdAt : 0,
     updatedAt: typeof m.updatedAt === "number" ? m.updatedAt : 0,
     contentHash: typeof m.contentHash === "string" ? m.contentHash : ""
@@ -954,6 +1138,10 @@ function tally(report, result) {
   }
 }
 function accumulate(total, report) {
+  for (const [source, at] of Object.entries(report.sourceLastIngestAt ?? {})) {
+    total.sourceLastIngestAt ??= {};
+    total.sourceLastIngestAt[source] = Math.max(total.sourceLastIngestAt[source] ?? 0, at);
+  }
   total.conversations += report.conversations;
   total.created += report.created;
   total.updated += report.updated;
@@ -964,18 +1152,19 @@ function accumulate(total, report) {
 
 // src/fingerprint.ts
 import { createHash as createHash2 } from "crypto";
-var FINGERPRINT_SCHEME = "fp1";
+var FINGERPRINT_SCHEME = "fp2";
 function fingerprintConversation(record) {
   const conversation = record.conversation;
   const payload = {
-    v: 1,
+    v: 2,
     title: conversation.title,
     localTitle: conversation.localTitle ?? null,
     messages: [...record.messages].sort((a, b) => a.msgIndex - b.msgIndex).map((message) => ({
       i: message.msgIndex,
       r: message.role,
       t: message.text,
-      f: message.formattedText ?? null
+      f: message.formattedText ?? null,
+      images: message.images ?? []
     }))
   };
   const digest = createHash2("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
@@ -1156,8 +1345,9 @@ var SearchIndex = class {
          FROM temp.snippet_fts WHERE snippet_fts MATCH ?`
       )
     };
-    this.stmts.selectFtsRows.setReadBigInts(true);
-    this.stmts.insertMessageRow.setReadBigInts(true);
+    for (const statement of Object.values(this.stmts)) {
+      statement.setReadBigInts(true);
+    }
   }
   /** True when the stored format version was missing or stale — caller rebuilds. */
   needsRebuild() {
@@ -1168,6 +1358,10 @@ var SearchIndex = class {
     const row = this.db.prepare("SELECT COUNT(*) AS n FROM conversations").get();
     return row.n;
   }
+  sourceSummary() {
+    return this.db.prepare(`SELECT platform AS source, COUNT(*) AS conversationCount,
+      MAX(updatedAt) AS newestConversationAt FROM conversations GROUP BY platform`).all();
+  }
   /** Number of indexed memories. */
   countMemories() {
     const row = this.db.prepare("SELECT COUNT(*) AS n FROM memories").get();
@@ -1218,7 +1412,7 @@ var SearchIndex = class {
    * because its body is async and cannot be expressed as a sync callback.
    */
   transaction(fn) {
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
       const result = fn();
       this.db.exec("COMMIT");
@@ -1228,8 +1422,8 @@ var SearchIndex = class {
       throw err;
     }
   }
-  upsertConversation(record) {
-    this.transaction(() => this.writeRecord(record));
+  upsertConversation(record, readCurrent) {
+    this.transaction(() => this.writeRecord(readCurrent ? readCurrent() : record));
   }
   upsertMemory(memory) {
     this.transaction(() => this.writeMemory(memory));
@@ -1246,18 +1440,17 @@ var SearchIndex = class {
    * reads, which the sync {@link transaction} helper cannot hold.
    */
   async rebuildFrom(corpus) {
-    this.corpus = corpus;
-    this.db.exec("DELETE FROM messages_fts; DELETE FROM message_rows; DELETE FROM conversations;");
-    this.db.exec("DELETE FROM memories_fts; DELETE FROM memories;");
     let conversations = 0;
     let memories = 0;
-    this.db.exec("BEGIN");
+    this.db.exec("BEGIN IMMEDIATE");
     try {
-      for await (const record of corpus.iterate()) {
+      this.db.exec("DELETE FROM messages_fts; DELETE FROM message_rows; DELETE FROM conversations;");
+      this.db.exec("DELETE FROM memories_fts; DELETE FROM memories;");
+      for await (const record of corpus.iterate({ strict: true })) {
         this.writeRecord(record);
         conversations += 1;
       }
-      for await (const memory of corpus.iterateMemories()) {
+      for await (const memory of corpus.iterateMemories({ strict: true })) {
         this.writeMemory(memory);
         memories += 1;
       }
@@ -1266,6 +1459,7 @@ var SearchIndex = class {
       this.db.exec("ROLLBACK");
       throw err;
     }
+    this.corpus = corpus;
     return { conversations, memories };
   }
   // Replace a conversation's index rows. Caller supplies the transaction (the
@@ -1372,7 +1566,6 @@ var SearchIndex = class {
       clauses.push("json_extract(c.providerWorkspace, '$.workspaceId') = @providerWorkspaceId");
       params.providerWorkspaceId = filters.providerWorkspaceId;
     }
-    const scanCap = Math.min(2e3, Math.max(200, limit * 40));
     const sql = `
       SELECT
         c.docId, c.platform, c.title, c.url, c.createdAt, c.updatedAt,
@@ -1385,16 +1578,18 @@ var SearchIndex = class {
       JOIN conversations c ON c.docId = m.docId
       WHERE ${clauses.join(" AND ")}
       ORDER BY bm25
-      LIMIT @scanCap
     `;
-    const rows = this.db.prepare(sql).all({ ...params, scanCap });
     const seen = /* @__PURE__ */ new Set();
+    const rows = [];
+    for (const value of this.db.prepare(sql).iterate(params)) {
+      const row = value;
+      if (seen.has(row.docId)) continue;
+      seen.add(row.docId);
+      rows.push(row);
+      if (rows.length >= limit) break;
+    }
     const hits = [];
     for (const row of rows) {
-      if (seen.has(row.docId)) {
-        continue;
-      }
-      seen.add(row.docId);
       const hit = {
         docId: row.docId,
         platform: row.platform,
@@ -1457,16 +1652,25 @@ var SearchIndex = class {
     return row ? row.value : null;
   }
   setMeta(key, value) {
-    this.db.prepare("INSERT INTO index_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+    const statement = this.db.prepare(
+      "INSERT INTO index_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    );
+    statement.setReadBigInts(true);
+    statement.run(key, value);
   }
 };
 async function openSearchIndex(corpus, options = {}) {
   await corpus.init();
   const index = new SearchIndex(corpus.paths.indexDbFile, corpus);
-  if (options.autoBuild !== false && (index.needsRebuild() || index.count() === 0 && index.countMemories() === 0)) {
-    await index.rebuildFrom(corpus);
+  try {
+    if (options.autoBuild !== false && (index.needsRebuild() || index.count() === 0 && index.countMemories() === 0)) {
+      await index.rebuildFrom(corpus);
+    }
+    return index;
+  } catch (error) {
+    index.close();
+    throw error;
   }
-  return index;
 }
 async function deleteIndexDb(dbFile) {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -2194,6 +2398,7 @@ function describeOutcome(outcome) {
 }
 
 export {
+  decodeImage,
   readNativeHostViewerExtensionId,
   resolveCorpusDir,
   staleIndexFiles,
@@ -2201,6 +2406,7 @@ export {
   upsertIndexedConversation,
   ingestFile,
   pendingInboxFiles,
+  retryQuarantine,
   drainInbox,
   fingerprintConversation,
   SearchIndex,

package/dist/{chunk-GLCLSBT6.js → chunk-SEBISBN5.js}

@@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/version.ts
-var VERSION = true ? "0.2.10" : "0.0.0-dev";
+var VERSION = true ? "0.2.12" : "0.0.0-dev";
 
 export {
   __require,

package/dist/{cli-2IIJ77ZQ.js → cli-IF63HSCG.js}

@@ -14,16 +14,17 @@ import {
   openSearchIndex,
   readAutomaticMaintenanceState,
   resolveCorpusDir,
+  retryQuarantine,
   runtimeBinDir,
   staleIndexFiles,
   uninstallRuntime
-} from "./chunk-XRA6OJC5.js";
+} from "./chunk-3QDA3XWA.js";
 import {
   VERSION,
   __commonJS,
   __require,
   __toESM
-} from "./chunk-GLCLSBT6.js";
+} from "./chunk-SEBISBN5.js";
 
 // ../node_modules/isexe/windows.js
 var require_windows = __commonJS({
@@ -3829,6 +3830,8 @@ Power-user / debugging:
   ingest <file...>     Ingest one or more NDJSON backup files into the corpus
   drain                Ingest every file in <corpus>/inbox; discard clean
                        payloads and quarantine malformed ones
+  retry-quarantine     Retry quarantined files; retain repaired originals in
+                       <corpus>/inbox/recovered (close MCP clients first)
   watch                Watch <corpus>/inbox and ingest new deltas live
   stats                Print corpus counts (conversations, messages, platforms)
   compact              Losslessly compress conversations and remove redundant
@@ -4058,6 +4061,20 @@ async function main() {
       }
       return 0;
     }
+    case "retry-quarantine": {
+      const index = await openSearchIndex(corpus);
+      try {
+        const report = await retryQuarantine(corpus, index);
+        process.stdout.write(
+          `Quarantine recovery: ${report.recovered} recovered, ${report.remaining} remaining, ${report.failed} failed.
+` + (report.archiveDir ? `Original files retained at ${report.archiveDir}
+` : "")
+        );
+        return report.remaining > 0 || report.failed > 0 ? 1 : 0;
+      } finally {
+        index.close();
+      }
+    }
     case "watch": {
       process.stdout.write(`Watching ${corpus.paths.inboxDir} for new deltas (Ctrl+C to stop)\u2026
 `);

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   VERSION
-} from "./chunk-GLCLSBT6.js";
+} from "./chunk-SEBISBN5.js";
 
 // src/nodeDownload.ts
 var NODE_DOWNLOAD_URLS = {
@@ -141,7 +141,7 @@ async function bootstrap() {
     await guideUnsupportedNodeVersion(process.versions.node);
     return 1;
   }
-  const { main } = await import("./cli-2IIJ77ZQ.js");
+  const { main } = await import("./cli-IF63HSCG.js");
   return main();
 }
 bootstrap().then((code) => {

package/dist/llmnesia-claude-host.mjs

@@ -19,11 +19,13 @@
 // without ~/.llmnesia/config.json this host is exactly as read-only as it
 // has always been for plain session indexing.
 //
-// Protocol v4 (extension → host). v1 was Claude-Code-only: `list` carried no
+// Protocol v5 (extension → host). v1 was Claude-Code-only: `list` carried no
 // `source` and `get` took a bare sessionId. Both remain accepted, so an
 // extension older than this host keeps working; an extension NEWER than the
 // host detects v1 from the pong and syncs Claude Code only.
 //
+// v5 adds per-source listing health and putSourceHealth metadata updates,
+// keeping diagnostics separate from the conversation inbox.
 // v4 adds ZCode to `list`/`get` (the first source backed by a SQLite database
 // rather than per-session files; `get` materializes the transcript as JSONL).
 // The version is informational in both directions, as below: a v3 host never
@@ -34,7 +36,7 @@
 // treats that as "nothing to fetch", so the version is informational: hosts are
 // installed out of band and an extension upgraded ahead of its host is the
 // ordinary case, not a fault.
-//   { cmd: "ping" }                    → { type: "pong", version: 4 }
+//   { cmd: "ping" }                    → { type: "pong", version: 5 }
 //   { cmd: "list" }                    → { type: "list", sessions:
 //                                          [{source, sessionId, mtime, project?, title?}] }
 //   { cmd: "get", source, sessionId }  → one or more { type: "chunk", sessionId, seq, total, data }
@@ -59,10 +61,10 @@ import { chmod, mkdir, readdir, readFile, rename, stat, writeFile } from "node:f
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-// 4 adds ZCode (see the protocol comment above). Do not make it a gate: hosts
+// 5 adds per-source listing health (see the protocol comment above). Do not make it a gate: hosts
 // are installed out of band and a version check would strand every user who
 // upgraded the extension first.
-const PROTOCOL_VERSION = 4;
+const PROTOCOL_VERSION = 5;
 const PROJECTS_DIR = join(homedir(), ".claude", "projects");
 // ZCode keeps every session in one SQLite database (WAL mode) — the first
 // source with no per-session file. The host opens it READ-ONLY and materializes
@@ -134,12 +136,13 @@ function send(message) {
 // One entry per session: { source, sessionId, mtime, project?, title?, path }.
 // `path` is stripped before anything goes on the wire.
 
-async function listClaudeCodeSessions() {
+async function listClaudeCodeSessions(issues) {
   const sessions = [];
   let projectDirs;
   try {
     projectDirs = await readdir(PROJECTS_DIR, { withFileTypes: true });
   } catch {
+    if (issues) issues.failed += 1;
     return sessions; // no ~/.claude/projects yet
   }
   for (const entry of projectDirs) {
@@ -151,6 +154,7 @@ async function listClaudeCodeSessions() {
     try {
       files = await readdir(dir);
     } catch {
+      if (issues) issues.failed += 1;
       continue;
     }
     for (const file of files) {
@@ -168,6 +172,7 @@ async function listClaudeCodeSessions() {
           path
         });
       } catch {
+        if (issues) issues.failed += 1;
         // Skip unreadable files.
       }
     }
@@ -186,18 +191,19 @@ function codexSessionId(filename) {
   return match ? match[1].toLowerCase() : base;
 }
 
-async function walkCodexDir(dir, depth, out) {
+async function walkCodexDir(dir, depth, out, issues) {
   let entries;
   try {
     entries = await readdir(dir, { withFileTypes: true });
   } catch {
+    if (issues) issues.failed += 1;
     return out; // missing or unreadable — nothing to add
   }
   for (const entry of entries) {
     const path = join(dir, entry.name);
     if (entry.isDirectory()) {
       if (depth > 0) {
-        await walkCodexDir(path, depth - 1, out);
+        await walkCodexDir(path, depth - 1, out, issues);
       }
       continue;
     }
@@ -213,6 +219,7 @@ async function walkCodexDir(dir, depth, out) {
         path
       });
     } catch {
+      if (issues) issues.failed += 1;
       // Skip unreadable files.
     }
   }
@@ -249,8 +256,8 @@ async function readCodexThreadNames(codexHome) {
   return titles;
 }
 
-async function listCodexSessions(codexHome) {
-  const sessions = await walkCodexDir(join(codexHome, "sessions"), CODEX_MAX_DEPTH, []);
+async function listCodexSessions(codexHome, issues) {
+  const sessions = await walkCodexDir(join(codexHome, "sessions"), CODEX_MAX_DEPTH, [], issues);
   if (sessions.length === 0) {
     return sessions;
   }
@@ -299,9 +306,10 @@ async function openZcodeDb() {
  * title ("New Session"); only real titles are attached, so the extension's
  * derived "<project> · <first prompt>" still wins when ZCode has no name.
  */
-async function listZcodeSessions() {
+async function listZcodeSessions(issues) {
   const db = await openZcodeDb();
   if (!db) {
+    if (issues) issues.failed += 1;
     return [];
   }
   try {
@@ -331,6 +339,7 @@ async function listZcodeSessions() {
     }
     return sessions;
   } catch {
+    if (issues) issues.failed += 1;
     return []; // unreadable or mid-migration database — ZCode contributes nothing
   } finally {
     db.close();
@@ -467,6 +476,36 @@ async function listSessions() {
   return [...claude, ...codex, ...zcode];
 }
 
+// A missing root and an unreadable source must not both appear as a healthy,
+// empty scan. Paths and transcript data never enter these diagnostics.
+async function listSessionsWithHealth() {
+  const config = await loadConfig();
+  const codexHome = config?.codexHome || DEFAULT_CODEX_HOME;
+  const sources = [
+    ["claude_code", PROJECTS_DIR, (issues) => listClaudeCodeSessions(issues)],
+    ["codex", join(codexHome, "sessions"), (issues) => listCodexSessions(codexHome, issues)],
+    ["zcode", ZCODE_DB, (issues) => listZcodeSessions(issues)]
+  ];
+  const sessions = [];
+  const sourceStatus = {};
+  for (const [source, path, list] of sources) {
+    try {
+      await stat(path);
+    } catch (error) {
+      sourceStatus[source] = { state: error?.code === "ENOENT" ? "missing" : "error" };
+      continue;
+    }
+    const issues = { failed: 0 };
+    try {
+      sessions.push(...await list(issues));
+      sourceStatus[source] = { state: issues.failed > 0 ? "partial" : "ok" };
+    } catch {
+      sourceStatus[source] = { state: "error" };
+    }
+  }
+  return { sessions, sourceStatus };
+}
+
 async function loadConfig() {
   try {
     const raw = await readFile(CONFIG_FILE, "utf8");
@@ -648,6 +687,43 @@ async function readCorpusMemories(corpusRoot) {
   return { memories, skipped };
 }
 
+// A separate metadata channel keeps health heartbeats out of the conversation
+// inbox. Older MCP readers ignore this file and keep their true data age.
+function sourceHealthRow(value) {
+  if (!value || typeof value !== "object") return null;
+  const { source, observedAt, connection, state, lastAttemptAt, lastSuccessfulSyncAt, lastCaptureAt, failedSessions } = value;
+  const time = (v) => Number.isSafeInteger(v) && v >= 0;
+  if (!["claude_code", "codex", "zcode"].includes(source) || !["connected", "disconnected"].includes(connection) ||
+      !["ok", "partial", "missing", "error", "unknown"].includes(state) || !time(observedAt) ||
+      observedAt > Date.now() + 300000 || !time(lastAttemptAt) || lastAttemptAt > observedAt ||
+      (lastSuccessfulSyncAt !== null && (!time(lastSuccessfulSyncAt) || lastSuccessfulSyncAt > observedAt)) ||
+      (lastCaptureAt !== null && (!time(lastCaptureAt) || lastCaptureAt > observedAt)) || !time(failedSessions)) return null;
+  return { source, observedAt, connection, state, lastAttemptAt, lastSuccessfulSyncAt, lastCaptureAt, failedSessions };
+}
+
+async function handleSourceHealth(message) {
+  const config = await loadConfig();
+  if (!config?.corpusRoot || !Array.isArray(message.rows) || message.rows.length > 3) {
+    send({ type: "error", error: "source health: invalid rows or no corpus configured" }); return;
+  }
+  const rows = message.rows.map(sourceHealthRow);
+  if (rows.some((row) => !row)) {
+    send({ type: "error", error: "source health: invalid report" }); return;
+  }
+  const path = join(config.corpusRoot, "source-health-v1.json");
+  let previous = [];
+  try { previous = JSON.parse(await readFile(path, "utf8")); } catch { /* First report. */ }
+  const current = new Map((Array.isArray(previous) ? previous : []).map(sourceHealthRow).filter(Boolean).map((row) => [row.source, row]));
+  for (const row of rows) {
+    if ((current.get(row.source)?.observedAt ?? -1) < row.observedAt) current.set(row.source, row);
+  }
+  await mkdir(config.corpusRoot, { recursive: true, mode: 0o700 });
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile(temp, JSON.stringify([...current.values()]) + "\n", { mode: FILE_MODE });
+  await rename(temp, path);
+  send({ type: "sourceHealthAck" });
+}
+
 async function handle(message) {
   if (!message || typeof message !== "object") {
     return;
@@ -662,7 +738,11 @@ async function handle(message) {
       send({ type: "corpusInfo", present: false });
       return;
     }
-    send({ type: "corpusInfo", present: true, root: config.corpusRoot });
+    send({ type: "corpusInfo", present: true, root: config.corpusRoot, sourceHealthSupported: true });
+    return;
+  }
+  if (message.cmd === "putSourceHealth") {
+    await handleSourceHealth(message);
     return;
   }
   if (message.cmd === "putChunk") {
@@ -680,8 +760,8 @@ async function handle(message) {
     return;
   }
   if (message.cmd === "list") {
-    const sessions = await listSessions();
-    send({ type: "list", sessions: sessions.map(({ path, ...rest }) => rest) });
+    const { sessions, sourceStatus } = await listSessionsWithHealth();
+    send({ type: "list", sessions: sessions.map(({ path, ...rest }) => rest), sourceStatus });
     return;
   }
   if (message.cmd === "get") {

package/dist/mcp.js

@@ -4,6 +4,7 @@ const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   AUTO_MAINTENANCE_RECHECK_MS,
   Corpus,
+  decodeImage,
   describeOutcome,
   drainInbox,
   fingerprintConversation,
@@ -14,13 +15,13 @@ import {
   runAutomaticMaintenance,
   scheduleSelfUpdate,
   upsertIndexedConversation
-} from "./chunk-XRA6OJC5.js";
+} from "./chunk-3QDA3XWA.js";
 import {
   VERSION,
   __commonJS,
   __export,
   __toESM
-} from "./chunk-GLCLSBT6.js";
+} from "./chunk-SEBISBN5.js";
 
 // ../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -6891,12 +6892,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs, exportName) {
+    function addFormats(ajv, list, fs2, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs[f]);
+        ajv.addFormat(f, fs2[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -21143,6 +21144,9 @@ import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 import path from "path";
 
+// src/service.ts
+import { promises as fs } from "fs";
+
 // src/inventory.ts
 import { randomBytes } from "crypto";
 var InventoryCursorError = class extends Error {
@@ -21501,6 +21505,7 @@ function describeIssues(error2) {
 
 // src/service.ts
 var STALE_AFTER_HOURS = 48;
+var LOCAL_HEALTH_STALE_MS = 45 * 6e4;
 var AUTO_MAINTENANCE_START_DELAY_MS = 6e4;
 var AUTO_MAINTENANCE_IDLE_MS = 3e4;
 var AUTO_MAINTENANCE_BUSY_RETRY_MS = 3e4;
@@ -21522,6 +21527,8 @@ var CompanionService = class _CompanionService {
   inventoryScanner = new InventoryScanner(() => this.index.inventoryRows());
   /** Memories written since this process started; the per-session cap counts these. */
   memoriesWritten = 0;
+  memoryWriteChain = Promise.resolve();
+  indexSync;
   activeOperations = 0;
   lastOperationAt = Date.now();
   maintenanceTimer;
@@ -21617,16 +21624,27 @@ var CompanionService = class _CompanionService {
     return run;
   }
   async drainPending() {
+    let pendingFiles = null;
+    let quarantinedFiles = this.indexSync?.quarantinedFiles ?? 0;
     try {
-      if ((await pendingInboxFiles(this.corpus)).length === 0) {
-        return;
+      pendingFiles = (await pendingInboxFiles(this.corpus)).length;
+      let failed = 0;
+      if (pendingFiles > 0) {
+        const report = await drainInbox(this.corpus, this.index, {
+          onFileError: (name, error2) => this.onDrainError(new Error(`inbox file ${name} could not be ingested`, { cause: error2 }))
+        });
+        failed = report.failed;
+        pendingFiles = (await pendingInboxFiles(this.corpus)).length;
       }
-      await drainInbox(this.corpus, this.index, {
-        // Per-file failures no longer abort the drain, so surface them here or
-        // they would pass silently — the outer catch only sees a fatal drain.
-        onFileError: (name, error2) => this.onDrainError(new Error(`inbox file ${name} could not be ingested`, { cause: error2 }))
-      });
+      try {
+        quarantinedFiles = (await fs.readdir(this.corpus.paths.quarantineDir, { withFileTypes: true })).filter((entry) => entry.isFile()).length;
+      } catch (error2) {
+        if (error2.code !== "ENOENT") throw error2;
+        quarantinedFiles = 0;
+      }
+      this.indexSync = failed > 0 || pendingFiles > 0 || quarantinedFiles > 0 ? { state: "error", pendingFiles, quarantinedFiles, lastFailureAt: Date.now() } : void 0;
     } catch (error2) {
+      this.indexSync = { state: "error", pendingFiles, quarantinedFiles, lastFailureAt: Date.now() };
       this.onDrainError(error2);
     }
   }
@@ -21634,7 +21652,8 @@ var CompanionService = class _CompanionService {
     await this.refresh();
     return this.index.search(query, filters);
   }
-  getConversation(docId) {
+  async getConversation(docId) {
+    await this.refresh();
     return this.corpus.get(docId);
   }
   /**
@@ -21680,6 +21699,44 @@ var CompanionService = class _CompanionService {
       await this.refresh();
     }
     const meta = await this.corpus.readMeta();
+    const health = new Map((await this.corpus.readSourceHealth()).map((row) => [row.source, row]));
+    const sources = {};
+    const sourceWarnings = {};
+    for (const row of this.index.sourceSummary()) {
+      sources[row.source] = {
+        conversationCount: row.conversationCount,
+        newestConversationAt: row.newestConversationAt,
+        lastIngestAt: meta?.sourceLastIngestAt?.[row.source] ?? null
+      };
+    }
+    for (const source of ["claude_code", "codex", "zcode"]) {
+      const row = health.get(source);
+      const summary = sources[source] ??= { conversationCount: 0, newestConversationAt: null, lastIngestAt: null };
+      const stale = row ? Date.now() - row.observedAt > LOCAL_HEALTH_STALE_MS : false;
+      summary.localSync = {
+        connection: !row || stale ? "unknown" : row.connection,
+        state: row?.state ?? "unknown",
+        lastStatusAt: row?.observedAt ?? null,
+        lastAttemptAt: row?.lastAttemptAt ?? null,
+        lastSuccessfulSyncAt: row?.lastSuccessfulSyncAt ?? null,
+        lastCaptureAt: row?.lastCaptureAt ?? null,
+        failedSessions: row?.failedSessions ?? 0,
+        freshness: !row ? "unknown" : stale ? "stale" : "fresh"
+      };
+      if (!row && summary.conversationCount > 0) {
+        sourceWarnings[source] = "No local-session sync diagnostics are available. Recent browser capture does not prove this source is current; update the extension and helper.";
+      } else if (stale && (summary.conversationCount > 0 || row?.lastSuccessfulSyncAt != null)) {
+        sourceWarnings[source] = "Local-session sync diagnostics have not arrived for over 45 minutes. The browser or helper may be offline; recent browser data does not prove this source is current.";
+      } else if (row?.connection === "disconnected") {
+        sourceWarnings[source] = "The local-session helper was disconnected at its last check. Check the helper and native messaging permission; automatic sync can resume when access is restored.";
+      } else if (row && (row.state === "partial" || row.state === "error")) {
+        sourceWarnings[source] = "The latest local-session scan had errors; this source may be missing sessions.";
+      } else if (row?.state === "missing" && (summary.conversationCount > 0 || row.lastCaptureAt !== null)) {
+        sourceWarnings[source] = "The helper can no longer find this source's session storage.";
+      } else if (row?.state === "unknown" && summary.conversationCount > 0) {
+        sourceWarnings[source] = "The helper is reachable but cannot confirm source health. Update the helper for per-source diagnostics.";
+      }
+    }
     const lastIngestAt = meta?.lastIngestAt ?? null;
     const hoursSinceIngest = lastIngestAt === null ? null : Math.round((Date.now() - lastIngestAt) / 36e5 * 10) / 10;
     const status = {
@@ -21690,7 +21747,8 @@ var CompanionService = class _CompanionService {
       conversationCount: this.index.count(),
       lastIngestAt,
       hoursSinceIngest,
-      newestConversationAt: this.index.listRecent(1)[0]?.updatedAt ?? null
+      newestConversationAt: this.index.listRecent(1)[0]?.updatedAt ?? null,
+      sources
     };
     if (hoursSinceIngest === null && status.conversationCount === 0) {
       status.staleWarning = "This corpus is empty and has never received browser data, so searches here will return nothing until setup finishes. The browser extension is what fills it; the connector on its own cannot. If the extension is not installed, get it from https://llmnesia.com. If it is installed, check that it is version 0.3.0 or newer, since older versions have no desktop connection at all; that both steps under Full settings \u2192 Connect desktop AI are complete, including `npx -y @llmnesia/mcp@latest install`; and that the browser has been fully quit and reopened since automatic sync was enabled.";
@@ -21699,6 +21757,17 @@ var CompanionService = class _CompanionService {
     } else if (hoursSinceIngest >= STALE_AFTER_HOURS) {
       status.staleWarning = `No browser data has reached this corpus in ${hoursSinceIngest}h. Either the user has not chatted since then, or the extension to corpus sync is broken, so results may be missing recent conversations.`;
     }
+    if (Object.keys(sourceWarnings).length > 0) {
+      status.sourceWarnings = sourceWarnings;
+      status.staleWarning = [status.staleWarning, ...Object.entries(sourceWarnings).map(([source, warning]) => `${source}: ${warning}`)].filter(Boolean).join("\n");
+    }
+    if (this.indexSync) {
+      status.indexSync = { ...this.indexSync };
+      status.staleWarning = [
+        status.staleWarning,
+        `Local indexing is incomplete (${this.indexSync.pendingFiles ?? "unknown"} queued files, ${this.indexSync.quarantinedFiles} quarantined files). Search and inventory may omit recent changes. Queued files will be retried on the next read; quarantined files need repair.`
+      ].filter(Boolean).join("\n");
+    }
     return status;
   }
   /** Validate, normalize, persist to the corpus, and index — the write path. */
@@ -21716,10 +21785,16 @@ var CompanionService = class _CompanionService {
    * this path may not touch. A memory that was already stored is not an error,
    * it is the dedupe working.
    */
-  async saveMemory(payload) {
+  saveMemory(payload) {
+    const run = this.memoryWriteChain.then(() => this.saveMemorySerial(payload));
+    this.memoryWriteChain = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async saveMemorySerial(payload) {
     const input = parseSaveMemoryInput(payload);
     const memory = normalizeMemoryInput(input);
-    if (this.memoriesWritten >= this.memoryWriteCap) {
+    const existing = await this.corpus.getMemory(memory.memoryId);
+    if (!existing && this.memoriesWritten >= this.memoryWriteCap) {
       throw new MemoryWriteCapError(
         `save_memory has already stored ${this.memoryWriteCap} memories in this session, which is the limit. Every stored memory competes for the same review queue and prompt budget, so keep the rest for the next session and record only the single most durable conclusion if one is left.`
       );
@@ -21732,8 +21807,10 @@ var CompanionService = class _CompanionService {
     }
     if (result.outcome === "created") {
       this.memoriesWritten += 1;
-      this.index.upsertMemory(memory);
     }
+    const saved = await this.corpus.getMemory(result.memoryId);
+    if (!saved) throw new Error(`Saved memory '${result.memoryId}' could not be read for indexing`);
+    this.index.upsertMemory(saved);
     return {
       memoryId: result.memoryId,
       outcome: result.outcome,
@@ -21831,6 +21908,7 @@ function corpusField(status) {
     lastIngestAt: status.lastIngestAt,
     hoursSinceIngest: status.hoursSinceIngest,
     conversationCount: status.conversationCount,
+    ...status.indexSync ? { indexSync: status.indexSync } : {},
     ...status.staleWarning ? { staleWarning: status.staleWarning } : {}
   };
 }
@@ -21957,7 +22035,7 @@ async function runServe() {
     "get_conversation",
     {
       title: "Get conversation",
-      description: "Return the full transcript of one conversation by its id (the `id` from search results). The conversation includes `sourceUrl`: its original-chat URL when available, otherwise a clickable HTTPS hand-off to its local LLMnesia Viewer. Always link it in an answer based on this transcript.",
+      description: "Return the full transcript of one conversation by its id (the `id` from search results). The conversation includes `sourceUrl`: its original-chat URL when available, otherwise a clickable HTTPS hand-off to its local LLMnesia Viewer. Always link it in an answer based on this transcript. Image metadata includes imageIndex and locallyAvailable; use get_conversation_image for retained bytes.",
       inputSchema: {
         id: external_exports.string().describe("The conversation id (docId), e.g. 'claude:abc-123'.")
       },
@@ -21989,11 +22067,36 @@ async function runServe() {
           role: m.role,
           ...m.model ? { model: m.model } : {},
           // Prefer the block-formatted copy; fall back to the search-collapsed text.
-          text: m.formattedText ?? m.text
+          text: m.formattedText ?? m.text,
+          ...m.images?.length ? { images: m.images.map((image, index) => ({
+            imageIndex: index,
+            url: image.url,
+            ...image.alt ? { alt: image.alt } : {},
+            locallyAvailable: decodeImage(image.dataUrl) !== null,
+            ...image.width ? { width: image.width } : {},
+            ...image.height ? { height: image.height } : {}
+          })) } : {}
         }))
       });
     })
   );
+  server.registerTool(
+    "get_conversation_image",
+    {
+      title: "Get conversation image",
+      description: "Return a retained local image from a conversation turn. Use the message index and imageIndex from get_conversation. Reads saved raster bytes only; no provider fetch or OCR.",
+      inputSchema: { id: external_exports.string(), messageIndex: external_exports.number().int().nonnegative(), imageIndex: external_exports.number().int().nonnegative() },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    async (args) => withService(async (service2) => {
+      const record2 = await service2.getConversation(args.id);
+      const image = record2?.messages.find((message) => message.msgIndex === args.messageIndex)?.images?.[args.imageIndex];
+      if (!image) return errorResult("No image found at that conversation/message/image index.");
+      const decoded = decodeImage(image.dataUrl);
+      if (!decoded) return errorResult("Only a provider URL was captured for this image. Reopen the original chat or import an export containing the image to retain a local copy. MCP does not fetch private provider URLs.");
+      return { content: [{ type: "image", ...decoded }] };
+    })
+  );
   server.registerTool(
     "list_recent",
     {
@@ -22103,6 +22206,7 @@ async function runServe() {
       try {
         const page = await service2.inventoryPage({ cursor: args.cursor, limit: args.limit });
         const payload = {
+          corpus: corpusField(await service2.corpusStatus({ refresh: false })),
           count: page.items.length,
           total: page.total,
           scanStartedAt: page.scanStartedAt,
@@ -22124,7 +22228,7 @@ async function runServe() {
     "corpus_status",
     {
       title: "Corpus status",
-      description: "Report how current the local corpus is: when browser data last reached it, how many conversations it holds, and the newest conversation it knows about. Use this when a conversation the user is sure they had cannot be found, to tell a genuinely missing chat apart from a corpus that has stopped receiving updates from the browser extension.",
+      description: "Report how current the local corpus is: when browser data last reached it, how many conversations it holds, and the newest conversation it knows about. The sources field includes per-source arrival times and local-session sync health. Check sourceWarnings: recent browser data must not be treated as proof that local agent sessions are current. Use this when a conversation the user is sure they had cannot be found, to tell a genuinely missing chat apart from a corpus that has stopped receiving updates from the browser extension.",
       inputSchema: {},
       annotations: {
         readOnlyHint: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmnesia/mcp",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "private": false,
   "type": "module",
   "comment:mcpName": "The MCP Registry's ownership marker: it must equal server.json's `name`, and the namespace must match how you authenticate with mcp-publisher. `com.llmnesia/...` requires DNS auth (a TXT record on llmnesia.com) — see docs/MCP_INSTALLER_BOARD.md.",

package/server.json

@@ -3,13 +3,13 @@
   "name": "com.llmnesia/mcp",
   "title": "LLMnesia",
   "description": "Search your AI chat history from Claude, Cursor, Codex, and other MCP clients.",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@llmnesia/mcp",
-      "version": "0.2.10",
+      "version": "0.2.12",
       "transport": {
         "type": "stdio"
       }