@prom.codes/memory-mcp 0.11.4 → 0.15.0

package/dist/bin.js

@@ -209,15 +209,15 @@ async function checkForUpdate(options) {
   const file = cachePath(cacheDir, name);
   const now = Date.now();
   if (!force) {
-    const cached = await readCache(file);
-    if (cached !== null && now - cached.checkedAt < cacheTtlMs && !cachedLatestIsStale(cached.latest, version)) {
-      const updateAvailable2 = cached.latest !== null && isNewerVersion(cached.latest, version);
+    const cached2 = await readCache(file);
+    if (cached2 !== null && now - cached2.checkedAt < cacheTtlMs && !cachedLatestIsStale(cached2.latest, version)) {
+      const updateAvailable2 = cached2.latest !== null && isNewerVersion(cached2.latest, version);
       if (updateAvailable2)
-        notify(log, name, version, cached.latest);
-      await syncAvailabilityMarker(cacheDir, name, version, cached.latest, updateAvailable2);
+        notify(log, name, version, cached2.latest);
+      await syncAvailabilityMarker(cacheDir, name, version, cached2.latest, updateAvailable2);
       return {
         ...base,
-        latest: cached.latest,
+        latest: cached2.latest,
         checked: false,
         updateAvailable: updateAvailable2,
         reason: "throttled"
@@ -239,14 +239,14 @@ async function checkForUpdate(options) {
 async function getLatestVersion(name, options = {}) {
   const { env = process.env, fetch: fetchImpl = globalThis.fetch, cacheDir = join(homedir(), ".prometheus"), cacheTtlMs = DEFAULT_TTL_MS, timeoutMs = DEFAULT_TIMEOUT_MS, minVersion } = options;
   const file = cachePath(cacheDir, name);
-  const cached = await readCache(file);
+  const cached2 = await readCache(file);
   const now = Date.now();
-  const stale = cachedLatestIsStale(cached?.latest ?? null, minVersion);
-  if (cached !== null && cached.latest !== null && now - cached.checkedAt < cacheTtlMs && !stale) {
-    return cached.latest;
+  const stale = cachedLatestIsStale(cached2?.latest ?? null, minVersion);
+  if (cached2 !== null && cached2.latest !== null && now - cached2.checkedAt < cacheTtlMs && !stale) {
+    return cached2.latest;
   }
   if (OPT_OUT_RE.test(env.PROMETHEUS_NO_UPDATE_CHECK ?? "") || typeof fetchImpl !== "function") {
-    return stale ? null : cached?.latest ?? null;
+    return stale ? null : cached2?.latest ?? null;
   }
   const latest = await fetchLatest(name, fetchImpl, timeoutMs);
   if (latest !== null) {
@@ -254,7 +254,7 @@ async function getLatestVersion(name, options = {}) {
     await writeCache(file, { checkedAt: now, latest });
     return latest;
   }
-  return stale ? null : cached?.latest ?? null;
+  return stale ? null : cached2?.latest ?? null;
 }
 function notify(log, name, current, latest) {
   log(`${name}: a newer version (${latest}) is available \u2014 you are on ${current}. npx users get it automatically on the next restart; for a global install run \`npm update -g ${name}\`. (Set PROMETHEUS_NO_UPDATE_CHECK=1 to silence.)
@@ -426,10 +426,58 @@ function createIdleWatchdog(options) {
   };
 }
 
+// ../shared/dist/native-binding.js
+import { createRequire } from "node:module";
+import { dirname as dirname2, join as join4 } from "node:path";
+import { existsSync } from "node:fs";
+var require_ = createRequire(import.meta.url);
+function isMusl() {
+  try {
+    const report = process.report?.getReport();
+    const header = typeof report === "object" && report !== null ? report : {};
+    return header.header?.glibcVersionRuntime === void 0;
+  } catch {
+    return false;
+  }
+}
+function platformToken(platform = process.platform, arch = process.arch, musl = platform === "linux" && isMusl()) {
+  const os = platform === "linux" && musl ? "linuxmusl" : platform;
+  return `${os}-${arch}`;
+}
+function nativePackageName(token = platformToken()) {
+  return `@prom.codes/native-${token}`;
+}
+function addonFileName(abi = process.versions.modules) {
+  return `better_sqlite3/node-v${abi}.node`;
+}
+var cached;
+function resolveNativeBinding() {
+  if (cached !== void 0)
+    return cached ?? void 0;
+  cached = null;
+  const override = process.env.PROMETHEUS_SQLITE_NATIVE_BINDING?.trim();
+  if (override) {
+    cached = existsSync(override) ? override : null;
+    return cached ?? void 0;
+  }
+  try {
+    const manifest = require_.resolve(`${nativePackageName()}/package.json`);
+    const candidate = join4(dirname2(manifest), addonFileName());
+    cached = existsSync(candidate) ? candidate : null;
+  } catch {
+    cached = null;
+  }
+  return cached ?? void 0;
+}
+function nativeBindingOption() {
+  const p = resolveNativeBinding();
+  return p ? { nativeBinding: p } : {};
+}
+
 // dist/composition.js
 import { createHash } from "node:crypto";
-import { homedir as homedir4 } from "node:os";
-import { basename, join as join4, resolve as resolve2 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { basename, join as join7, resolve as resolve2 } from "node:path";
 
 // ../embeddings-openai-compat/dist/index.js
 var DEFAULT_BATCH = 96;
@@ -1548,6 +1596,26 @@ function requireApiKey(env) {
 
 // dist/extraction.js
 var SYSTEM_PROMPT = 'You extract durable, atomic facts from a coding agent\'s session notes for long-term project memory. Output ONLY a JSON array of objects {"key":..., "value":...}. Each fact must be ONE self-contained statement that will be useful in a FUTURE session: a decision, a convention, a preference, a stable configuration, or a learned fact about the project. `key` is a short kebab-case slug; `value` is the full fact in one sentence. DROP transient step-by-step narration, anything true only for this one session, and anything obvious. Never invent facts not supported by the notes. If there is nothing durable, output []. Output at most 12 facts.';
+var CURATION_SYSTEM_PROMPT = 'You curate a coding agent\'s recorded session into long-term project memory. Output ONLY a JSON object: {"summary": string, "facts": [{"key","value","confidence"}], "procedures": [{"key","value"}]}. `summary` is 3-6 sentences: the goal, the outcome, and the key steps taken. `facts` are DURABLE things worth recalling in a future session \u2014 decisions, conventions, preferences, stable config, or learned facts about the project. `procedures` are reusable, proven how-tos (a sequence of steps that worked). For each candidate `key` is a short kebab-case slug and `value` is self-contained. DROP transient narration and anything true only for this one run. Never invent anything not supported by the log. If nothing is durable, return empty arrays (still write the summary). At most 10 facts and 6 procedures.';
+function parseCuration(raw, maxSummaryChars = 2e3) {
+  const match = raw.match(/\{[\s\S]*\}/);
+  const empty = { summary: "", facts: [], procedures: [] };
+  if (!match)
+    return empty;
+  let parsed;
+  try {
+    parsed = JSON.parse(match[0]);
+  } catch {
+    return empty;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return empty;
+  const obj = parsed;
+  const summary = typeof obj.summary === "string" ? obj.summary.trim().slice(0, maxSummaryChars) : "";
+  const facts = Array.isArray(obj.facts) ? parseExtraction(JSON.stringify(obj.facts), 10) : [];
+  const procedures = Array.isArray(obj.procedures) ? parseExtraction(JSON.stringify(obj.procedures), 6) : [];
+  return { summary, facts, procedures };
+}
 function parseExtraction(raw, maxFacts = 12, maxValueChars = 2e3) {
   const match = raw.match(/\[[\s\S]*\]/);
   if (!match)
@@ -1607,47 +1675,60 @@ var OpenAICompatExtractor = class {
     const trimmed = text.trim();
     if (trimmed === "")
       return [];
+    const content = await this.#chat(SYSTEM_PROMPT, `Session notes:
+
+${trimmed}`, opts?.signal);
+    return content === null ? [] : parseExtraction(content);
+  }
+  async curate(sessionText, opts) {
+    const trimmed = sessionText.trim();
+    const empty = { summary: "", facts: [], procedures: [] };
+    if (trimmed === "")
+      return empty;
+    const content = await this.#chat(CURATION_SYSTEM_PROMPT, `Session log:
+
+${trimmed}`, opts?.signal);
+    return content === null ? empty : parseCuration(content);
+  }
+  /**
+   * One chat-completion round with retry on 429/5xx. Returns the message content,
+   * or `null` on a permanent client error / exhausted retries (callers degrade
+   * gracefully — never throw). Shared by {@link extract} and {@link curate}.
+   */
+  async #chat(system, user, signal) {
     const body = JSON.stringify({
       model: this.model,
       temperature: this.#temperature,
       messages: [
-        { role: "system", content: SYSTEM_PROMPT },
-        { role: "user", content: `Session notes:
-
-${trimmed}` }
+        { role: "system", content: system },
+        { role: "user", content: user }
       ]
     });
     const headers = { "content-type": "application/json" };
     if (this.#apiKey !== void 0 && this.#apiKey !== "") {
       headers.authorization = `Bearer ${this.#apiKey}`;
     }
-    let lastErr;
     for (let attempt = 0; attempt <= this.#maxRetries; attempt++) {
       try {
         const res = await this.#fetch(this.#url, {
           method: "POST",
           headers,
           body,
-          ...opts?.signal ? { signal: opts.signal } : {}
+          ...signal ? { signal } : {}
         });
         if (res.status === 429 || res.status >= 500) {
-          lastErr = new Error(`extractor HTTP ${res.status}`);
         } else if (!res.ok) {
-          return [];
+          return null;
         } else {
           const json = await res.json();
-          const content = json.choices?.[0]?.message?.content ?? "";
-          return parseExtraction(content);
+          return json.choices?.[0]?.message?.content ?? "";
         }
-      } catch (err) {
-        lastErr = err;
+      } catch {
       }
-      if (attempt < this.#maxRetries) {
+      if (attempt < this.#maxRetries)
         await delay(this.#retryBaseMs * 2 ** attempt);
-      }
     }
-    void lastErr;
-    return [];
+    return null;
   }
 };
 function delay(ms) {
@@ -1729,10 +1810,347 @@ var OpenAICompatRewriter = class {
 
 // dist/sqlite.js
 import { randomUUID } from "node:crypto";
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, rmSync as rmSync2 } from "node:fs";
+import { dirname as dirname4, join as join6 } from "node:path";
 import Database from "better-sqlite3";
 
+// dist/security.js
+var SECRET_PATTERNS = [
+  { name: "openai-key", regex: /\bsk-proj-[A-Za-z0-9_-]{20,}/ },
+  { name: "anthropic-key", regex: /\bsk-ant-[A-Za-z0-9_-]{20,}/ },
+  { name: "supabase-token", regex: /\bsbp?_[A-Za-z0-9]{20,}/ },
+  { name: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{20,}/ },
+  { name: "gitlab-token", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
+  { name: "dockerhub-token", regex: /\bdckr_(?:pat|oat)_[A-Za-z0-9_-]{10,}/ },
+  { name: "resend-key", regex: /\bre_[A-Za-z0-9]{8,}_[A-Za-z0-9]{10,}/ },
+  { name: "runpod-key", regex: /\brpa_[A-Za-z0-9]{30,}/ },
+  { name: "sentry-token", regex: /\bsntrys_[A-Za-z0-9+/=_-]{20,}/ },
+  { name: "vercel-token", regex: /\bvc[kp]_[A-Za-z0-9]{20,}/ },
+  { name: "huggingface-token", regex: /\bhf_[A-Za-z0-9]{30,}/ },
+  { name: "npm-token", regex: /\bnpm_[A-Za-z0-9]{30,}/ },
+  { name: "voyage-key", regex: /\bpa-[A-Za-z0-9_-]{30,}/ },
+  { name: "google-api-key", regex: /\bAIza[A-Za-z0-9_-]{30,}/ },
+  { name: "sovrgpt-key", regex: /\bsov_[a-f0-9]{40,}/ },
+  { name: "prometheus-key", regex: /\bprom_(?:live|test)_[A-Za-z0-9]{10,}/ },
+  { name: "aws-access-key", regex: /\bAKIA[A-Z0-9]{16}\b/ },
+  { name: "jwt", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/ },
+  { name: "private-key-block", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { name: "authorization-header", regex: /\bAuthorization:\s*(?:Bearer|Basic)\s+\S{8,}/i },
+  {
+    name: "connection-string-credentials",
+    regex: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^\s/@:]+:[^\s/@]+@/i
+  }
+];
+function findSecretPatterns(text) {
+  const hits = [];
+  for (const p of SECRET_PATTERNS) {
+    if (p.regex.test(text))
+      hits.push(p.name);
+  }
+  return hits;
+}
+var SECRET_VALUE_ERROR = "memory value matches the secret deny-list and was rejected";
+function assertNoSecrets(text) {
+  const hits = findSecretPatterns(text);
+  if (hits.length > 0) {
+    throw new Error(`${SECRET_VALUE_ERROR} (pattern: ${hits.join(", ")}).`);
+  }
+}
+
+// dist/recorder.js
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+var SPOOL_VERSION = 1;
+var SECRET_PATTERN_SOURCES = [
+  "sk-proj-[A-Za-z0-9_-]{20,}",
+  "sk-ant-[A-Za-z0-9_-]{20,}",
+  "\\bsbp?_[A-Za-z0-9]{20,}",
+  "\\bgh[pousr]_[A-Za-z0-9]{20,}",
+  "\\bglpat-[A-Za-z0-9_-]{20,}",
+  "\\bdckr_(?:pat|oat)_[A-Za-z0-9_-]{10,}",
+  "\\bre_[A-Za-z0-9]{8,}_[A-Za-z0-9]{10,}",
+  "\\brpa_[A-Za-z0-9]{30,}",
+  "\\bsntrys_[A-Za-z0-9+/=_-]{20,}",
+  "\\bvc[kp]_[A-Za-z0-9]{20,}",
+  "\\bhf_[A-Za-z0-9]{30,}",
+  "\\bnpm_[A-Za-z0-9]{30,}",
+  "\\bpa-[A-Za-z0-9_-]{30,}",
+  "\\bAIza[A-Za-z0-9_-]{30,}",
+  "\\bsov_[a-f0-9]{40,}",
+  "\\bprom_(?:live|test)_[A-Za-z0-9]{10,}",
+  "\\bAKIA[A-Z0-9]{16}\\b",
+  "\\beyJ[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{5,}",
+  "-----BEGIN [A-Z ]*PRIVATE KEY-----",
+  "\\b(?:postgres(?:ql)?|mysql|mongodb(?:\\+srv)?|redis|amqp)://[^\\s/@:]+:[^\\s/@]+@"
+];
+var REDACT_RE = new RegExp(`(${SECRET_PATTERN_SOURCES.join(")|(")})`, "gi");
+var EVENT_CAP_BYTES = 4 * 1024;
+var SPOOL_CAP_BYTES = 4 * 1024 * 1024;
+function recorderRoot(env = process.env) {
+  const base = env.PROMETHEUS_DIR && env.PROMETHEUS_DIR !== "" ? env.PROMETHEUS_DIR : join5(homedir4(), ".prometheus");
+  return join5(base, "recorder");
+}
+function sanitizeSegment(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128) || "_";
+}
+function parseSpool(raw) {
+  const lines = raw.split("\n");
+  const events = [];
+  let droppedPartialTail = false;
+  let ended = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "")
+      continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj && typeof obj.event === "string" && typeof obj.sessionId === "string") {
+        events.push({ ...obj, seq: i });
+        if (obj.event === "session_end")
+          ended = true;
+      }
+    } catch {
+      if (i === lines.length - 1)
+        droppedPartialTail = true;
+    }
+  }
+  return { events, droppedPartialTail, ended };
+}
+var RECORDER_HOOK_FILENAME = "prometheus-recorder-hook.mjs";
+var RECORDER_HOOK_SCRIPT = String.raw`#!/usr/bin/env node
+// Prometheus Session Recorder hook (Claude Code). Appends ONE diet+redacted
+// JSONL event per invocation to ~/.prometheus/recorder/<projectId>/<sessionId>.jsonl.
+// Pure node stdlib, no deps. EXITS 0 ON EVERY PATH — a recorder failure must
+// never disturb a coding session. Managed by prom.codes (memory-mcp recorder_setup).
+import { appendFileSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+
+const SPOOL_CAP = ${SPOOL_CAP_BYTES};
+const EVENT_CAP = ${EVENT_CAP_BYTES};
+const SECRET_SOURCES = ${JSON.stringify(SECRET_PATTERN_SOURCES)};
+const REDACT = new RegExp("(" + SECRET_SOURCES.join(")|(") + ")", "gi");
+
+function redact(s) { return String(s).replace(REDACT, "[redacted]"); }
+function clip(s, n) {
+  const str = typeof s === "string" ? s : (s === undefined ? "" : JSON.stringify(s));
+  return str.length > n ? str.slice(0, n) + "…" : str;
+}
+function sanitize(s) { return String(s).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128) || "_"; }
+function sensitivePath(p) {
+  const s = String(p).replace(/\\/g, "/").toLowerCase();
+  const base = s.slice(s.lastIndexOf("/") + 1);
+  if (/^\.env(\..+)?$/.test(base)) return true;
+  if (base === "id_rsa" || base === "id_dsa" || base === "id_ecdsa" || base === "id_ed25519") return true;
+  if (/\.(pem|key|pfx|p12|keystore)$/.test(base)) return true;
+  if (/(^|\/)(secrets?|credentials?)(\/|$)/.test(s)) return true;
+  return false;
+}
+function projectIdOf(root) { return createHash("sha256").update(String(root)).digest("hex").slice(0, 16); }
+
+function dietTool(toolName, inp, result) {
+  const tool = toolName; inp = inp || {};
+  const fp = typeof inp.file_path === "string" ? inp.file_path : undefined;
+  if (fp !== undefined && sensitivePath(fp)) return { tool: tool, note: "[skipped: sensitive path]" };
+  if (tool === "Edit" || tool === "Write" || tool === "NotebookEdit") {
+    return { tool: tool, file_path: fp, oldPreview: clip(inp.old_string || "", 100), newPreview: clip(inp.new_string || inp.content || "", 100) };
+  }
+  if (tool === "Bash") {
+    const r = result || {};
+    return { tool: tool, command: clip(inp.command, 300), stdout: clip(r.stdout, 500), stderr: clip(r.stderr, 200), exitCode: typeof r.exitCode === "number" ? r.exitCode : (r.exit_code != null ? r.exit_code : null) };
+  }
+  if (tool === "Read" || tool === "Glob" || tool === "Grep" || tool === "LS") {
+    return { tool: tool, target: clip(inp.file_path || inp.path || inp.pattern || "", 200) };
+  }
+  return { tool: tool, resultPreview: clip(result, 500) };
+}
+
+function finalize(payload) {
+  const s = redact(JSON.stringify(payload));
+  return s.length > EVENT_CAP ? s.slice(0, EVENT_CAP) + "…" : s;
+}
+
+// Read the last assistant text from a Claude Code transcript JSONL (best-effort).
+function lastAssistantText(transcriptPath) {
+  try {
+    if (!transcriptPath) return "";
+    const raw = readFileSync(transcriptPath, "utf8");
+    const lines = raw.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const ln = lines[i].trim(); if (ln === "") continue;
+      let obj; try { obj = JSON.parse(ln); } catch { continue; }
+      const msg = obj && obj.message ? obj.message : obj;
+      const role = obj && obj.type ? obj.type : (msg && msg.role);
+      if (role === "assistant" && msg) {
+        const c = msg.content;
+        if (typeof c === "string") return c;
+        if (Array.isArray(c)) {
+          const txt = c.filter(function (b) { return b && b.type === "text"; }).map(function (b) { return b.text; }).join("\n");
+          if (txt) return txt;
+        }
+      }
+    }
+  } catch { /* best-effort */ }
+  return "";
+}
+
+function run(input) {
+  let p = {};
+  try { p = JSON.parse(String(input || "").replace(/^/, "").trim() || "{}"); } catch { return; }
+  const eventName = typeof p.hook_event_name === "string" ? p.hook_event_name : "";
+  const sessionId = typeof p.session_id === "string" && p.session_id !== "" ? p.session_id : "unknown";
+  const root = (process.env.CLAUDE_PROJECT_DIR && process.env.CLAUDE_PROJECT_DIR !== "") ? process.env.CLAUDE_PROJECT_DIR : (p.cwd || process.cwd());
+  const projectId = projectIdOf(root);
+
+  let event = null; let payload = {};
+  if (eventName === "SessionStart") { event = "session_start"; payload = { cwd: root, model: p.model || null, source: p.source || null }; }
+  else if (eventName === "UserPromptSubmit") { event = "user_message"; payload = { text: clip(p.prompt || "", 4000) }; }
+  else if (eventName === "PostToolUse") { event = "tool_use"; payload = dietTool(p.tool_name || "", p.tool_input, p.tool_response); }
+  else if (eventName === "Stop" || eventName === "SubagentStop") { event = "assistant_message"; payload = { text: clip(lastAssistantText(p.transcript_path || ""), 4000) }; }
+  else if (eventName === "SessionEnd") { event = "session_end"; payload = { reason: p.reason || null }; }
+  else return;
+
+  const base = join((process.env.PROMETHEUS_DIR && process.env.PROMETHEUS_DIR !== "") ? process.env.PROMETHEUS_DIR : join(homedir(), ".prometheus"), "recorder", sanitize(projectId));
+  const file = join(base, sanitize(sessionId) + ".jsonl");
+
+  // Per-session cap: once the spool is large, keep session_end + messages but
+  // drop further tool_use (the noisiest, most numerous events).
+  try {
+    if (event === "tool_use") {
+      let size = 0; try { size = statSync(file).size; } catch { size = 0; }
+      if (size >= SPOOL_CAP) return;
+    }
+  } catch { /* stat failure -> keep going */ }
+
+  const line = JSON.stringify({ v: ${SPOOL_VERSION}, ts: new Date().toISOString(), projectId: projectId, sessionId: sessionId, agent: "claude-code", event: event, payload: JSON.parse(finalize(payload)) }) + "\n";
+  try { mkdirSync(base, { recursive: true }); appendFileSync(file, line, { encoding: "utf8", flag: "a" }); } catch { /* never throw */ }
+}
+
+if (process.stdin.isTTY) { process.exit(0); }
+else {
+  let raw = "";
+  process.stdin.on("data", function (c) { raw += c; });
+  process.stdin.on("end", function () { try { run(raw); } catch { /* swallow */ } process.exit(0); });
+  process.stdin.on("error", function () { process.exit(0); });
+}
+`;
+var RECORDER_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "SessionEnd"
+];
+var RECORDER_HOOK_TIMEOUT = 5;
+function resolveSettingsPath(opts) {
+  if (opts.settingsPathOverride)
+    return opts.settingsPathOverride;
+  const root = opts.projectRoot ?? process.cwd();
+  if (opts.scope === "project")
+    return join5(root, ".claude", "settings.json");
+  if (opts.scope === "project-local")
+    return join5(root, ".claude", "settings.local.json");
+  return join5(homedir4(), ".claude", "settings.json");
+}
+function resolveHookPath(opts) {
+  const dir = opts.hookDirOverride ?? join5(homedir4(), ".prometheus", "hooks");
+  return join5(dir, RECORDER_HOOK_FILENAME);
+}
+function ownsEntry(entry) {
+  return Array.isArray(entry.hooks) && entry.hooks.some((h) => typeof h?.command === "string" && h.command.includes(RECORDER_HOOK_FILENAME));
+}
+function readSettings(settingsPath) {
+  if (!existsSync2(settingsPath))
+    return {};
+  const raw = readFileSync2(settingsPath, "utf8").replace(/^/, "");
+  if (raw.trim() === "")
+    return {};
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`${settingsPath} does not contain a JSON object.`);
+  }
+  return parsed;
+}
+function backupSettings(settingsPath) {
+  if (!existsSync2(settingsPath))
+    return null;
+  const d = /* @__PURE__ */ new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  const bak = `${settingsPath}.prom-backup-${stamp}`;
+  copyFileSync(settingsPath, bak);
+  return bak;
+}
+function recorderStatus(opts = {}) {
+  const settingsPath = resolveSettingsPath(opts);
+  const hookPath = resolveHookPath(opts);
+  let installedEvents = [];
+  try {
+    const settings = readSettings(settingsPath);
+    for (const ev of RECORDER_EVENTS) {
+      const arr = settings.hooks?.[ev];
+      if (Array.isArray(arr) && arr.some(ownsEntry))
+        installedEvents.push(ev);
+    }
+  } catch {
+    installedEvents = [];
+  }
+  return {
+    installed: installedEvents.length > 0,
+    scope: opts.scope ?? "user",
+    events: installedEvents,
+    settingsPath,
+    hookScriptPresent: existsSync2(hookPath)
+  };
+}
+function applyRecorderHooks(opts = {}) {
+  const scope = opts.scope ?? "user";
+  const settingsPath = resolveSettingsPath(opts);
+  const hookPath = resolveHookPath(opts);
+  const command = `node "${hookPath.replace(/\\/g, "/")}"`;
+  const settings = readSettings(settingsPath);
+  const backup = backupSettings(settingsPath);
+  settings.hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  for (const ev of RECORDER_EVENTS) {
+    const arr = settings.hooks[ev];
+    if (Array.isArray(arr)) {
+      const kept = arr.filter((e) => !ownsEntry(e));
+      if (kept.length === 0)
+        delete settings.hooks[ev];
+      else
+        settings.hooks[ev] = kept;
+    }
+  }
+  if (!opts.uninstall) {
+    mkdirSync2(dirname3(hookPath), { recursive: true });
+    writeFileSync2(hookPath, RECORDER_HOOK_SCRIPT, "utf8");
+    for (const ev of RECORDER_EVENTS) {
+      const matcher = ev === "PostToolUse" ? "*" : "";
+      (settings.hooks[ev] ??= []).push({
+        matcher,
+        hooks: [{ type: "command", command, timeout: RECORDER_HOOK_TIMEOUT }]
+      });
+    }
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0)
+    delete settings.hooks;
+  mkdirSync2(dirname3(settingsPath), { recursive: true });
+  writeFileSync2(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  JSON.parse(readFileSync2(settingsPath, "utf8"));
+  return {
+    action: opts.uninstall ? "uninstalled" : "installed",
+    settingsPath,
+    scope,
+    hookPath,
+    events: opts.uninstall ? [] : [...RECORDER_EVENTS],
+    backup,
+    note: opts.uninstall ? "Removed the Prometheus session recorder hooks. Reload your Claude Code window(s)." : "Installed the session recorder (opt-in). Reload / restart your Claude Code window(s). It records LOCALLY to ~/.prometheus/recorder; nothing is uploaded. Uninstall anytime with recorder_setup { uninstall: true }."
+  };
+}
+
 // dist/rrf.js
 function reciprocalRankFusion(lists, options = {}) {
   const k = options.k ?? 60;
@@ -1993,6 +2411,54 @@ CREATE TRIGGER IF NOT EXISTS agent_memory_vec_ad AFTER DELETE ON agent_memory BE
   DELETE FROM agent_memory_vec WHERE record_id = old.id;
 END;
 `;
+var RECORDER_SCHEMA = `
+CREATE TABLE IF NOT EXISTS agent_sessions (
+  session_id  TEXT NOT NULL,
+  project_id  TEXT NOT NULL,
+  agent       TEXT NOT NULL,
+  cwd         TEXT,
+  model       TEXT,
+  started_at  TEXT NOT NULL,
+  ended_at    TEXT,
+  stats       TEXT,
+  summary     TEXT,
+  curated_at  TEXT,
+  PRIMARY KEY (project_id, session_id)
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON agent_sessions (project_id, started_at DESC);
+
+CREATE TABLE IF NOT EXISTS session_events (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT NOT NULL,
+  session_id  TEXT NOT NULL,
+  seq         INTEGER NOT NULL,
+  ts          TEXT NOT NULL,
+  event_type  TEXT NOT NULL,
+  tool_name   TEXT,
+  content     TEXT NOT NULL,
+  metadata    TEXT,
+  UNIQUE (project_id, session_id, seq)
+);
+CREATE INDEX IF NOT EXISTS idx_events_session ON session_events (project_id, session_id, seq);
+`;
+var RECORDER_FTS_SCHEMA = `
+CREATE VIRTUAL TABLE IF NOT EXISTS session_events_fts USING fts5(
+  content, tool_name,
+  content='session_events',
+  content_rowid='id',
+  tokenize='unicode61'
+);
+CREATE TRIGGER IF NOT EXISTS session_events_ai AFTER INSERT ON session_events BEGIN
+  INSERT INTO session_events_fts (rowid, content, tool_name)
+  VALUES (new.id, new.content, new.tool_name);
+END;
+CREATE TRIGGER IF NOT EXISTS session_events_ad AFTER DELETE ON session_events BEGIN
+  INSERT INTO session_events_fts (session_events_fts, rowid, content, tool_name)
+  VALUES ('delete', old.id, old.content, old.tool_name);
+END;
+`;
+var DEFAULT_RETENTION_DAYS = 90;
+var DEFAULT_MAX_SESSIONS = 300;
 function vectorToBlob(vector) {
   return Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
 }
@@ -2043,6 +2509,70 @@ function rowToRecord(row) {
     updatedAt: row.updated_at
   };
 }
+function sessionRowToRecord(r) {
+  return {
+    sessionId: r.session_id,
+    projectId: r.project_id,
+    agent: r.agent,
+    cwd: r.cwd,
+    model: r.model,
+    startedAt: r.started_at,
+    endedAt: r.ended_at,
+    stats: r.stats ? JSON.parse(r.stats) : null,
+    summary: r.summary,
+    curatedAt: r.curated_at
+  };
+}
+function strField(payload, key) {
+  const v = payload[key];
+  return typeof v === "string" ? v : null;
+}
+function recorderContent(ev) {
+  let content;
+  let toolName = null;
+  if (ev.event === "user_message" || ev.event === "assistant_message") {
+    content = strField(ev.payload, "text") ?? "";
+  } else if (ev.event === "tool_use") {
+    toolName = strField(ev.payload, "tool");
+    content = JSON.stringify(ev.payload);
+  } else {
+    content = JSON.stringify(ev.payload);
+  }
+  if (findSecretPatterns(content).length > 0)
+    content = "[dropped: secret-like]";
+  return { content, toolName };
+}
+function computeSessionStats(evs) {
+  let toolCount = 0;
+  const tools = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set();
+  for (const ev of evs) {
+    if (ev.event !== "tool_use")
+      continue;
+    toolCount++;
+    const t = strField(ev.payload, "tool");
+    if (t !== null)
+      tools.add(t);
+    const fp = strField(ev.payload, "file_path");
+    if (fp !== null)
+      files.add(fp);
+  }
+  return { toolCount, toolsUsed: [...tools], filesTouched: [...files] };
+}
+function condenseEvent(r) {
+  let content = r.content;
+  if (r.event_type === "tool_use") {
+    content = r.tool_name ? `[tool] ${r.tool_name}: ${r.content}` : `[tool] ${r.content}`;
+  }
+  return { seq: r.seq, ts: r.ts, eventType: r.event_type, toolName: r.tool_name, content };
+}
+function intFromEnv(env, name, def) {
+  const raw = env[name];
+  if (raw === void 0 || raw === "")
+    return def;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : def;
+}
 var SqliteMemoryBackend = class {
   db;
   embedder;
@@ -2057,14 +2587,16 @@ var SqliteMemoryBackend = class {
   closed = false;
   constructor(dbPath, opts = {}) {
     if (dbPath !== ":memory:") {
-      mkdirSync2(dirname2(dbPath), { recursive: true });
+      mkdirSync3(dirname4(dbPath), { recursive: true });
     }
-    this.db = new Database(dbPath);
+    this.db = new Database(dbPath, { ...nativeBindingOption() });
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
     this.db.exec(SCHEMA);
     this.db.exec(FTS_SCHEMA);
     this.db.exec(VEC_SCHEMA);
+    this.db.exec(RECORDER_SCHEMA);
+    this.db.exec(RECORDER_FTS_SCHEMA);
     this.db.exec(`INSERT INTO agent_memory_fts (agent_memory_fts) VALUES ('rebuild')`);
     this.embedder = opts.embedder;
     this.reranker = opts.reranker;
@@ -2492,6 +3024,183 @@ ${h.record.value}`
     this.audit("consolidate", { scope: input.scope, scopeId: input.scopeId }, `records=${written.length}`);
     return written;
   }
+  // ===================================================================
+  // Session Recorder (M1) — RecorderStore implementation.
+  // ===================================================================
+  /**
+   * Ingest every spool file for `projectId` under the recorder root: parse,
+   * write events idempotently (`INSERT OR IGNORE` on `(project_id, session_id,
+   * seq)`), maintain the session header, and DELETE the spool of any session that
+   * has ended (its `session_end` is persisted). Best-effort per file — a corrupt
+   * spool never aborts the sweep. Returns roll-up counts.
+   */
+  async ingestSpoolDir(projectId, env = process.env) {
+    const dir = join6(recorderRoot(env), sanitizeSegment(projectId));
+    let sessions = 0;
+    let events = 0;
+    let deletedSpools = 0;
+    let files;
+    try {
+      files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      return { sessions: 0, events: 0, deletedSpools: 0 };
+    }
+    for (const file of files) {
+      const full = join6(dir, file);
+      try {
+        const raw = readFileSync3(full, "utf8");
+        const parsed = parseSpool(raw);
+        if (parsed.events.length === 0) {
+          continue;
+        }
+        const written = this.ingestSessionEvents(projectId, parsed.events);
+        events += written;
+        sessions += 1;
+        if (parsed.ended) {
+          try {
+            rmSync2(full, { force: true });
+            deletedSpools += 1;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return { sessions, events, deletedSpools };
+  }
+  /**
+   * Write one session's parsed events: ensure the header, insert events
+   * idempotently (re-scanning each content for secrets → `[dropped]`), and set
+   * cwd/model (from `session_start`) + ended_at/stats (from `session_end`).
+   * Runs in a single transaction. Returns the number of NEW event rows.
+   */
+  ingestSessionEvents(projectId, evs) {
+    if (evs.length === 0)
+      return 0;
+    const sessionId = evs[0].sessionId;
+    const agent = evs[0].agent || "claude-code";
+    const firstTs = evs[0].ts;
+    const ensureHeader = this.db.prepare(`INSERT OR IGNORE INTO agent_sessions (session_id, project_id, agent, started_at)
+       VALUES (?, ?, ?, ?)`);
+    const insertEvent = this.db.prepare(`INSERT OR IGNORE INTO session_events
+         (project_id, session_id, seq, ts, event_type, tool_name, content, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+    const setStart = this.db.prepare(`UPDATE agent_sessions SET cwd = ?, model = ?, started_at = ? WHERE project_id = ? AND session_id = ?`);
+    const setEnd = this.db.prepare(`UPDATE agent_sessions SET ended_at = ?, stats = ? WHERE project_id = ? AND session_id = ?`);
+    let written = 0;
+    const tx = this.db.transaction(() => {
+      ensureHeader.run(sessionId, projectId, agent, firstTs);
+      for (const ev of evs) {
+        const { content, toolName } = recorderContent(ev);
+        const res = insertEvent.run(projectId, sessionId, ev.seq, ev.ts, ev.event, toolName, content, null);
+        written += res.changes;
+        if (ev.event === "session_start") {
+          const cwd = strField(ev.payload, "cwd");
+          const model = strField(ev.payload, "model");
+          setStart.run(cwd, model, ev.ts, projectId, sessionId);
+        }
+      }
+      const end = evs.find((e) => e.event === "session_end");
+      if (end !== void 0) {
+        setEnd.run(end.ts, JSON.stringify(computeSessionStats(evs)), projectId, sessionId);
+      }
+    });
+    tx();
+    return written;
+  }
+  async listSessions(projectId, limit = 20) {
+    const rows = this.db.prepare(`SELECT * FROM agent_sessions WHERE project_id = ? ORDER BY started_at DESC LIMIT ?`).all(projectId, limit);
+    return rows.map(sessionRowToRecord);
+  }
+  async getSession(projectId, sessionId, maxChars = 2e4) {
+    const header = this.db.prepare(`SELECT * FROM agent_sessions WHERE project_id = ? AND session_id = ?`).get(projectId, sessionId);
+    if (header === void 0)
+      return null;
+    const rows = this.db.prepare(`SELECT seq, ts, event_type, tool_name, content FROM session_events
+         WHERE project_id = ? AND session_id = ? ORDER BY seq ASC`).all(projectId, sessionId);
+    const events = [];
+    let used = 0;
+    let truncated = false;
+    for (const r of rows) {
+      const line = condenseEvent(r);
+      if (used + line.content.length > maxChars && events.length > 0) {
+        truncated = true;
+        break;
+      }
+      used += line.content.length;
+      events.push(line);
+    }
+    return { session: sessionRowToRecord(header), events, truncated };
+  }
+  async searchSessions(projectId, query, limit = 20) {
+    const match = toFtsQuery(query);
+    if (match === "")
+      return [];
+    const rows = this.db.prepare(`SELECT e.session_id AS session_id, e.ts AS ts, e.event_type AS event_type,
+                snippet(session_events_fts, 0, '\xAB', '\xBB', ' \u2026 ', 12) AS snip
+         FROM session_events_fts f
+         JOIN session_events e ON e.id = f.rowid
+         WHERE session_events_fts MATCH ? AND e.project_id = ?
+         ORDER BY rank LIMIT ?`).all(match, projectId, limit);
+    return rows.map((r) => ({
+      sessionId: r.session_id,
+      ts: r.ts,
+      eventType: r.event_type,
+      snippet: r.snip
+    }));
+  }
+  /** M2: sessions that ended but have not been curated yet (newest first). */
+  async listUncuratedSessions(projectId, limit = 10) {
+    const rows = this.db.prepare(`SELECT * FROM agent_sessions
+         WHERE project_id = ? AND ended_at IS NOT NULL AND curated_at IS NULL
+         ORDER BY started_at DESC LIMIT ?`).all(projectId, limit);
+    return rows.map(sessionRowToRecord);
+  }
+  /** M2: store a session's distilled summary + stamp `curated_at` (idempotency gate). */
+  async setCuration(projectId, sessionId, summary) {
+    this.db.prepare(`UPDATE agent_sessions SET summary = ?, curated_at = ? WHERE project_id = ? AND session_id = ?`).run(summary, (/* @__PURE__ */ new Date()).toISOString(), projectId, sessionId);
+  }
+  async recorderTotals(projectId) {
+    const s = this.db.prepare(`SELECT COUNT(*) AS n FROM agent_sessions WHERE project_id = ?`).get(projectId);
+    const e = this.db.prepare(`SELECT COUNT(*) AS n FROM session_events WHERE project_id = ?`).get(projectId);
+    return { sessions: s.n, events: e.n };
+  }
+  /**
+   * Apply retention (spec §3.7): keep at most `maxSessions` newest sessions per
+   * project (older sessions + their events are dropped), and drop events older
+   * than `retentionDays`. Curated sessions (`curated_at` set — M2) older than 14
+   * days keep only their header+summary (events dropped). Env overrides:
+   * `PROMETHEUS_RECORDER_RETENTION_DAYS` / `PROMETHEUS_RECORDER_MAX_SESSIONS`.
+   */
+  async applyRecorderRetention(env = process.env) {
+    const days = intFromEnv(env, "PROMETHEUS_RECORDER_RETENTION_DAYS", DEFAULT_RETENTION_DAYS);
+    const maxSessions = intFromEnv(env, "PROMETHEUS_RECORDER_MAX_SESSIONS", DEFAULT_MAX_SESSIONS);
+    const cutoff = new Date(Date.now() - days * 864e5).toISOString();
+    const curatedCutoff = new Date(Date.now() - 14 * 864e5).toISOString();
+    let prunedSessions = 0;
+    let prunedEvents = 0;
+    const tx = this.db.transaction(() => {
+      const overflow = this.db.prepare(`SELECT project_id, session_id FROM (
+             SELECT project_id, session_id,
+                    ROW_NUMBER() OVER (PARTITION BY project_id ORDER BY started_at DESC) AS rn
+             FROM agent_sessions
+           ) WHERE rn > ?`).all(maxSessions);
+      const delEvents = this.db.prepare(`DELETE FROM session_events WHERE project_id = ? AND session_id = ?`);
+      const delSession = this.db.prepare(`DELETE FROM agent_sessions WHERE project_id = ? AND session_id = ?`);
+      for (const o of overflow) {
+        prunedEvents += delEvents.run(o.project_id, o.session_id).changes;
+        prunedSessions += delSession.run(o.project_id, o.session_id).changes;
+      }
+      prunedEvents += this.db.prepare(`DELETE FROM session_events WHERE ts < ?`).run(cutoff).changes;
+      const curated = this.db.prepare(`SELECT project_id, session_id FROM agent_sessions
+           WHERE curated_at IS NOT NULL AND curated_at < ?`).all(curatedCutoff);
+      for (const c of curated) {
+        prunedEvents += delEvents.run(c.project_id, c.session_id).changes;
+      }
+    });
+    tx();
+    return { prunedSessions, prunedEvents };
+  }
   async close() {
     if (this.closed)
       return;
@@ -2510,7 +3219,7 @@ function projectIdFor(workspaceRoot) {
   return createHash("sha256").update(abs).digest("hex").slice(0, 16);
 }
 function defaultMemoryDbPath() {
-  return join4(homedir4(), ".prometheus", "memory.db");
+  return join7(homedir5(), ".prometheus", "memory.db");
 }
 function intEnv(env, name, def) {
   const raw = env[name];
@@ -2778,6 +3487,7 @@ function composeFromEnv(opts) {
   });
   return {
     backend,
+    recorder: backend,
     workspaceRoot,
     projectId,
     projectName,
@@ -2799,47 +3509,57 @@ function composeFromEnv(opts) {
   };
 }
 
-// dist/roots.js
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-async function rootFromClient(server, timeoutMs = 2500) {
-  let supportsRoots = false;
-  try {
-    supportsRoots = server.getClientCapabilities()?.roots != null;
-  } catch {
-    return null;
-  }
-  if (!supportsRoots)
-    return null;
-  let res;
-  try {
-    res = await server.listRoots(void 0, { timeout: timeoutMs });
-  } catch {
-    return null;
-  }
-  const roots = res?.roots ?? [];
-  for (const r of roots) {
-    const uri = typeof r?.uri === "string" ? r.uri : "";
-    if (uri.startsWith("file://")) {
-      try {
-        return fileURLToPath2(uri);
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-
-// dist/server.js
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// dist/tools.js
-import { z } from "zod";
-
 // dist/project-files.js
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 var MEMORIES_DIR = path.join(".prometheus", "memories");
 var PROJECT_FILE_SOURCE = "import:project-file";
+var VALID_TYPES = /* @__PURE__ */ new Set(["semantic", "procedural", "episodic", "working"]);
+function serializeMemoryFile(f) {
+  const lines = ["---", `type: ${f.type}`];
+  if (f.tags && f.tags.length > 0)
+    lines.push(`tags: [${f.tags.join(", ")}]`);
+  if (f.confidence !== void 0)
+    lines.push(`confidence: ${f.confidence}`);
+  lines.push(`updated: ${f.updated ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  if (f.source !== void 0 && f.source !== "")
+    lines.push(`source: ${f.source}`);
+  lines.push("---", "", f.value.replace(/\s+$/, ""), "");
+  return lines.join("\n");
+}
+function parseMemoryFile(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
+  if (m === null)
+    return { type: "semantic", tags: void 0, confidence: void 0, source: void 0, body: content.trim() };
+  const fm = m[1] ?? "";
+  const body = content.slice(m[0].length).replace(/^\r?\n/, "").trim();
+  let type = "semantic";
+  let tags;
+  let confidence;
+  let source;
+  for (const line of fm.split(/\r?\n/)) {
+    const kv = /^([A-Za-z_]+)\s*:\s*(.*)$/.exec(line.trim());
+    if (kv === null)
+      continue;
+    const key = kv[1].toLowerCase();
+    const val = kv[2].trim();
+    if (key === "type" && VALID_TYPES.has(val))
+      type = val;
+    else if (key === "tags") {
+      const inner = val.replace(/^\[|\]$/g, "");
+      const parsed = inner.split(",").map((t) => t.trim().replace(/^["']|["']$/g, "")).filter((t) => t !== "");
+      if (parsed.length > 0)
+        tags = parsed;
+    } else if (key === "confidence") {
+      const n = Number.parseFloat(val);
+      if (Number.isFinite(n) && n >= 0 && n <= 1)
+        confidence = n;
+    } else if (key === "source" && val !== "")
+      source = val;
+  }
+  return { type, tags, confidence, source, body };
+}
 function memoriesDir(workspaceRoot) {
   return path.join(workspaceRoot, MEMORIES_DIR);
 }
@@ -2853,13 +3573,25 @@ function keyToFilename(key) {
 function filenameToKey(filename) {
   return filename.replace(/\.md$/i, "");
 }
-async function writeProjectFile(workspaceRoot, key, content) {
+async function writeMemoryFile(workspaceRoot, f) {
   const dir = memoriesDir(workspaceRoot);
   await fs.mkdir(dir, { recursive: true });
-  const file = path.join(dir, keyToFilename(key));
-  await fs.writeFile(file, content, "utf-8");
+  const file = path.join(dir, keyToFilename(f.key));
+  await fs.writeFile(file, serializeMemoryFile(f), "utf-8");
   return file;
 }
+function memoriesShared(workspaceRoot) {
+  const probe = path.join(MEMORIES_DIR, ".prom-shared-probe");
+  try {
+    execFileSync("git", ["-C", workspaceRoot, "check-ignore", "-q", probe], {
+      stdio: ["ignore", "ignore", "ignore"],
+      timeout: 3e3
+    });
+    return false;
+  } catch (err) {
+    return err.status === 1;
+  }
+}
 async function deleteProjectFile(workspaceRoot, key) {
   const file = path.join(memoriesDir(workspaceRoot), keyToFilename(key));
   try {
@@ -2893,67 +3625,196 @@ async function listProjectFiles(workspaceRoot) {
 async function syncProjectFiles(backend, input) {
   const files = await listProjectFiles(input.workspaceRoot);
   const scopeId = input.scopeId ?? input.projectId;
+  const fileKeys = /* @__PURE__ */ new Set();
+  const skippedKeys = /* @__PURE__ */ new Set();
+  const skipped = [];
+  let synced = 0;
   for (const file of files) {
+    const parsed = parseMemoryFile(file.content);
+    if (findSecretPatterns(parsed.body).length > 0) {
+      skipped.push({ key: file.key, reason: "secret-like content" });
+      skippedKeys.add(file.key);
+      continue;
+    }
+    fileKeys.add(file.key);
     await backend.write({
       projectId: input.projectId,
       scope: "project",
       scopeId,
-      type: "semantic",
+      type: parsed.type,
       key: file.key,
-      value: file.content,
+      value: parsed.body,
+      ...parsed.tags !== void 0 ? { tags: parsed.tags } : {},
+      ...parsed.confidence !== void 0 ? { confidence: parsed.confidence } : {},
       source: PROJECT_FILE_SOURCE
     });
+    synced++;
   }
-  return files.length;
+  let pruned = 0;
+  const existing = await backend.list({ projectId: input.projectId, scope: "project" });
+  for (const rec of existing) {
+    if (rec.source !== PROJECT_FILE_SOURCE)
+      continue;
+    if (fileKeys.has(rec.key) || skippedKeys.has(rec.key))
+      continue;
+    await backend.delete({
+      projectId: input.projectId,
+      scope: "project",
+      scopeId,
+      type: rec.type,
+      key: rec.key
+    });
+    pruned++;
+  }
+  return { synced, pruned, skipped };
 }
 
-// dist/security.js
-var SECRET_PATTERNS = [
-  { name: "openai-key", regex: /\bsk-proj-[A-Za-z0-9_-]{20,}/ },
-  { name: "anthropic-key", regex: /\bsk-ant-[A-Za-z0-9_-]{20,}/ },
-  { name: "supabase-token", regex: /\bsbp?_[A-Za-z0-9]{20,}/ },
-  { name: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{20,}/ },
-  { name: "gitlab-token", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
-  { name: "dockerhub-token", regex: /\bdckr_(?:pat|oat)_[A-Za-z0-9_-]{10,}/ },
-  { name: "resend-key", regex: /\bre_[A-Za-z0-9]{8,}_[A-Za-z0-9]{10,}/ },
-  { name: "runpod-key", regex: /\brpa_[A-Za-z0-9]{30,}/ },
-  { name: "sentry-token", regex: /\bsntrys_[A-Za-z0-9+/=_-]{20,}/ },
-  { name: "vercel-token", regex: /\bvc[kp]_[A-Za-z0-9]{20,}/ },
-  { name: "huggingface-token", regex: /\bhf_[A-Za-z0-9]{30,}/ },
-  { name: "npm-token", regex: /\bnpm_[A-Za-z0-9]{30,}/ },
-  { name: "voyage-key", regex: /\bpa-[A-Za-z0-9_-]{30,}/ },
-  { name: "google-api-key", regex: /\bAIza[A-Za-z0-9_-]{30,}/ },
-  { name: "sovrgpt-key", regex: /\bsov_[a-f0-9]{40,}/ },
-  { name: "prometheus-key", regex: /\bprom_(?:live|test)_[A-Za-z0-9]{10,}/ },
-  { name: "aws-access-key", regex: /\bAKIA[A-Z0-9]{16}\b/ },
-  { name: "jwt", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/ },
-  { name: "private-key-block", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-  { name: "authorization-header", regex: /\bAuthorization:\s*(?:Bearer|Basic)\s+\S{8,}/i },
-  {
-    name: "connection-string-credentials",
-    regex: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^\s/@:]+:[^\s/@]+@/i
+// dist/curation.js
+function sessionLog(events) {
+  const lines = [];
+  for (const e of events) {
+    if (e.eventType === "user_message")
+      lines.push(`USER: ${e.content}`);
+    else if (e.eventType === "assistant_message")
+      lines.push(`ASSISTANT: ${e.content}`);
+    else if (e.eventType === "tool_use")
+      lines.push(e.content);
   }
-];
-function findSecretPatterns(text) {
-  const hits = [];
-  for (const p of SECRET_PATTERNS) {
-    if (p.regex.test(text))
-      hits.push(p.name);
+  return lines.join("\n");
+}
+async function curateSession(deps, sessionId) {
+  const { backend, recorder, extractor, projectId, workspaceRoot, mirrorToFiles } = deps;
+  const detail = await recorder.getSession(projectId, sessionId, 4e4);
+  if (detail === null)
+    return { curated: false, reason: "no such session" };
+  const log = sessionLog(detail.events);
+  if (log.trim() === "") {
+    await recorder.setCuration(projectId, sessionId, "");
+    return { curated: true, summary: "", facts: 0, procedures: 0 };
   }
-  return hits;
+  let result;
+  try {
+    result = await extractor.curate(log);
+  } catch {
+    return { curated: false, reason: "curation call failed" };
+  }
+  if (result.summary.trim() === "") {
+    return { curated: false, reason: "curator returned no summary (provider unavailable?)" };
+  }
+  const scope = "project";
+  const scopeId = scopeIdFor(scope, projectId);
+  const source = `curated:session:${sessionId}`;
+  const summary = findSecretPatterns(result.summary).length > 0 ? "[dropped: secret-like]" : result.summary;
+  await recorder.setCuration(projectId, sessionId, summary);
+  await backend.write({
+    projectId,
+    scope,
+    scopeId,
+    type: "episodic",
+    key: `session:${sessionId}`,
+    value: summary,
+    source
+  });
+  let factCount = 0;
+  for (const f of result.facts) {
+    try {
+      assertNoSecrets(`${f.key}
+${f.value}`);
+    } catch {
+      continue;
+    }
+    await backend.write({
+      projectId,
+      scope,
+      scopeId,
+      type: "semantic",
+      key: f.key,
+      value: f.value,
+      ...f.confidence !== void 0 ? { confidence: f.confidence } : {},
+      source
+    });
+    if (mirrorToFiles) {
+      try {
+        await writeMemoryFile(workspaceRoot, {
+          key: f.key,
+          type: "semantic",
+          value: f.value,
+          ...f.confidence !== void 0 ? { confidence: f.confidence } : {},
+          source
+        });
+      } catch {
+      }
+    }
+    factCount++;
+  }
+  let procCount = 0;
+  for (const p of result.procedures) {
+    try {
+      assertNoSecrets(`${p.key}
+${p.value}`);
+    } catch {
+      continue;
+    }
+    await backend.write({
+      projectId,
+      scope,
+      scopeId,
+      type: "procedural",
+      key: p.key,
+      value: p.value,
+      source
+    });
+    if (mirrorToFiles) {
+      try {
+        await writeMemoryFile(workspaceRoot, { key: p.key, type: "procedural", value: p.value, source });
+      } catch {
+      }
+    }
+    procCount++;
+  }
+  return { curated: true, summary, facts: factCount, procedures: procCount };
 }
-var SECRET_VALUE_ERROR = "memory value matches the secret deny-list and was rejected";
-function assertNoSecrets(text) {
-  const hits = findSecretPatterns(text);
-  if (hits.length > 0) {
-    throw new Error(`${SECRET_VALUE_ERROR} (pattern: ${hits.join(", ")}).`);
+
+// dist/roots.js
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+async function rootFromClient(server, timeoutMs = 2500) {
+  let supportsRoots = false;
+  try {
+    supportsRoots = server.getClientCapabilities()?.roots != null;
+  } catch {
+    return null;
+  }
+  if (!supportsRoots)
+    return null;
+  let res;
+  try {
+    res = await server.listRoots(void 0, { timeout: timeoutMs });
+  } catch {
+    return null;
+  }
+  const roots = res?.roots ?? [];
+  for (const r of roots) {
+    const uri = typeof r?.uri === "string" ? r.uri : "";
+    if (uri.startsWith("file://")) {
+      try {
+        return fileURLToPath2(uri);
+      } catch {
+      }
+    }
   }
+  return null;
 }
 
+// dist/server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// dist/tools.js
+import { z } from "zod";
+
 // dist/setup.js
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 var MEMORY_RUNTIMES = [
   "claude-code",
   "cursor",
@@ -2997,13 +3858,13 @@ alwaysApply: true
 var TARGETS = {
   "claude-code": { relPath: "CLAUDE.md", mode: "block", detect: "CLAUDE.md" },
   cursor: {
-    relPath: join6(".cursor", "rules", "prometheus-memory.mdc"),
+    relPath: join9(".cursor", "rules", "prometheus-memory.mdc"),
     mode: "file",
     fileContent: CURSOR_FRONTMATTER + withMarkers(RULE_BLOCK) + "\n",
     detect: ".cursor"
   },
   augment: {
-    relPath: join6(".augment", "rules", "prometheus-memory.md"),
+    relPath: join9(".augment", "rules", "prometheus-memory.md"),
     mode: "file",
     fileContent: withMarkers(RULE_BLOCK) + "\n",
     detect: ".augment"
@@ -3011,19 +3872,19 @@ var TARGETS = {
   agents: { relPath: "AGENTS.md", mode: "block", detect: "AGENTS.md" }
 };
 function detectRuntimes(workspaceRoot) {
-  const found = MEMORY_RUNTIMES.filter((rt) => existsSync(join6(workspaceRoot, TARGETS[rt].detect)));
+  const found = MEMORY_RUNTIMES.filter((rt) => existsSync3(join9(workspaceRoot, TARGETS[rt].detect)));
   return found.length > 0 ? found : ["agents"];
 }
 function existingRuntimes(workspaceRoot) {
-  return MEMORY_RUNTIMES.filter((rt) => existsSync(join6(workspaceRoot, TARGETS[rt].detect)));
+  return MEMORY_RUNTIMES.filter((rt) => existsSync3(join9(workspaceRoot, TARGETS[rt].detect)));
 }
 function installedRuntimes(workspaceRoot) {
   return MEMORY_RUNTIMES.filter((rt) => {
-    const p = join6(workspaceRoot, TARGETS[rt].relPath);
-    if (!existsSync(p))
+    const p = join9(workspaceRoot, TARGETS[rt].relPath);
+    if (!existsSync3(p))
       return false;
     try {
-      return readFileSync2(p, "utf-8").includes(BLOCK_START);
+      return readFileSync4(p, "utf-8").includes(BLOCK_START);
     } catch {
       return false;
     }
@@ -3048,14 +3909,14 @@ function upsertBlock(existing, block) {
 }
 async function installRuntime(workspaceRoot, runtime) {
   const target = TARGETS[runtime];
-  const absPath = join6(workspaceRoot, target.relPath);
-  const exists = existsSync(absPath);
+  const absPath = join9(workspaceRoot, target.relPath);
+  const exists = existsSync3(absPath);
   const before = exists ? await readFile3(absPath, "utf-8") : "";
   const after = target.mode === "file" ? target.fileContent : upsertBlock(before, RULE_BLOCK);
   if (exists && before === after) {
     return { runtime, path: absPath, action: "unchanged" };
   }
-  await mkdir3(dirname3(absPath), { recursive: true });
+  await mkdir3(dirname5(absPath), { recursive: true });
   await writeFile3(absPath, after, "utf-8");
   return { runtime, path: absPath, action: exists ? "updated" : "created" };
 }
@@ -3143,6 +4004,9 @@ function recordToJson(rec) {
     value: rec.value,
     confidence: rec.confidence ?? null,
     source: rec.source ?? null,
+    // M3-git: where this record came from — a committed/shared file, or the
+    // local DB only (a private write or a not-yet-shared record).
+    origin: rec.source === PROJECT_FILE_SOURCE ? "file" : "local",
     tags: rec.tags ?? [],
     useCount: rec.useCount,
     createdAt: rec.createdAt,
@@ -3174,7 +4038,13 @@ var writeInput = {
   key: z.string().min(1, "key must not be empty"),
   value: z.string().min(1, "value must not be empty"),
   confidence: z.number().min(0).max(1).optional(),
-  tags: z.array(z.string().min(1)).optional()
+  tags: z.array(z.string().min(1)).optional(),
+  /**
+   * M3-git: promote this record to a committed `.prometheus/memories/` file so
+   * it is SHARED with the team via git (file = shared, DB = private). Default
+   * false (DB-only). Only project-scope semantic/procedural records are shareable.
+   */
+  share: z.boolean().optional()
 };
 var captureInput = {
   sessionId: z.string().min(1, "sessionId must not be empty"),
@@ -3207,12 +4077,31 @@ var deleteInput = {
 var searchInput = {
   query: z.string().min(1, "query must not be empty"),
   types: z.array(typeEnum).min(1).optional(),
-  limit: z.number().int().positive().max(MAX_LIMIT).optional()
+  limit: z.number().int().positive().max(MAX_LIMIT).optional(),
+  /**
+   * Which stores to search. Default `["memories"]` (unchanged behaviour).
+   * `"sessions"` also searches the Session Recorder's event log (M1).
+   */
+  sources: z.array(z.enum(["memories", "sessions"])).min(1).optional()
 };
 var runtimeEnum = z.enum(MEMORY_RUNTIMES);
 var setupInput = {
   runtimes: z.array(runtimeEnum).min(1).optional()
 };
+var recorderSetupInput = {
+  scope: z.enum(["user", "project", "project-local"]).optional(),
+  uninstall: z.boolean().optional()
+};
+var sessionsInput = {
+  mode: z.enum(["list", "get"]).optional(),
+  sessionId: z.string().min(1).optional(),
+  limit: z.number().int().positive().max(MAX_LIMIT).optional(),
+  maxChars: z.number().int().positive().optional()
+};
+var curateInput = {
+  sessionId: z.string().min(1).optional(),
+  limit: z.number().int().positive().max(MAX_LIMIT).optional()
+};
 var emptyInput = {};
 function registerTools(server, source, hooks = {}) {
   const ready = typeof source === "function" ? source : () => Promise.resolve(source);
@@ -3235,7 +4124,7 @@ function registerTools(server, source, hooks = {}) {
     const { backend, workspaceRoot, projectId, projectName } = deps;
     const mirrorToFiles = !deps.rootIsHomeOrFsRoot;
     const limit = clampLimit(args.limit, DEFAULT_READ_LIMIT);
-    const synced = mirrorToFiles ? await syncProjectFiles(backend, { projectId, workspaceRoot }) : 0;
+    const sync = mirrorToFiles ? await syncProjectFiles(backend, { projectId, workspaceRoot }) : { synced: 0, pruned: 0, skipped: [] };
     const records = await backend.read({
       chain: defaultScopeChain(projectId),
       types: args.types,
@@ -3244,7 +4133,9 @@ function registerTools(server, source, hooks = {}) {
     return textResult({
       projectId,
       projectName,
-      projectFilesSynced: synced,
+      projectFilesSynced: sync.synced,
+      projectFilesPruned: sync.pruned,
+      ...sync.skipped.length > 0 ? { skippedFiles: sync.skipped } : {},
       woven: weave(records),
       records: records.map(recordToJson)
     });
@@ -3274,10 +4165,18 @@ ${args.value}`);
       source: "user"
     });
     let projectFile = null;
-    if (mirrorToFiles && scope === "project" && args.type === "semantic") {
-      projectFile = await writeProjectFile(workspaceRoot, args.key, args.value);
+    const shareable = scope === "project" && (args.type === "semantic" || args.type === "procedural");
+    if (mirrorToFiles && shareable && args.share === true) {
+      projectFile = await writeMemoryFile(workspaceRoot, {
+        key: args.key,
+        type: args.type,
+        value: args.value,
+        ...args.tags !== void 0 ? { tags: args.tags } : {},
+        ...args.confidence !== void 0 ? { confidence: args.confidence } : {},
+        source: "shared:user"
+      });
     }
-    return textResult({ record: recordToJson(record), projectFile });
+    return textResult({ record: recordToJson(record), projectFile, shared: projectFile !== null });
   });
   reg("capture", {
     title: "Consolidate session learnings",
@@ -3349,24 +4248,31 @@ ${f.value}`);
     inputSchema: searchInput
   }, async (args) => {
     const deps = await ready();
-    const { backend, workspaceRoot, projectId } = deps;
+    const { backend, recorder, workspaceRoot, projectId } = deps;
     const mirrorToFiles = !deps.rootIsHomeOrFsRoot;
     const limit = clampLimit(args.limit, 20);
-    if (mirrorToFiles)
-      await syncProjectFiles(backend, { projectId, workspaceRoot });
-    const hits = await backend.search({
-      chain: defaultScopeChain(projectId),
-      query: args.query,
-      types: args.types,
-      limit
-    });
+    const sources = args.sources ?? ["memories"];
+    let hits = [];
+    if (sources.includes("memories")) {
+      if (mirrorToFiles)
+        await syncProjectFiles(backend, { projectId, workspaceRoot });
+      hits = await backend.search({
+        chain: defaultScopeChain(projectId),
+        query: args.query,
+        types: args.types,
+        limit
+      });
+    }
+    let sessionHits = [];
+    if (sources.includes("sessions")) {
+      sessionHits = await recorder.searchSessions(projectId, args.query, limit);
+    }
     return textResult({
       projectId,
       query: args.query,
-      hits: hits.map((h) => ({
-        snippet: h.snippet,
-        record: recordToJson(h.record)
-      }))
+      sources,
+      hits: hits.map((h) => ({ snippet: h.snippet, record: recordToJson(h.record) })),
+      sessions: sessionHits
     });
   });
   reg("list", {
@@ -3407,7 +4313,7 @@ ${f.value}`);
       key: args.key
     });
     let fileRemoved = false;
-    if (mirrorToFiles && scope === "project" && args.type === "semantic") {
+    if (mirrorToFiles && scope === "project" && (args.type === "semantic" || args.type === "procedural")) {
       fileRemoved = await deleteProjectFile(workspaceRoot, args.key);
     }
     return textResult({ removed, fileRemoved });
@@ -3434,6 +4340,82 @@ ${f.value}`);
     }
     return textResult({ workspaceRoot, results });
   });
+  reg("recorder_setup", {
+    title: "Install the Session Recorder (opt-in)",
+    description: "Install (or, with `uninstall: true`, remove) the Prometheus Session Recorder \u2014 Claude Code hooks that capture your coding sessions LOCALLY so memory-mcp can recall what you did and distil durable knowledge. STRICTLY OPT-IN and reversible: this writes a hook script + 5 hook entries (SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd) into settings.json (backed up first). It records BEHAVIOUR, not code \u2014 tool names + short previews, with secrets redacted and sensitive-file contents skipped \u2014 as append-only JSONL under ~/.prometheus/recorder/. NOTHING is uploaded; it never leaves your machine. `scope`: 'project-local' (default \u2014 this project only, .claude/settings.local.json), 'project' (committed .claude/settings.json), or 'user' (~/.claude/settings.json, every project). After install/uninstall, RELOAD your Claude Code window(s). Claude-Code-specific (Cursor/VS Code do not run hooks).",
+    inputSchema: recorderSetupInput
+  }, async (args) => {
+    const deps = await ready();
+    try {
+      const result = applyRecorderHooks({
+        scope: args.scope ?? "project-local",
+        projectRoot: deps.workspaceRoot,
+        uninstall: args.uninstall === true
+      });
+      return textResult({ ok: true, ...result });
+    } catch (err) {
+      return textResult({
+        ok: false,
+        reason: `recorder_setup failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  });
+  reg("sessions", {
+    title: "Browse recorded coding sessions",
+    description: "Browse the Session Recorder's captured sessions for this project (requires recorder_setup). `{mode:'list'}` (default) \u2192 the most recent sessions with their header + stats (tool count, tools used, files touched) + M2 summary. `{mode:'get', sessionId}` \u2192 one session's condensed event log (user/assistant messages in full, tool calls as one-liners), capped by `maxChars`. Answers 'what did I do this week?' and 'have we tried X before?' \u2014 entirely from the LOCAL recorder DB.",
+    inputSchema: sessionsInput
+  }, async (args) => {
+    const { recorder, projectId } = await ready();
+    const mode = args.mode ?? "list";
+    if (mode === "get") {
+      const sessionId = (args.sessionId ?? "").trim();
+      if (sessionId === "") {
+        return textResult({ ok: false, reason: "mode 'get' requires a sessionId." });
+      }
+      const detail = await recorder.getSession(projectId, sessionId, args.maxChars ?? void 0);
+      if (detail === null) {
+        return textResult({ ok: false, reason: `no recorded session "${sessionId}" for this project.` });
+      }
+      return textResult({ ok: true, ...detail });
+    }
+    const limit = clampLimit(args.limit, 20);
+    const sessions = await recorder.listSessions(projectId, limit);
+    return textResult({ ok: true, projectId, count: sessions.length, sessions });
+  });
+  reg("curate", {
+    title: "Distil recorded sessions into durable memory",
+    description: "Curate recorded coding sessions (M2): distil a session's event log into a short summary + durable fact/procedure candidates via the configured extraction LLM (`PROMETHEUS_MEMORY_EXTRACT_PROVIDER`). Accepted project/semantic candidates land in `.prometheus/memories/` (git-versioned, PR-reviewable \u2014 the quality gate). `{sessionId}` curates that one session; with no args it curates the ended-but-not-yet-curated sessions (up to `limit`). Runs automatically after a session ends too. Requires an extractor \u2014 without one it is inactive (the recorder still works via `sessions`/`search`).",
+    inputSchema: curateInput
+  }, async (args) => {
+    const deps = await ready();
+    const { extractor, recorder, backend, projectId, workspaceRoot } = deps;
+    if (extractor === null) {
+      return textResult({
+        ok: false,
+        reason: "no extractor configured \u2014 set PROMETHEUS_MEMORY_EXTRACT_PROVIDER (mistral|openai|generic) + its key to enable curation. The recorder still works via sessions/search."
+      });
+    }
+    const curateDeps = {
+      backend,
+      recorder,
+      extractor,
+      projectId,
+      workspaceRoot,
+      mirrorToFiles: !deps.rootIsHomeOrFsRoot
+    };
+    const sessionId = (args.sessionId ?? "").trim();
+    if (sessionId !== "") {
+      const outcome = await curateSession(curateDeps, sessionId);
+      return textResult({ ok: outcome.curated, ...outcome });
+    }
+    const limit = clampLimit(args.limit, 10);
+    const pending = await recorder.listUncuratedSessions(projectId, limit);
+    const results = [];
+    for (const s of pending) {
+      results.push({ sessionId: s.sessionId, ...await curateSession(curateDeps, s.sessionId) });
+    }
+    return textResult({ ok: true, curatedCount: results.filter((r) => r.curated).length, results });
+  });
   reg("status", {
     title: "Memory status / health check",
     description: "Health check for this project's agent memory. Reports the resolved workspace root, project id, DB path, how many records are stored (total + by scope), the embedding provider with a zero-cost key-reachability probe, and which quality levers are active (rerank / rewrite / temporal). CALL THIS to confirm where memory is stored, how much is there, and whether the API key works.",
@@ -3455,7 +4437,36 @@ ${f.value}`);
         embeddingsError = err instanceof Error ? err.message : String(err);
       }
     }
-    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.11.4", { isDevBuild: false });
+    const update = await buildUpdateStatus("@prom.codes/memory-mcp", "0.15.0", { isDevBuild: false });
+    let recorder;
+    try {
+      const scopes = ["project-local", "project", "user"];
+      let rec = recorderStatus({ scope: "project-local", projectRoot: workspaceRoot });
+      for (const s of scopes) {
+        const st = recorderStatus({ scope: s, projectRoot: workspaceRoot });
+        if (st.installed) {
+          rec = st;
+          break;
+        }
+      }
+      const totals = await deps.recorder.recorderTotals(projectId);
+      recorder = {
+        installed: rec.installed,
+        scope: rec.scope,
+        events: rec.events,
+        settingsPath: rec.settingsPath,
+        hookScriptPresent: rec.hookScriptPresent,
+        sessions: totals.sessions,
+        totalEvents: totals.events,
+        retention: {
+          days: Number(process.env.PROMETHEUS_RECORDER_RETENTION_DAYS ?? 90),
+          maxSessions: Number(process.env.PROMETHEUS_RECORDER_MAX_SESSIONS ?? 300)
+        },
+        note: rec.installed ? "Session recorder is active (opt-in). It records LOCALLY only." : "Session recorder is OFF. Install with recorder_setup (strictly opt-in; records locally, nothing uploaded)."
+      };
+    } catch {
+      recorder = { installed: false, error: "recorder status unavailable" };
+    }
     const summary = deps.rootIsHomeOrFsRoot ? `Memory at ${dbPath}: ${stats.total} records, but the workspace resolved to ${workspaceRoot} (home/root) \u2014 open a project folder so memories scope and mirror correctly.` : `Memory at ${dbPath}: ${stats.total} records for project "${projectName}".${update.updateAvailable === true ? ` Update available: ${update.current} \u2192 ${update.latest} (ask me to run update via the context server's update_servers tool).` : ""}`;
     return textResult({
       installed: true,
@@ -3468,6 +4479,22 @@ ${f.value}`);
         autoSetup: deps.autoSetup
       },
       storage: { dbPath, projectFileMirror: mirrorToFiles },
+      // M3-git L1 boot-check: is `.prometheus/memories/` committed (shared) or
+      // gitignored (private/off)? Best-effort; never throws.
+      sharedMemory: (() => {
+        if (deps.rootIsHomeOrFsRoot)
+          return { shared: false, note: "no project open" };
+        let shared = false;
+        try {
+          shared = memoriesShared(workspaceRoot);
+        } catch {
+          shared = false;
+        }
+        return {
+          shared,
+          note: shared ? "Team memory sharing is ON: .prometheus/memories/ is committed to git; curated + share:true records travel with the repo." : "Team memory sharing is OFF: .prometheus/memories/ is gitignored (local memory still works fully). To share, add `!.prometheus/memories/` after `.prometheus/*` in .gitignore and commit the folder."
+        };
+      })(),
       records: { total: stats.total, byScope: stats.byScope },
       embeddings: {
         enabled: deps.embeddingsEnabled,
@@ -3482,6 +4509,7 @@ ${f.value}`);
         dedup: deps.dedupEnabled,
         extract: deps.extractorId
       },
+      recorder,
       update,
       summary
     });
@@ -3491,7 +4519,7 @@ ${f.value}`);
 // dist/server.js
 var SERVER_IDENTITY = {
   name: "prometheus-memory-mcp",
-  version: "0.11.4",
+  version: "0.15.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 Prometheus 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.";
@@ -3526,6 +4554,8 @@ async function main() {
     onToolCall: (tool) => heartbeat.update({ lastTool: tool, lastToolCallAt: Date.now() })
   });
   let watchdog = null;
+  let recorderTimer = null;
+  const RECORDER_INGEST_MS = 6e4;
   let shuttingDown = false;
   const shutdown = async (reason) => {
     if (shuttingDown)
@@ -3534,6 +4564,8 @@ async function main() {
     process.stderr.write(`prometheus-memory-mcp: ${reason}, shutting down
 `);
     watchdog?.stop();
+    if (recorderTimer !== null)
+      clearInterval(recorderTimer);
     heartbeat.stop();
     try {
       await server.close();
@@ -3590,6 +4622,38 @@ async function main() {
       });
     }
     composedResolve(composed);
+    const ingestOnce = async () => {
+      try {
+        const r = await composed.recorder.ingestSpoolDir(composed.projectId, env);
+        if (r.events > 0) {
+          process.stderr.write(`prometheus-memory-mcp: recorder ingested ${r.events} event(s) from ${r.sessions} session(s); reclaimed ${r.deletedSpools} spool(s)
+`);
+        }
+        const c = composed;
+        if (c.extractor !== null) {
+          const pending = await c.recorder.listUncuratedSessions(c.projectId, 3);
+          for (const s of pending) {
+            const outcome = await curateSession({
+              backend: c.backend,
+              recorder: c.recorder,
+              extractor: c.extractor,
+              projectId: c.projectId,
+              workspaceRoot: c.workspaceRoot,
+              mirrorToFiles: !c.rootIsHomeOrFsRoot
+            }, s.sessionId);
+            if (outcome.curated) {
+              process.stderr.write(`prometheus-memory-mcp: curated session ${s.sessionId} (${outcome.facts ?? 0} facts, ${outcome.procedures ?? 0} procedures)
+`);
+            }
+          }
+        }
+        await composed.recorder.applyRecorderRetention(env);
+      } catch {
+      }
+    };
+    void ingestOnce();
+    recorderTimer = setInterval(() => void ingestOnce(), RECORDER_INGEST_MS);
+    recorderTimer.unref?.();
   };
   if (eagerVia !== null) {
     boot(void 0, eagerVia);