@llmnesia/mcp 0.1.13 → 0.1.14

package/dist/{chunk-3JQ7CGCP.js → chunk-JS2GFGNW.js}

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
+import {
+  VERSION
+} from "./chunk-QGVH3T5W.js";
 
 // src/config.ts
 import { readFileSync } from "fs";
@@ -102,6 +105,7 @@ function canonicalConversationDoc(c) {
     createdAt: c.createdAt,
     contentUpdatedAt: c.contentUpdatedAt,
     indexedAt: c.indexedAt,
+    corpusChangedAt: c.corpusChangedAt,
     updatedAt: c.updatedAt,
     lastSeenAt: c.lastSeenAt,
     messageCount: c.messageCount,
@@ -207,10 +211,10 @@ var Corpus = class {
 `);
   }
   /**
-   * Insert or replace a conversation, keyed on docId with last-write-wins by
-   * `conversation.updatedAt`. A stale write (older updatedAt than what's on
-   * disk) is a no-op. Re-writing identical content produces byte-identical
-   * output, so replaying a delta is safe.
+   * Insert or replace a conversation, keyed on docId. New bridge records use
+   * the local `corpusChangedAt` mutation clock; older records fall back to the
+   * source `updatedAt`. If mutation clocks tie, source freshness breaks the
+   * tie. Re-writing identical content remains a byte-identical no-op.
    */
   async upsert(record) {
     return this.enqueueWrite(async () => {
@@ -219,9 +223,11 @@ var Corpus = class {
       const file = this.paths.conversationFile(conversation.platform, conversation.docId);
       const existing = await readJsonIfExists(file);
       if (existing) {
+        const existingChangedAt = existing.conversation.corpusChangedAt ?? existing.conversation.updatedAt ?? 0;
+        const incomingChangedAt = conversation.corpusChangedAt ?? conversation.updatedAt ?? 0;
         const existingUpdatedAt = existing.conversation.updatedAt ?? 0;
         const incomingUpdatedAt = conversation.updatedAt ?? 0;
-        if (incomingUpdatedAt < existingUpdatedAt) {
+        if (incomingChangedAt < existingChangedAt || incomingChangedAt === existingChangedAt && incomingUpdatedAt < existingUpdatedAt) {
           return { docId: conversation.docId, outcome: "skipped" };
         }
       }
@@ -841,6 +847,295 @@ function normalizeMatchRole(role) {
   return role === "assistant" || role === "user" || role === "system" ? role : "unknown";
 }
 
+// src/runtimeInstall.ts
+import { cp, mkdir, readdir, rename, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join5 } from "path";
+import { fileURLToPath } from "url";
+function defaultSourceDir() {
+  return dirname2(fileURLToPath(import.meta.url));
+}
+function runtimeBinDir(home = homedir2()) {
+  return join5(home, ".llmnesia", "bin");
+}
+async function installRuntime(options = {}) {
+  const home = options.home ?? homedir2();
+  const sourceDir = options.sourceDir ?? defaultSourceDir();
+  const nodePath = options.nodePath ?? process.execPath;
+  const binDir = runtimeBinDir(home);
+  const sourceEntry = join5(sourceDir, "cli.js");
+  if (!existsSync(sourceEntry)) {
+    throw new Error(
+      `Cannot locate the built runtime: no cli.js in ${sourceDir}. Run this from an installed package (npx -y @llmnesia/mcp@latest install) or build first (npm run build).`
+    );
+  }
+  const parentDir = dirname2(binDir);
+  const nonce = `${process.pid}-${Date.now()}`;
+  const stagingDir = join5(parentDir, `.bin-install-${nonce}`);
+  const backupDir = join5(parentDir, `.bin-backup-${nonce}`);
+  await mkdir(parentDir, { recursive: true });
+  await rm(stagingDir, { recursive: true, force: true });
+  await rm(backupDir, { recursive: true, force: true });
+  await mkdir(stagingDir, { recursive: true });
+  try {
+    for (const name of await readdir(sourceDir)) {
+      await cp(join5(sourceDir, name), join5(stagingDir, name), { recursive: true });
+    }
+    await writeFile(
+      join5(stagingDir, "package.json"),
+      `${JSON.stringify(
+        {
+          name: "llmnesia-mcp-runtime",
+          private: true,
+          type: "module",
+          // Stamped so the installed build is identifiable without spawning it.
+          // Its absence is how a machine sat on 0.1.3 while npm was ten
+          // releases ahead and nothing, doctor included, could say so.
+          version: options.version ?? VERSION,
+          comment: "Installed copy of @llmnesia/mcp's dist. Managed by the LLMnesia installer; edits are lost on reinstall."
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+    const hadPreviousRuntime = existsSync(binDir);
+    if (hadPreviousRuntime) {
+      await rename(binDir, backupDir);
+    }
+    try {
+      await rename(stagingDir, binDir);
+    } catch (err) {
+      if (hadPreviousRuntime && !existsSync(binDir) && existsSync(backupDir)) {
+        await rename(backupDir, binDir);
+      }
+      throw err;
+    }
+    await rm(backupDir, { recursive: true, force: true });
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+  const entry = join5(binDir, "cli.js");
+  return {
+    binDir,
+    entry,
+    serve: { command: nodePath, args: [entry, "serve"] },
+    sourceDir,
+    nodePath
+  };
+}
+async function uninstallRuntime(home = homedir2()) {
+  const binDir = runtimeBinDir(home);
+  if (!existsSync(binDir)) {
+    return null;
+  }
+  await rm(binDir, { recursive: true, force: true });
+  return binDir;
+}
+
+// src/selfUpdate.ts
+import { spawn } from "child_process";
+import { mkdtemp, readFile, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join6 } from "path";
+import { homedir as homedir3, tmpdir } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var PACKAGE_NAME = "@llmnesia/mcp";
+var REGISTRY_LATEST_URL = "https://registry.npmjs.org/@llmnesia%2Fmcp/latest";
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var INSTALL_TIMEOUT_MS = 12e4;
+var UPDATE_CHECK_DELAY_MS = 3e4;
+function stateFile(home) {
+  return join6(home, ".llmnesia", "update-state.json");
+}
+async function readState(home) {
+  try {
+    const parsed = JSON.parse(await readFile(stateFile(home), "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeState(home, state) {
+  try {
+    await writeFile2(stateFile(home), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+function compareVersions(a, b) {
+  const parse = (v) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : [];
+  };
+  const left = parse(a);
+  const right = parse(b);
+  if (left.length === 0 || right.length === 0) {
+    return 0;
+  }
+  for (let i = 0; i < 3; i += 1) {
+    if (left[i] !== right[i]) {
+      return left[i] - right[i];
+    }
+  }
+  return 0;
+}
+function isStableRelease(version) {
+  return /^\d+\.\d+\.\d+$/.test(version.trim());
+}
+function isSelfUpdateDisabled(env = process.env) {
+  const raw = env.LLMNESIA_NO_AUTO_UPDATE;
+  return raw === "1" || raw === "true";
+}
+async function fetchLatestFromRegistry() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+  try {
+    const response = await fetch(REGISTRY_LATEST_URL, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`registry responded ${response.status}`);
+    }
+    const body = await response.json();
+    if (typeof body.version !== "string") {
+      throw new Error("registry response had no version");
+    }
+    return body.version;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function npmCommand() {
+  const binDir = dirname3(process.execPath);
+  return process.platform === "win32" ? join6(binDir, "npm.cmd") : join6(binDir, "npm");
+}
+async function npmDownload(version) {
+  const prefix = await mkdtemp(join6(tmpdir(), "llmnesia-update-"));
+  await new Promise((resolve2, reject) => {
+    const child = spawn(
+      npmCommand(),
+      [
+        "install",
+        `${PACKAGE_NAME}@${version}`,
+        "--prefix",
+        prefix,
+        "--no-audit",
+        "--no-fund",
+        "--no-save",
+        "--loglevel",
+        "error"
+      ],
+      { stdio: ["ignore", "ignore", "pipe"], windowsHide: true }
+    );
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    const timer = setTimeout(() => child.kill(), INSTALL_TIMEOUT_MS);
+    child.once("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`npm install exited ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+      }
+    });
+  });
+  return join6(prefix, "node_modules", PACKAGE_NAME, "dist");
+}
+async function maybeSelfUpdate(options = {}) {
+  const env = options.env ?? process.env;
+  if (isSelfUpdateDisabled(env)) {
+    return { action: "disabled" };
+  }
+  const home = options.home ?? homedir3();
+  const currentVersion = options.currentVersion ?? VERSION;
+  const runningDir = options.runningDir ?? dirname3(fileURLToPath2(import.meta.url));
+  if (runningDir !== runtimeBinDir(home)) {
+    return { action: "not-installed-runtime" };
+  }
+  if (!isStableRelease(currentVersion)) {
+    return { action: "not-a-release-build", currentVersion };
+  }
+  const now = options.now ?? Date.now;
+  const state = await readState(home);
+  if (state.lastCheckedAt !== void 0 && now() - state.lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
+    return { action: "throttled" };
+  }
+  let latest;
+  try {
+    latest = await (options.fetchLatestVersion ?? fetchLatestFromRegistry)();
+  } catch (err) {
+    await writeState(home, { ...state, lastCheckedAt: now() });
+    return { action: "check-failed", error: err instanceof Error ? err.message : String(err) };
+  }
+  const checked = { ...state, lastCheckedAt: now(), lastSeenVersion: latest };
+  if (!isStableRelease(latest) || compareVersions(latest, currentVersion) <= 0) {
+    await writeState(home, checked);
+    return { action: "up-to-date", latest };
+  }
+  if (state.lastFailedVersion === latest) {
+    await writeState(home, checked);
+    return { action: "skipped-failed-before", latest };
+  }
+  let sourceDir;
+  try {
+    sourceDir = await (options.downloadPackage ?? npmDownload)(latest);
+    await installRuntime({ home, sourceDir, version: latest });
+    await writeState(home, { ...checked, lastUpdatedTo: latest, lastFailedVersion: void 0 });
+    return { action: "updated", from: currentVersion, to: latest };
+  } catch (err) {
+    await writeState(home, { ...checked, lastFailedVersion: latest });
+    return { action: "update-failed", latest, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    if (sourceDir) {
+      await rm2(join6(sourceDir, "..", "..", ".."), { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+function scheduleSelfUpdate(options = {}) {
+  const { delayMs = UPDATE_CHECK_DELAY_MS, onOutcome, ...rest } = options;
+  const timer = setTimeout(() => {
+    void maybeSelfUpdate(rest).then(
+      (outcome) => onOutcome?.(outcome),
+      () => {
+      }
+    );
+  }, delayMs);
+  timer.unref?.();
+}
+function describeOutcome(outcome) {
+  switch (outcome.action) {
+    case "updated":
+      return `updated ${outcome.from} to ${outcome.to}; it takes effect next launch`;
+    case "update-failed":
+      return `could not install ${outcome.latest}: ${outcome.error}`;
+    case "check-failed":
+      return `could not reach the npm registry: ${outcome.error}`;
+    case "up-to-date":
+      return `already current (latest published is ${outcome.latest})`;
+    case "skipped-failed-before":
+      return `${outcome.latest} failed to install previously; not retrying automatically`;
+    case "throttled":
+      return "checked recently";
+    case "disabled":
+      return "automatic updates are turned off (LLMNESIA_NO_AUTO_UPDATE)";
+    case "not-installed-runtime":
+      return "not running from ~/.llmnesia/bin, so nothing to update";
+    case "not-a-release-build":
+      return `running an unreleased build (${outcome.currentVersion}); leaving the installed runtime alone`;
+  }
+}
+
 export {
   resolveCorpusDir,
   Corpus,
@@ -849,5 +1144,11 @@ export {
   drainInbox,
   SearchIndex,
   openSearchIndex,
-  deleteIndexDb
+  deleteIndexDb,
+  runtimeBinDir,
+  installRuntime,
+  uninstallRuntime,
+  isSelfUpdateDisabled,
+  scheduleSelfUpdate,
+  describeOutcome
 };

package/dist/{chunk-7DAYOGB6.js → chunk-QGVH3T5W.js}

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

package/dist/{cli-OJM47LQR.js → cli-I2P4TSZW.js}

@@ -7,15 +7,19 @@ import {
   deleteIndexDb,
   drainInbox,
   ingestFile,
+  installRuntime,
+  isSelfUpdateDisabled,
   openSearchIndex,
-  resolveCorpusDir
-} from "./chunk-3JQ7CGCP.js";
+  resolveCorpusDir,
+  runtimeBinDir,
+  uninstallRuntime
+} from "./chunk-JS2GFGNW.js";
 import {
   VERSION,
   __commonJS,
   __require,
   __toESM
-} from "./chunk-7DAYOGB6.js";
+} from "./chunk-QGVH3T5W.js";
 
 // ../node_modules/isexe/windows.js
 var require_windows = __commonJS({
@@ -455,19 +459,19 @@ var require_enoent = __commonJS({
         spawnargs: original.args
       });
     }
-    function hookChildProcess(cp2, parsed) {
+    function hookChildProcess(cp, parsed) {
       if (!isWin) {
         return;
       }
-      const originalEmit = cp2.emit;
-      cp2.emit = function(name, arg1) {
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
         if (name === "exit") {
           const err = verifyENOENT(arg1, parsed);
           if (err) {
-            return originalEmit.call(cp2, "error", err);
+            return originalEmit.call(cp, "error", err);
           }
         }
-        return originalEmit.apply(cp2, arguments);
+        return originalEmit.apply(cp, arguments);
       };
     }
     function verifyENOENT(status, parsed) {
@@ -495,18 +499,18 @@ var require_enoent = __commonJS({
 var require_cross_spawn = __commonJS({
   "../node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
-    var cp2 = __require("child_process");
+    var cp = __require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
     function spawn(command, args, options) {
       const parsed = parse(command, args, options);
-      const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync(command, args, options) {
       const parsed = parse(command, args, options);
-      const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
@@ -1602,9 +1606,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname7 = sysPath.dirname(file);
+    const dirname6 = sysPath.dirname(file);
     const basename3 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname7);
+    const parent = this.fsw._getWatchedDir(dirname6);
     let prevStats = stats;
     if (parent.has(basename3))
       return;
@@ -1631,7 +1635,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname7, basename3);
+          this.fsw._remove(dirname6, basename3);
         }
       } else if (parent.has(basename3)) {
         const at = newStats.atimeMs;
@@ -3420,100 +3424,14 @@ async function unregisterClients(options = {}) {
 }
 
 // src/doctor.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { delimiter, dirname as dirname6, isAbsolute as isAbsolute2, join as join6, sep } from "path";
-import { homedir as homedir4, platform as platform3 } from "os";
-
-// src/runtimeInstall.ts
-import { cp, mkdir as mkdir3, readdir as readdir3, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function defaultSourceDir() {
-  return dirname5(fileURLToPath2(import.meta.url));
-}
-function runtimeBinDir(home2 = homedir3()) {
-  return join5(home2, ".llmnesia", "bin");
-}
-async function installRuntime(options = {}) {
-  const home2 = options.home ?? homedir3();
-  const sourceDir = options.sourceDir ?? defaultSourceDir();
-  const nodePath = options.nodePath ?? process.execPath;
-  const binDir = runtimeBinDir(home2);
-  const sourceEntry = join5(sourceDir, "cli.js");
-  if (!existsSync(sourceEntry)) {
-    throw new Error(
-      `Cannot locate the built runtime: no cli.js in ${sourceDir}. Run this from an installed package (npx -y @llmnesia/mcp@latest install) or build first (npm run build).`
-    );
-  }
-  const parentDir = dirname5(binDir);
-  const nonce = `${process.pid}-${Date.now()}`;
-  const stagingDir = join5(parentDir, `.bin-install-${nonce}`);
-  const backupDir = join5(parentDir, `.bin-backup-${nonce}`);
-  await mkdir3(parentDir, { recursive: true });
-  await rm2(stagingDir, { recursive: true, force: true });
-  await rm2(backupDir, { recursive: true, force: true });
-  await mkdir3(stagingDir, { recursive: true });
-  try {
-    for (const name of await readdir3(sourceDir)) {
-      await cp(join5(sourceDir, name), join5(stagingDir, name), { recursive: true });
-    }
-    await writeFile3(
-      join5(stagingDir, "package.json"),
-      `${JSON.stringify(
-        {
-          name: "llmnesia-mcp-runtime",
-          private: true,
-          type: "module",
-          comment: "Installed copy of @llmnesia/mcp's dist. Managed by the LLMnesia installer; edits are lost on reinstall."
-        },
-        null,
-        2
-      )}
-`,
-      "utf8"
-    );
-    const hadPreviousRuntime = existsSync(binDir);
-    if (hadPreviousRuntime) {
-      await rename(binDir, backupDir);
-    }
-    try {
-      await rename(stagingDir, binDir);
-    } catch (err) {
-      if (hadPreviousRuntime && !existsSync(binDir) && existsSync(backupDir)) {
-        await rename(backupDir, binDir);
-      }
-      throw err;
-    }
-    await rm2(backupDir, { recursive: true, force: true });
-  } finally {
-    await rm2(stagingDir, { recursive: true, force: true });
-  }
-  const entry = join5(binDir, "cli.js");
-  return {
-    binDir,
-    entry,
-    serve: { command: nodePath, args: [entry, "serve"] },
-    sourceDir,
-    nodePath
-  };
-}
-async function uninstallRuntime(home2 = homedir3()) {
-  const binDir = runtimeBinDir(home2);
-  if (!existsSync(binDir)) {
-    return null;
-  }
-  await rm2(binDir, { recursive: true, force: true });
-  return binDir;
-}
-
-// src/doctor.ts
+import { existsSync, readFileSync } from "fs";
+import { delimiter, dirname as dirname5, isAbsolute as isAbsolute2, join as join5, sep } from "path";
+import { homedir as homedir3, platform as platform3 } from "os";
 var INSTALL_COMMAND = "npx -y @llmnesia/mcp@latest install";
 function checkNativeHostManifest(home2, osPlatform2) {
   if (osPlatform2 === "win32") {
-    const manifestPath = join6(home2, ".llmnesia", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
+    const manifestPath = join5(home2, ".llmnesia", `${HOST_NAME}.json`);
+    if (existsSync(manifestPath)) {
       return {
         name: "Native messaging host",
         status: "ok",
@@ -3528,11 +3446,11 @@ function checkNativeHostManifest(home2, osPlatform2) {
   }
   const found = [];
   for (const [label, browserDir] of posixBrowsers(home2, osPlatform2)) {
-    if (!existsSync2(browserDir)) {
+    if (!existsSync(browserDir)) {
       continue;
     }
-    const manifestPath = join6(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
+    const manifestPath = join5(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
+    if (existsSync(manifestPath)) {
       found.push(label);
     }
   }
@@ -3546,8 +3464,8 @@ function checkNativeHostManifest(home2, osPlatform2) {
   };
 }
 async function checkCorpus(home2, corpusRoot) {
-  const configPath = join6(home2, ".llmnesia", "config.json");
-  if (!corpusRoot && !existsSync2(configPath)) {
+  const configPath = join5(home2, ".llmnesia", "config.json");
+  if (!corpusRoot && !existsSync(configPath)) {
     return {
       name: "Corpus config",
       status: "missing",
@@ -3555,7 +3473,7 @@ async function checkCorpus(home2, corpusRoot) {
     };
   }
   const root = corpusRoot ?? resolveCorpusDir();
-  if (!existsSync2(root)) {
+  if (!existsSync(root)) {
     return {
       name: "Corpus",
       status: "warn",
@@ -3588,14 +3506,14 @@ async function checkCorpus(home2, corpusRoot) {
 function commandProblem(command, args = []) {
   const looksLikePath = isAbsolute2(command) || command.includes(sep) || command.includes("/");
   if (looksLikePath) {
-    if (!existsSync2(command)) {
+    if (!existsSync(command)) {
       return `its command does not exist: ${command}`;
     }
   } else if (!resolveOnPath(command)) {
     return `its command "${command}" is not on PATH. GUI clients get a minimal PATH (no nvm, no homebrew), so a bare command name is unreliable even when your shell can find it. Re-run: ${INSTALL_COMMAND}`;
   }
   const script = args.find((a) => a.endsWith(".js") || a.endsWith(".mjs"));
-  if (script && (isAbsolute2(script) || script.includes(sep)) && !existsSync2(script)) {
+  if (script && (isAbsolute2(script) || script.includes(sep)) && !existsSync(script)) {
     return `its script does not exist: ${script}. Re-run: ${INSTALL_COMMAND}`;
   }
   return null;
@@ -3607,29 +3525,72 @@ function resolveOnPath(command) {
       continue;
     }
     for (const ext of exts) {
-      if (existsSync2(join6(dir, command + ext))) {
+      if (existsSync(join5(dir, command + ext))) {
         return true;
       }
     }
   }
   return false;
 }
+function installedRuntimeVersion(home2) {
+  try {
+    const parsed = JSON.parse(readFileSync(join5(runtimeBinDir(home2), "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
 function checkRuntime(home2) {
-  const entry = join6(runtimeBinDir(home2), "cli.js");
-  if (existsSync2(entry)) {
-    return { name: "MCP server runtime", status: "ok", detail: `Installed at ${entry}.` };
+  const entry = join5(runtimeBinDir(home2), "cli.js");
+  if (!existsSync(entry)) {
+    return {
+      name: "MCP server runtime",
+      status: "missing",
+      detail: `No runtime at ${entry}. Clients spawn this copy, so registration alone is not enough. Run: ${INSTALL_COMMAND}`
+    };
   }
-  return {
-    name: "MCP server runtime",
-    status: "missing",
-    detail: `No runtime at ${entry}. Clients spawn this copy, so registration alone is not enough. Run: ${INSTALL_COMMAND}`
-  };
+  const installed = installedRuntimeVersion(home2);
+  if (installed === null) {
+    return {
+      name: "MCP server runtime",
+      status: "warn",
+      detail: `Installed at ${entry}, but its version is not recorded, so it predates automatic updates. Refresh it with: ${INSTALL_COMMAND}`
+    };
+  }
+  const suffix = installed === VERSION ? "" : ` (this command is ${VERSION})`;
+  return { name: "MCP server runtime", status: "ok", detail: `Version ${installed} at ${entry}${suffix}.` };
+}
+function checkAutoUpdate(home2, env) {
+  const name = "Automatic updates";
+  if (isSelfUpdateDisabled(env)) {
+    return { name, status: "warn", detail: "Turned off by LLMNESIA_NO_AUTO_UPDATE." };
+  }
+  let state = {};
+  try {
+    state = JSON.parse(readFileSync(join5(home2, ".llmnesia", "update-state.json"), "utf8"));
+  } catch {
+    return {
+      name,
+      status: "ok",
+      detail: "On. No check has run yet; the server checks shortly after it starts."
+    };
+  }
+  if (state.lastFailedVersion) {
+    return {
+      name,
+      status: "warn",
+      detail: `On, but ${state.lastFailedVersion} could not be installed automatically. Run: ${INSTALL_COMMAND}`
+    };
+  }
+  const checkedAt = state.lastCheckedAt ? new Date(state.lastCheckedAt).toISOString() : "never";
+  const latest = state.lastSeenVersion ? `; latest published ${state.lastSeenVersion}` : "";
+  return { name, status: "ok", detail: `On. Last checked ${checkedAt}${latest}.` };
 }
 async function checkJsonClient(label, configPath) {
-  if (!existsSync2(dirname6(configPath))) {
-    return { name: label, status: "warn", detail: `Not installed (no ${dirname6(configPath)}).` };
+  if (!existsSync(dirname5(configPath))) {
+    return { name: label, status: "warn", detail: `Not installed (no ${dirname5(configPath)}).` };
   }
-  if (!existsSync2(configPath)) {
+  if (!existsSync(configPath)) {
     return {
       name: label,
       status: "missing",
@@ -3718,8 +3679,8 @@ async function checkCodex(home2, cli) {
       return { name: "Codex", status: "warn", detail: `Could not inspect Codex MCP settings: ${err instanceof Error ? err.message : String(err)}` };
     }
   }
-  const configPath = join6(home2, ".codex", "config.toml");
-  if (!existsSync2(configPath)) {
+  const configPath = join5(home2, ".codex", "config.toml");
+  if (!existsSync(configPath)) {
     return { name: "Codex", status: "warn", detail: `Not installed (no ${configPath}), or never configured.` };
   }
   let text;
@@ -3747,11 +3708,11 @@ async function checkCodex(home2, cli) {
   };
 }
 async function runDoctor(options = {}) {
-  const home2 = options.home ?? homedir4();
+  const home2 = options.home ?? homedir3();
   const osPlatform2 = options.osPlatform ?? platform3();
   const claudeCli = options.claudeCli ?? realClaudeCli;
   const codexCli = options.codexCli ?? realCodexCli;
-  const claudeDesktopPath = osPlatform2 === "darwin" ? join6(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join6(process.env.APPDATA || join6(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
+  const claudeDesktopPath = osPlatform2 === "darwin" ? join5(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join5(process.env.APPDATA || join5(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
   const checks = [];
   const run = async (name, fn) => {
     try {
@@ -3766,11 +3727,12 @@ async function runDoctor(options = {}) {
   };
   await run("Native messaging host", () => checkNativeHostManifest(home2, osPlatform2));
   await run("MCP server runtime", () => checkRuntime(home2));
+  await run("Automatic updates", () => checkAutoUpdate(home2, options.env ?? process.env));
   await run("Corpus", () => checkCorpus(home2, options.corpusRoot));
   if (claudeDesktopPath) {
     await run("Claude Desktop", () => checkJsonClient("Claude Desktop", claudeDesktopPath));
   }
-  await run("Cursor", () => checkJsonClient("Cursor", join6(home2, ".cursor", "mcp.json")));
+  await run("Cursor", () => checkJsonClient("Cursor", join5(home2, ".cursor", "mcp.json")));
   await run("Claude Code", () => checkClaudeCode(claudeCli));
   await run("Codex", () => checkCodex(home2, codexCli));
   checks.push({
@@ -3857,7 +3819,7 @@ function summarizeClientRegistrations(results) {
   return { connected, prepared, errors };
 }
 function formatInstallSuccess() {
-  return "\nSetup complete.\nFully close and reopen your browser and any desktop AI app you use.\nLLMnesia will be available in the desktop AI apps connected during setup.\nLLMnesia Settings will confirm when your history is ready.\n";
+  return "\nSetup complete.\nFully close and reopen your browser and any desktop AI app you use.\nLLMnesia will be available in the desktop AI apps connected during setup.\nLLMnesia Settings will confirm when your history is ready.\n\nLLMnesia keeps itself up to date, checking for a new version once a day.\nOnly a version number is fetched. Your conversations never leave this machine.\nTo turn updates off, set LLMNESIA_NO_AUTO_UPDATE=1.\n";
 }
 async function runInstall(positionals, options, flags) {
   let hadProblems = false;

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-7DAYOGB6.js";
+} from "./chunk-QGVH3T5W.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-OJM47LQR.js");
+  const { main } = await import("./cli-I2P4TSZW.js");
   return main();
 }
 bootstrap().then((code) => {

package/dist/mcp.js

@@ -3,17 +3,19 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   Corpus,
+  describeOutcome,
   drainInbox,
   openSearchIndex,
   pendingInboxFiles,
-  resolveCorpusDir
-} from "./chunk-3JQ7CGCP.js";
+  resolveCorpusDir,
+  scheduleSelfUpdate
+} from "./chunk-JS2GFGNW.js";
 import {
   VERSION,
   __commonJS,
   __export,
   __toESM
-} from "./chunk-7DAYOGB6.js";
+} from "./chunk-QGVH3T5W.js";
 
 // ../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -21656,7 +21658,17 @@ async function runServe() {
       })
     );
   }
-  server.server.oninitialized = () => service.start();
+  server.server.oninitialized = () => {
+    service.start();
+    scheduleSelfUpdate({
+      onOutcome: (outcome) => {
+        if (outcome.action === "updated" || outcome.action === "update-failed") {
+          process.stderr.write(`llmnesia: ${describeOutcome(outcome)}
+`);
+        }
+      }
+    });
+  };
   const transport = new StdioServerTransport();
   await server.connect(transport);
   process.stderr.write(`llmnesia MCP protocol ready; waiting for client initialization (${root})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmnesia/mcp",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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.1.13",
+  "version": "0.1.14",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@llmnesia/mcp",
-      "version": "0.1.13",
+      "version": "0.1.14",
       "transport": {
         "type": "stdio"
       }