@prom.codes/memory-mcp 0.18.0 → 0.19.0

package/dist/bin.js

@@ -28,9 +28,11 @@ var DOCUMENT_LANGUAGE_IDS = [
   "yaml",
   "toml"
 ];
+var COMPOSITE_LANGUAGE_IDS = ["vue"];
 var LANGUAGE_IDS = [
   ...GRAMMAR_LANGUAGE_IDS,
-  ...DOCUMENT_LANGUAGE_IDS
+  ...DOCUMENT_LANGUAGE_IDS,
+  ...COMPOSITE_LANGUAGE_IDS
 ];
 
 // ../shared/dist/update-check.js
@@ -259,15 +261,19 @@ function notify(log, name, current, latest) {
 
 // ../shared/dist/update-info.js
 async function buildUpdateStatus(pkgName, currentVersion, options = {}) {
-  const base = { current: currentVersion, command: await resolveUpgradeCommand() };
   if (options.isDevBuild === true) {
     return {
-      ...base,
+      current: currentVersion,
+      // A workspace build does not need an npm-version probe: the command is
+      // invariant across supported npm releases, and avoiding the subprocess
+      // keeps status responsive during deferred-root startup.
+      command: UPGRADE_COMMAND,
       latest: null,
       updateAvailable: null,
       note: "dev build (workspace) \u2014 version comparison skipped"
     };
   }
+  const base = { current: currentVersion, command: await resolveUpgradeCommand() };
   let latest = null;
   try {
     latest = await getLatestVersion(pkgName, {
@@ -388,7 +394,12 @@ function startHeartbeat(options) {
 // ../shared/dist/idle-watchdog.js
 var DEFAULT_IDLE_EXIT_MS = 30 * 6e4;
 var IDLE_CHECK_INTERVAL_MS = 6e4;
+var DEFAULT_PROBE_TIMEOUT_MS = 5e3;
+var DEFAULT_PROBE_RETRIES = 2;
+var DEFAULT_MAX_PROBE_EXTENSIONS = 8;
 var IDLE_EXIT_ENV = "PROMETHEUS_IDLE_EXIT_MS";
+var IDLE_MAX_PINGS_ENV = "PROMETHEUS_IDLE_MAX_PINGS";
+var IDLE_PROBE_MS_ENV = "PROMETHEUS_IDLE_PROBE_MS";
 function parseIdleExitMs(env) {
   const raw = (env[IDLE_EXIT_ENV] ?? "").trim();
   if (raw === "")
@@ -396,6 +407,20 @@ function parseIdleExitMs(env) {
   const n = Number(raw);
   return Number.isFinite(n) && n >= 0 ? n : void 0;
 }
+function parseMaxProbeExtensions(env) {
+  const raw = (env[IDLE_MAX_PINGS_ENV] ?? "").trim();
+  if (raw === "")
+    return void 0;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : void 0;
+}
+function parseProbeTimeoutMs(env) {
+  const raw = (env[IDLE_PROBE_MS_ENV] ?? "").trim();
+  if (raw === "")
+    return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
 function createIdleWatchdog(options) {
   const env = options.env ?? process.env;
   const idleMs = options.idleMs ?? parseIdleExitMs(env) ?? DEFAULT_IDLE_EXIT_MS;
@@ -406,18 +431,72 @@ function createIdleWatchdog(options) {
     }, stop() {
     }, idleMs: 0 };
   }
+  const probe = options.probe;
+  const probeTimeoutMs = options.probeTimeoutMs ?? parseProbeTimeoutMs(env) ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const probeRetries = Math.max(1, options.probeRetries ?? DEFAULT_PROBE_RETRIES);
+  const maxProbeExtensions = options.maxProbeExtensions ?? parseMaxProbeExtensions(env) ?? DEFAULT_MAX_PROBE_EXTENSIONS;
+  const yieldToIo = options.yieldToIo ?? ((fn) => {
+    const t = setImmediate(fn);
+    t.unref?.();
+  });
   let lastActivity = now();
   let stopped = false;
   let fired = false;
+  let probing = false;
+  let failedProbes = 0;
+  let probeOnlyExtensions = 0;
+  const fire = (idleFor, why) => {
+    fired = true;
+    clearInterval(timer);
+    const detail = why === "unanswered" ? ` and ${probeRetries} liveness pings went unanswered (${Math.round(probeTimeoutMs / 1e3)}s each)` : why === "capped" ? ` \u2014 the client answered ${probeOnlyExtensions} liveness pings in a row but sent no request in any of those windows, so this server is attached to a session nobody is using (raise or disable with ${IDLE_MAX_PINGS_ENV})` : "";
+    options.onIdle(`idle for ${Math.round(idleFor / 1e3)}s with no client activity` + detail + ` (set ${IDLE_EXIT_ENV}=0 to disable)`);
+  };
+  const launchProbe = () => {
+    probing = true;
+    const startedAt = now();
+    let settled = false;
+    let timeoutTimer = null;
+    const finish = (alive) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timeoutTimer !== null)
+        clearTimeout(timeoutTimer);
+      probing = false;
+      if (stopped || fired)
+        return;
+      if (alive || lastActivity > startedAt) {
+        failedProbes = 0;
+        lastActivity = now();
+        probeOnlyExtensions += 1;
+        if (maxProbeExtensions > 0 && probeOnlyExtensions >= maxProbeExtensions) {
+          fire(idleMs * probeOnlyExtensions, "capped");
+        }
+        return;
+      }
+      failedProbes += 1;
+      if (failedProbes < probeRetries)
+        return;
+      fire(now() - lastActivity, "unanswered");
+    };
+    timeoutTimer = setTimeout(() => {
+      yieldToIo(() => finish(false));
+    }, probeTimeoutMs);
+    timeoutTimer.unref?.();
+    void probe().then(() => finish(true), () => finish(false));
+  };
   const timer = setInterval(() => {
     if (stopped || fired)
       return;
     const idleFor = now() - lastActivity;
-    if (idleFor >= idleMs) {
-      fired = true;
-      clearInterval(timer);
-      options.onIdle(`idle for ${Math.round(idleFor / 1e3)}s with no client activity (set ${IDLE_EXIT_ENV}=0 to disable)`);
+    if (idleFor < idleMs)
+      return;
+    if (probe === void 0) {
+      fire(idleFor, "silent");
+      return;
     }
+    if (!probing)
+      launchProbe();
   }, checkIntervalMs);
   timer.unref?.();
   return {
@@ -426,6 +505,10 @@ function createIdleWatchdog(options) {
       if (stopped)
         return;
       lastActivity = now();
+      if (!probing) {
+        failedProbes = 0;
+        probeOnlyExtensions = 0;
+      }
     },
     stop() {
       if (stopped)
@@ -4648,7 +4731,7 @@ ${f.value}`);
         embeddingsError = err instanceof Error ? err.message : String(err);
       }
     }
-    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.18.0", { isDevBuild: false });
+    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.19.0", { isDevBuild: false });
     let recorder;
     try {
       const scopes = ["project-local", "project", "user"];
@@ -4730,7 +4813,7 @@ ${f.value}`);
 // dist/server.js
 var SERVER_IDENTITY = {
   name: "prom.codes-memory",
-  version: "0.18.0",
+  version: "0.19.0",
   title: "prom.codes Memory"
 };
 var SERVER_INSTRUCTIONS = "Persistent agent memory for this workspace \u2014 USE IT PROACTIVELY; the user will not tell you to. Protocol:\n1. ONE-TIME: if this workspace has no prom.codes memory rule yet, call memory_setup now (idempotent) so the protocol is installed into the runtime rule files and survives future sessions. (The server also auto-installs it on startup when a project rule file already exists \u2014 memory_setup covers the rest.)\n2. SESSION START: before any non-trivial task, call memory_read to recall facts, decisions and procedures from earlier sessions.\n3. DURING WORK: when the user states a durable preference, decision, correction or project fact, store it with memory_write (semantic for facts, procedural for how-tos) \u2014 without being asked.\n4. LOOK-UP: use memory_search for keyword recall when memory_read is not specific enough.\n5. SESSION END: consolidate what was learned with memory_capture.\nCall memory_status anytime to check what is stored and whether the rule is installed. Never store secrets, API keys or credentials \u2014 such writes are rejected.";
@@ -4803,9 +4886,19 @@ async function main() {
   process.stdin.once("end", () => void shutdown("stdin closed (client exited)"));
   process.stdin.once("close", () => void shutdown("stdin closed (client exited)"));
   server.server.onclose = () => void shutdown("transport closed (client exited)");
-  watchdog = createIdleWatchdog({ onIdle: (reason) => void shutdown(reason), env });
+  watchdog = createIdleWatchdog({
+    onIdle: (reason) => void shutdown(reason),
+    env,
+    // Before reaping, ask the client via MCP ping: a live-but-quiet session
+    // (e.g. Claude Code with deferred tools, no memory call for 30 min —
+    // 2026-08-12) answers and is never dropped; only an abandoned server
+    // whose pong never comes still reaps itself.
+    probe: async () => {
+      await server.server.ping();
+    }
+  });
   if (watchdog.idleMs > 0) {
-    process.stderr.write(`prom.codes-memory: idle self-exit armed (${Math.round(watchdog.idleMs / 6e4)} min of no client activity)
+    process.stderr.write(`prom.codes-memory: idle self-exit armed (${Math.round(watchdog.idleMs / 6e4)} min of no client activity; client is pinged before exit)
 `);
   }
   const armIdleWatch = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prom.codes/memory-mcp",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {