opencode-memoir 1.1.9 → 2.0.0

package/dist/index.js

@@ -6,869 +6,132 @@ function debugLog(...args) {
 `);
 }
 
-// src/store.ts
-import { execFile, execFileSync } from "node:child_process";
-import { access, mkdir, rm } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { promisify } from "node:util";
-
-// src/utils.ts
-function coercePaths(path) {
-  if (!path) return [];
-  return Array.isArray(path) ? path.filter(Boolean) : [path];
+// src/memory-saver.ts
+var sessionMsgCount = /* @__PURE__ */ new Map();
+var REMINDER_INTERVAL = Math.max(0, parseInt(process.env.MEMOIR_REMINDER_INTERVAL ?? "5", 10));
+function incrementMsgCount(sessionID) {
+  const count = (sessionMsgCount.get(sessionID) ?? 0) + 1;
+  sessionMsgCount.set(sessionID, count);
+  return count;
 }
-function tryPrettyJson(text) {
-  try {
-    return JSON.stringify(JSON.parse(text), null, 2);
-  } catch {
-    return text;
-  }
+function shouldRemind(count) {
+  return REMINDER_INTERVAL > 0 && count > 1 && count % REMINDER_INTERVAL === 0;
 }
-var MEMOIR_GET_MAX_KEYS = 20;
-var SECRET_PATTERN = new RegExp(
-  [
-    // Generic secret assignments
-    `(?:password|passwd|secret|api[_-]?key|token|auth[_-]?token|access[_-]?key|private[_-]?key)\\s*[=:]\\s*['"]?[^\\s'"]{8,}`,
-    // AWS secret keys
-    `(?:aws[_-]?secret[_-]?access[_-]?key|aws_secret)\\s*[=:]\\s*['"]?[A-Za-z0-9/+=]{40}`,
-    // Connection strings with embedded credentials
-    "(?:postgres|mysql|mongodb|redis|amqp)://[^\\s:]+:[^\\s@]+@[^\\s]+",
-    // Generic connection strings with passwords
-    "://[^\\s:]+:[^\\s@]+@",
-    // PEM private keys
-    "-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----",
-    // Generic high-entropy secret assignments
-    `(?:secret|credential|key|password)\\s*[=:]\\s*['"][A-Za-z0-9+/=_-]{20,}['"]`
-  ].join("|")
-);
-function errorMessage(e) {
-  return e instanceof Error ? e.message : String(e);
+function pruneAll() {
+  sessionMsgCount.clear();
 }
 
 // src/store.ts
+import { execFile, execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
-var MEMOIR_PACKAGE = "memoir-ai";
-var MEMOIR_AI_PIN = "0.2.2";
-var GIT_TIMEOUT_MS = 3e3;
-var MEMOIR_TIMEOUT_MS = 15e3;
-var MEMOIR_MAX_BUFFER = 1024 * 1024;
-var NO_GIT_CACHE_MAX = 500;
-var NO_GIT_CACHE_TTL = 5 * 60 * 1e3;
-function evictOldestNoGit() {
-  const firstKey = _noGitCache.keys().next().value;
-  if (firstKey !== void 0) _noGitCache.delete(firstKey);
-}
-function sweepNoGitCache() {
-  const now = Date.now();
-  for (const [key, ts] of _noGitCache) {
-    if (now - ts >= NO_GIT_CACHE_TTL) _noGitCache.delete(key);
-  }
-}
-var _noGitCache = /* @__PURE__ */ new Map();
-function _checkNoGit(cwd) {
-  const ts = _noGitCache.get(cwd);
-  if (ts === void 0) return false;
-  const age = Date.now() - ts;
-  if (age < NO_GIT_CACHE_TTL) return true;
-  _noGitCache.delete(cwd);
-  return false;
-}
-function _main_worktree_root(cwd) {
-  if (_checkNoGit(cwd)) return "";
-  try {
-    const gitDir = execFileSync("git", ["rev-parse", "--git-dir"], {
-      cwd,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    }).trim();
-    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
-      cwd,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    }).trim();
-    const resolvePath = (path) => {
-      if (path.startsWith("/")) return path;
-      return join(cwd, path);
-    };
-    const gitDirAbs = resolvePath(gitDir);
-    const gitCommonDirAbs = resolvePath(gitCommonDir);
-    if (gitDirAbs === gitCommonDirAbs) {
-      return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-        cwd,
-        encoding: "utf8",
-        timeout: GIT_TIMEOUT_MS
-      }).trim();
-    }
-    const worktreeList = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    });
-    const firstLine = worktreeList.split("\n")[0];
-    if (firstLine.startsWith("worktree ")) {
-      const mainWorktree = firstLine.substring("worktree ".length).trim();
-      if (mainWorktree && mainWorktree !== "(bare)") {
-        return mainWorktree;
-      }
-    }
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    }).trim();
-  } catch (e) {
-    debugLog("_main_worktree_root: not a git repo or git error:", errorMessage(e));
-    sweepNoGitCache();
-    _noGitCache.set(cwd, Date.now());
-    if (_noGitCache.size > NO_GIT_CACHE_MAX) evictOldestNoGit();
-    return "";
-  }
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
 }
-var _storePathCache = null;
 function deriveStorePath(cwd = process.cwd()) {
   if (pluginStoreOverride) return pluginStoreOverride;
-  const configured = process.env.MEMOIR_STORE;
-  if (configured) return configured;
-  if (_storePathCache && _storePathCache.cwd === cwd) return _storePathCache.path;
+  const envStore = process.env.MEMOIR_STORE;
+  if (envStore) return envStore;
   let projectDir;
   try {
-    const gitRoot = _main_worktree_root(cwd);
-    if (gitRoot) {
-      projectDir = gitRoot;
-    } else {
-      projectDir = resolve(cwd);
-    }
-  } catch (e) {
-    debugLog("deriveStorePath: unexpected error:", errorMessage(e));
-    projectDir = cwd;
+    const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim();
+    projectDir = gitRoot;
+  } catch {
+    projectDir = resolve(cwd);
   }
   const slug = projectDir.replace(/[/.]/g, "-");
-  const result = join(homedir(), ".memoir", slug);
-  _storePathCache = { cwd, path: result };
-  return result;
+  return join(homedir(), ".memoir", slug);
 }
 var pluginStoreOverride;
 function setPluginStoreOverride(store) {
   pluginStoreOverride = store;
 }
-var ENSURED_STORES_MAX = 200;
-var ensuredStores = /* @__PURE__ */ new Set();
-var storeCreateQueues = /* @__PURE__ */ new Map();
-async function ensureStore(store) {
-  if (ensuredStores.has(store)) return;
-  const prev = storeCreateQueues.get(store) ?? Promise.resolve();
-  let release;
-  const next = new Promise((resolve2) => {
-    release = resolve2;
-  });
-  storeCreateQueues.set(store, next);
-  await prev;
-  if (ensuredStores.has(store)) {
-    release();
-    if (storeCreateQueues.get(store) === next) storeCreateQueues.delete(store);
-    return;
-  }
-  try {
-    await access(join(store, ".git"));
-    ensuredStores.add(store);
-    if (ensuredStores.size > ENSURED_STORES_MAX) {
-      const first = ensuredStores.keys().next().value;
-      if (first !== void 0) ensuredStores.delete(first);
-    }
-    return;
-  } catch {
-    await mkdir(join(store, ".."), { recursive: true }).catch(
-      (e) => debugLog("ensureStore: mkdir failed:", errorMessage(e))
-    );
-  }
-  const creationPromise = (async () => {
-    const tmpDir = join(tmpdir(), `memoir-scratch-${Date.now()}`);
-    try {
-      await mkdir(tmpDir, { recursive: true });
-      await execFileAsync("git", ["init", "-q", tmpDir], { timeout: 5e3 });
-      const result = await runMemoir(["new", store, "--taxonomy-builtin"], { cwd: tmpDir });
-      if (!result.ok) {
-        throw new Error(result.error);
-      }
-      ensuredStores.add(store);
-      if (ensuredStores.size > ENSURED_STORES_MAX) {
-        const first = ensuredStores.keys().next().value;
-        if (first !== void 0) ensuredStores.delete(first);
-      }
-    } catch (e) {
-      debugLog("ensureStore: creation failed:", errorMessage(e));
-      throw e;
-    } finally {
-      rm(tmpDir, { recursive: true, force: true }).catch(
-        (e) => debugLog("tmp cleanup failed:", errorMessage(e))
-      );
-    }
-  })();
-  try {
-    await creationPromise;
-  } finally {
-    release();
-    if (storeCreateQueues.get(store) === next) storeCreateQueues.delete(store);
-  }
-}
-function reorderResolver(resolver, winner) {
-  const idx = resolver.indexOf(winner);
-  if (idx <= 0) return [...resolver];
-  const next = [...resolver];
-  next.splice(idx, 1);
-  next.unshift(winner);
-  return next;
-}
-var memoirResolved = null;
-async function runMemoir(args, options = {}) {
-  let specs = memoirSpawnSpecs(args);
-  if (memoirResolved) {
-    const winner = specs.find((s) => s.label === memoirResolved);
-    if (winner) specs = reorderResolver(specs, winner);
-  }
-  let lastError = "";
-  let lastResolver;
-  for (const spec of specs) {
-    try {
-      const { stdout } = await execFileAsync(spec.command, spec.args, {
-        cwd: options.cwd ?? process.cwd(),
-        env: process.env,
-        maxBuffer: MEMOIR_MAX_BUFFER,
-        timeout: MEMOIR_TIMEOUT_MS
-        // prevent hang if memoir CLI stalls
-      });
-      memoirResolved = spec.label;
-      return { ok: true, stdout: stdout.trim() };
-    } catch (e) {
-      lastError = errorMessage(e);
-      lastResolver = spec.label;
-      debugLog("runMemoir: fallback", spec.label, "failed:", lastError);
-      if (memoirResolved === spec.label) memoirResolved = null;
-    }
-  }
-  return { ok: false, error: `Memoir command failed: ${lastError}`, resolver: lastResolver };
-}
-function memoirSpawnSpecs(args) {
-  return [
-    { command: "memoir", args, label: "memoir" },
-    {
-      command: "uvx",
-      args: ["--from", `${MEMOIR_PACKAGE}==${MEMOIR_AI_PIN}`, "memoir", ...args],
-      label: "uvx"
-    },
-    {
-      command: "uv",
-      args: ["tool", "run", "--from", `${MEMOIR_PACKAGE}==${MEMOIR_AI_PIN}`, "memoir", ...args],
-      label: "uv tool run"
-    }
-  ];
-}
-async function getCurrentBranch(store) {
+function currentGitBranch(cwd = process.cwd()) {
   try {
-    const runFn = _storeTestOverrides.runMemoirFn ?? runMemoir;
-    const result = await runFn(["--json", "-s", store, "status"], { cwd: store });
-    if (!result.ok) return "unknown";
-    const data = JSON.parse(result.stdout);
-    return data.branch || "unknown";
-  } catch (e) {
-    debugLog("getCurrentBranch: failed:", errorMessage(e));
-    return "unknown";
-  }
-}
-async function codeGitBranch() {
-  try {
-    const execFn = _storeTestOverrides.execFileAsyncFn ?? execFileAsync;
-    const { stdout } = await execFn("git", ["branch", "--show-current"], {
+    return execFileSync("git", ["branch", "--show-current"], {
+      cwd,
       encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    });
-    return stdout.trim();
-  } catch (e) {
-    debugLog("codeGitBranch: failed:", errorMessage(e));
-    return "";
-  }
-}
-async function branchExistsInMemoir(store, name) {
-  if (!name) return false;
-  try {
-    const runFn = _storeTestOverrides.runMemoirFn ?? runMemoir;
-    const result = await runFn(["--json", "-s", store, "branch"], { cwd: store });
-    if (!result.ok) return false;
-    const data = JSON.parse(result.stdout);
-    const branches = data?.branches ?? [];
-    return branches.includes(name);
-  } catch (e) {
-    debugLog("branchExistsInMemoir: failed:", errorMessage(e));
-    return false;
-  }
-}
-async function autoMatchMemoirBranch(store) {
-  const runFn = _storeTestOverrides.runMemoirFn ?? runMemoir;
-  const codeBranch = await codeGitBranch();
-  if (!codeBranch) {
-    return getCurrentBranch(store);
-  }
-  const current = await getCurrentBranch(store);
-  if (current === codeBranch) return current;
-  if (!await branchExistsInMemoir(store, codeBranch)) {
-    const result2 = await runFn(["-s", store, "branch", codeBranch, "--from", "main"], {
-      cwd: store
-    });
-    if (!result2.ok) {
-      debugLog("autoMatchMemoirBranch: create branch failed:", result2.error);
-      return getCurrentBranch(store);
-    }
-  }
-  const result = await runFn(["-s", store, "checkout", codeBranch], { cwd: store });
-  if (!result.ok) {
-    debugLog("autoMatchMemoirBranch: checkout failed:", result.error);
-    return getCurrentBranch(store);
-  }
-  return codeBranch;
-}
-async function readMemoirValue(store, key, namespace = "default") {
-  try {
-    const runFn = _storeTestOverrides.runMemoirFn ?? runMemoir;
-    const result = await runFn(["--json", "-s", store, "get", key, "-n", namespace], {
-      cwd: store
-    });
-    if (!result.ok) return "";
-    const parsed = JSON.parse(result.stdout);
-    const items = parsed?.items ?? [];
-    const value = items[0]?.value?.content;
-    return typeof value === "string" ? value : "";
-  } catch (e) {
-    debugLog("readMemoirValue: failed:", errorMessage(e));
+      timeout: 3e3
+    }).trim();
+  } catch {
     return "";
   }
 }
-var _storeTestOverrides = {};
-
-// src/capture.ts
-var _cliOverrides = null;
-var EDIT_TOOLS = /* @__PURE__ */ new Set([
-  "Edit",
-  "Write",
-  "MultiEdit",
-  "NotebookEdit",
-  "apply_patch",
-  "ApplyPatch",
-  "MultiFileEdit"
-]);
-function evictOldest(map, maxSize) {
-  if (map.size <= maxSize) return;
-  const firstKey = map.keys().next().value;
-  if (firstKey !== void 0) map.delete(firstKey);
-}
-var METRICS_CODE_MAX = 1e3;
-var pendingEditsBySession = /* @__PURE__ */ new Map();
-var toolMetricsBySession = /* @__PURE__ */ new Map();
-var cachedBranchBySession = /* @__PURE__ */ new Map();
+var branchCache = /* @__PURE__ */ new Map();
 function getCachedBranch(sessionID) {
-  return cachedBranchBySession.get(sessionID) ?? "unknown";
+  return branchCache.get(sessionID) ?? "";
 }
 function setCachedBranch(sessionID, branch) {
-  cachedBranchBySession.set(sessionID, branch);
-  evictOldest(cachedBranchBySession, 200);
-}
-function recordEdit(sessionID, edit) {
-  let edits = pendingEditsBySession.get(sessionID);
-  if (!edits) {
-    edits = [];
-    pendingEditsBySession.set(sessionID, edits);
-    evictOldest(pendingEditsBySession, 500);
-  }
-  edits.push(edit);
-}
-function recordToolMetrics(sessionID, tool2, metrics) {
-  let sessionMetrics = toolMetricsBySession.get(sessionID);
-  if (!sessionMetrics) {
-    sessionMetrics = /* @__PURE__ */ new Map();
-    toolMetricsBySession.set(sessionID, sessionMetrics);
-    evictOldest(toolMetricsBySession, 500);
-  }
-  const prev = sessionMetrics.get(tool2) ?? { calls: 0, errors: 0 };
-  sessionMetrics.set(tool2, {
-    calls: prev.calls + metrics.calls,
-    errors: prev.errors + metrics.errors
-  });
-}
-function parseTurnMetrics(text) {
-  const result = /* @__PURE__ */ new Map();
-  if (!text) return result;
-  const parts = text.split("|");
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (!trimmed) continue;
-    const [tool2, callsStr, errorsStr] = trimmed.split(":");
-    if (!tool2) continue;
-    result.set(tool2, {
-      calls: parseInt(callsStr, 10) || 0,
-      errors: parseInt(errorsStr, 10) || 0
-    });
-  }
-  return result;
+  branchCache.set(sessionID, branch);
 }
-function serializeTurnMetrics(map) {
-  return [...map.entries()].map(([tool2, m]) => `${tool2}:${m.calls}:${m.errors}`).join(" | ");
-}
-var flushQueues = /* @__PURE__ */ new Map();
-async function acquireFlushLock(store) {
-  const prev = flushQueues.get(store) ?? Promise.resolve();
-  let release;
-  const next = new Promise((resolve2) => {
-    release = resolve2;
-  });
-  flushQueues.set(store, next);
-  await prev;
-  return () => {
-    release();
-    if (flushQueues.get(store) === next) flushQueues.delete(store);
-  };
-}
-async function flushCapture(store, branch, sessionID) {
-  const targets = sessionID ? [sessionID] : [...pendingEditsBySession.keys()];
-  if (targets.length === 0) return;
+async function callMemoir(args, store) {
   try {
-    store = store ?? deriveStorePath();
-    if (!store) return;
-    await ensureStore(store);
-    const releaseLock = await acquireFlushLock(store);
-    try {
-      const perSession = [];
-      const swappedSids = /* @__PURE__ */ new Map();
-      for (const sid of targets) {
-        const idx = perSession.length;
-        const edits = pendingEditsBySession.get(sid) ?? [];
-        pendingEditsBySession.set(sid, []);
-        const metrics = toolMetricsBySession.get(sid) ?? /* @__PURE__ */ new Map();
-        toolMetricsBySession.set(sid, /* @__PURE__ */ new Map());
-        const sb = branch ?? cachedBranchBySession.get(sid);
-        perSession.push({ edits, metrics, sessionBranch: sb ?? "unknown" });
-        swappedSids.set(sid, idx);
-      }
-      if (!perSession.some((p) => p.edits.length > 0 || p.metrics.size > 0)) return;
-      try {
-        for (const p of perSession) {
-          if (p.sessionBranch === "unknown" || !p.sessionBranch) {
-            p.sessionBranch = await (_cliOverrides?.getCurrentBranch ?? getCurrentBranch)(store);
-          }
-        }
-        for (const p of perSession) {
-          const { edits, metrics, sessionBranch: branchKey } = p;
-          if (edits.length === 0 && metrics.size === 0) continue;
-          const [prevCodeRaw, prevTurnRaw] = await Promise.all([
-            edits.length > 0 ? (_cliOverrides?.readMemoirValue ?? readMemoirValue)(
-              store,
-              `metrics.code.${branchKey}`
-            ) : Promise.resolve(""),
-            metrics.size > 0 ? (_cliOverrides?.readMemoirValue ?? readMemoirValue)(
-              store,
-              `metrics.turn.${branchKey}`
-            ) : Promise.resolve("")
-          ]);
-          let codeWrite;
-          if (edits.length > 0) {
-            const files = [...new Set(edits.map((e) => e.filePath))];
-            const entry = {
-              timestamp: Date.now() / 1e3,
-              summary: `Changed ${edits.length} block(s) across ${files.length} file(s): ${files.join(", ")}`,
-              files
-            };
-            let acc = {
-              schema_version: 2,
-              entries: []
-            };
-            if (prevCodeRaw) {
-              try {
-                const parsed = JSON.parse(prevCodeRaw);
-                if (parsed?.entries && Array.isArray(parsed.entries)) {
-                  acc = parsed;
-                  if (acc.schema_version < 2) acc.schema_version = 2;
-                }
-              } catch (e) {
-                debugLog(
-                  "flushCapture: failed to parse existing code metrics, starting fresh:",
-                  errorMessage(e)
-                );
-              }
-            }
-            acc.entries.push(entry);
-            if (acc.entries.length > METRICS_CODE_MAX)
-              acc.entries = acc.entries.slice(-METRICS_CODE_MAX);
-            codeWrite = (_cliOverrides?.runMemoir ?? runMemoir)(
-              [
-                "-s",
-                store,
-                "remember",
-                "--replace",
-                JSON.stringify(acc),
-                "-p",
-                `metrics.code.${branchKey}`
-              ],
-              { cwd: store }
-            );
-          }
-          let turnWrite;
-          if (metrics.size > 0) {
-            const existing = parseTurnMetrics(prevTurnRaw);
-            for (const [tool2, current] of metrics) {
-              const prev = existing.get(tool2) ?? { calls: 0, errors: 0 };
-              existing.set(tool2, {
-                calls: prev.calls + current.calls,
-                errors: prev.errors + current.errors
-              });
-            }
-            turnWrite = (_cliOverrides?.runMemoir ?? runMemoir)(
-              [
-                "-s",
-                store,
-                "remember",
-                "--replace",
-                serializeTurnMetrics(existing),
-                "-p",
-                `metrics.turn.${branchKey}`
-              ],
-              { cwd: store }
-            );
-          }
-          const writes = [];
-          if (codeWrite) writes.push(codeWrite);
-          if (turnWrite) writes.push(turnWrite);
-          const results = await Promise.all(writes);
-          for (const result of results) {
-            if (!result.ok) {
-              throw new Error(`Memoir write failed: ${result.error}`);
-            }
-          }
-        }
-      } catch (e) {
-        for (const [sid, idx] of swappedSids) {
-          const p = perSession[idx];
-          const currentEdits = pendingEditsBySession.get(sid) ?? [];
-          pendingEditsBySession.set(sid, [...p.edits, ...currentEdits]);
-          const merged = toolMetricsBySession.get(sid) ?? /* @__PURE__ */ new Map();
-          for (const [tool2, m] of p.metrics) {
-            const prev = merged.get(tool2) ?? { calls: 0, errors: 0 };
-            merged.set(tool2, { calls: prev.calls + m.calls, errors: prev.errors + m.errors });
-          }
-          toolMetricsBySession.set(sid, merged);
-        }
-        throw e;
-      }
-    } finally {
-      releaseLock();
-    }
-  } catch (e) {
-    debugLog("flushCapture: failed:", errorMessage(e));
-  }
-}
-
-// src/recall-gate.ts
-function isSecretSanitizationEnabled() {
-  return process.env.MEMOIR_SANITIZE_SECRETS !== "0";
-}
-var pendingRecall = /* @__PURE__ */ new Set();
-var ACK_PATTERN = /^(ok|thanks|thank you|sounds good|got it|👍|🙏|perfect|great|cool|nice|awesome|understood|makes sense|agree|right|sure|yes|no|done|nvm|never mind|lgtm|looks good|proceed|continue|good|fine)\b/i;
-var EXPLICIT_RECALL_PATTERN = /\b(memoir:recall|memoir:remember|memoir-recall|memoir-remember)\b|(\/recall|\/remember)\b/i;
-var RECALL_TRIGGER_PATTERNS = [
-  // Action verbs and domain nouns
-  /\b(add|build|implement|refactor|redesign|design|create|write|set( |-)up|wire( |-)up|integrate|migrate|rewrite|extract|extend|plumb|hook( |-)up|ship|scaffold|optimize|fix|debug|review|architect|model|schema|API|service|feature|module|system|pipeline|workflow|make|move|replace|convert|swap|remove|clean( |-)up|transform|investigate|explore|figure( |-)out|plan|decide|choose|pick|compare|walk( |-)?me( |-)?through|take( |-)?a( |-)?stab|help( |-)?me|harness|hook|prompt|test)\b/i,
-  // Question starts (how/why/what/where/when/should/can/could/would/is it/are we/do I/does it)
-  /^(how|why|what|where|when|should|can|could|would|is it|are we|do I|does it)\b.*\?/im,
-  // Code blocks (triple backticks)
-  /```/,
-  // Code definitions
-  /\b(def|function|class|import|export)\s+/,
-  // Memoir/recall keywords
-  /\b(memoir|recall|remember|memory)\b/i,
-  // File extensions
-  /\b\w+\.(py|js|ts|tsx|scala|java|go|rs|rb|md|json|yaml|yml|toml|sh|bash|css|html|kt|swift|c|cpp|h|hpp)\b/i,
-  // File paths (slash-containing tokens)
-  /\w+\/\w+/
-];
-function isAcknowledgement(text) {
-  const trimmed = text.trim().toLowerCase();
-  const words = trimmed.split(/\s+/);
-  return words.length <= 5 && ACK_PATTERN.test(trimmed);
-}
-function shouldTriggerRecall(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return false;
-  if (EXPLICIT_RECALL_PATTERN.test(trimmed)) return true;
-  if (trimmed.length < 10) return false;
-  if (isAcknowledgement(trimmed)) return false;
-  if (trimmed.length >= 40 && RECALL_TRIGGER_PATTERNS.some((p) => p.test(trimmed))) return true;
-  return false;
-}
-var DEFAULT_RECALL_NAMESPACES = ["default", "project:onboard", "codebase:onboard"];
-
-// src/capture-hooks.ts
-var branchMatchCache = /* @__PURE__ */ new Map();
-var BRANCH_MATCH_TTL_MS = 5e3;
-async function handleShellEnv(storeRoot, _input, output) {
-  try {
-    output.env.MEMOIR_STORE = storeRoot;
-  } catch (e) {
-    debugLog("shell.env: failed:", errorMessage(e));
-  }
-}
-async function handleToolExecuteAfter(input, output) {
-  try {
-    const typedInput = input;
-    const typedOutput = output;
-    const sid = typedInput?.sessionID ?? "default";
-    if (process.env.MEMOIR_NO_CAPTURE === "1") return;
-    if (process.env.MEMOIR_NO_METRICS !== "1") {
-      const calls = 1;
-      const errors = typedOutput?.metadata?.error || typedOutput?.output?.startsWith("Error:") ? 1 : 0;
-      recordToolMetrics(sid, typedInput?.tool ?? "", { calls, errors });
-    }
-    if (process.env.MEMOIR_NO_CODE_SUMMARY !== "1" && EDIT_TOOLS.has(typedInput?.tool ?? "")) {
-      const args = typedInput?.args ?? {};
-      const filePath = typeof args.filePath === "string" ? args.filePath : typeof args.path === "string" ? args.path : "";
-      if (filePath) {
-        recordEdit(sid, {
-          tool: typedInput?.tool ?? "",
-          filePath,
-          snippet: "",
-          timestamp: Date.now()
-        });
+    const { stdout } = await execFileAsync(
+      "uvx",
+      ["--from", "memoir-ai", "memoir", "-s", store, ...args],
+      {
+        encoding: "utf8",
+        timeout: 15e3,
+        maxBuffer: 1024 * 1024
       }
-    }
-  } catch (e) {
-    debugLog("tool.execute.after: failed:", errorMessage(e));
-  }
-}
-async function handleChatMessage(storeRoot, input, output) {
-  try {
-    const typedInput = input;
-    const typedOutput = output;
-    const sid = typedInput?.sessionID ?? "default";
-    const text = (typedOutput?.parts ?? []).filter((p) => p.type === "text").map((p) => p.text).join(" ");
-    if (shouldTriggerRecall(text)) {
-      pendingRecall.add(sid);
-    }
-    const _cachedBranch = getCachedBranch(sid);
-    const prevBranch = _cachedBranch === "unknown" ? void 0 : _cachedBranch;
-    const now = Date.now();
-    const cached = branchMatchCache.get(sid);
-    if (cached && now - cached.ts < BRANCH_MATCH_TTL_MS) {
-      setCachedBranch(sid, cached.branch);
-    } else {
-      const branch = await autoMatchMemoirBranch(storeRoot);
-      branchMatchCache.set(sid, { branch, ts: now });
-      setCachedBranch(sid, branch);
-    }
-    if (process.env.MEMOIR_NO_CAPTURE !== "1") {
-      await flushCapture(storeRoot, prevBranch, sid);
-    }
+    );
+    return stdout.trim();
   } catch (e) {
-    debugLog("chat.message: failed:", errorMessage(e));
-  }
-}
-async function flushAllCapture(storeRoot) {
-  await flushCapture(storeRoot);
-}
-
-// src/memoir-ops.ts
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { mkdir as mkdir2, readFile, rm as rm2, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
-var UI_URL_DEADLINE_MS = 5e3;
-var UI_URL_POLL_MS = 100;
-var UI_OUTPUT_MAX_BYTES = 256 * 1024;
-async function ensureStoreOrError(store) {
-  try {
-    await ensureStore(store);
+    debugLog("callMemoir failed:", errorMessage(e));
     return null;
-  } catch (error) {
-    return errorMessage(error);
-  }
-}
-async function statusJson(store) {
-  const storeErr = await ensureStoreOrError(store);
-  if (storeErr) return `Memoir command failed: ${storeErr}`;
-  const result = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
-  if (!result.ok) return result.error;
-  try {
-    const data = JSON.parse(result.stdout);
-    const branch = await codeGitBranch();
-    data.opencode = { store, project_git_root: process.cwd(), project_git_branch: branch };
-    return JSON.stringify(data, null, 2);
-  } catch (e) {
-    debugLog("statusJson: failed to parse JSON:", errorMessage(e));
-    return result.stdout;
   }
 }
-async function launchUi(store) {
-  await ensureStore(store);
-  const pidDir = join2(homedir2(), ".memoir", "ui-servers");
-  await mkdir2(pidDir, { recursive: true });
-  const hash = createHash("sha256").update(store).digest("hex").slice(0, 8);
-  const pidfile = join2(pidDir, `${hash}.json`);
+async function autoMatchMemoirBranch(store, sessionID) {
+  const codeBranch = currentGitBranch();
+  if (!codeBranch) return;
+  const cached = getCachedBranch(sessionID);
+  if (cached === codeBranch) return;
+  const branchResult = await callMemoir(["--json", "branch"], store);
+  if (branchResult === null) return;
   try {
-    const existing = JSON.parse(await readFile(pidfile, "utf8"));
-    if (existing?.pid && existing?.url) {
-      try {
-        process.kill(Number(existing.pid), 0);
-        return JSON.stringify({ ...existing, reused: true }, null, 2);
-      } catch (e) {
-        debugLog("launchUi: process dead, relaunching:", errorMessage(e));
-      }
+    const data = JSON.parse(branchResult);
+    const branches = data?.branches ?? [];
+    if (!branches.includes(codeBranch)) {
+      await callMemoir(["branch", codeBranch, "--from", "main"], store);
     }
+    await callMemoir(["checkout", codeBranch], store);
+    setCachedBranch(sessionID, codeBranch);
   } catch (e) {
-    debugLog("launchUi: failed to read pidfile:", errorMessage(e));
-    await rm2(pidfile, { force: true }).catch(
-      (e2) => debugLog("launchUi: failed to remove stale pidfile", errorMessage(e2))
-    );
+    debugLog("autoMatchMemoirBranch: parsing failed:", errorMessage(e));
   }
-  let lastError = "";
-  let uiSpecs = memoirSpawnSpecs(["ui", store]);
-  if (memoirResolved) {
-    const winner = uiSpecs.find((s) => s.label === memoirResolved);
-    if (winner) uiSpecs = reorderResolver(uiSpecs, winner);
-  }
-  for (const spec of uiSpecs) {
-    const child = spawn(spec.command, spec.args, {
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"],
-      // Scrub process.env — only forward whitelisted vars to avoid leaking secrets
-      env: Object.fromEntries(
-        Object.entries({
-          HOME: process.env.HOME,
-          USER: process.env.USER,
-          PATH: process.env.PATH,
-          MEMOIR_STORE: process.env.MEMOIR_STORE,
-          MEMOIR_DEBUG: process.env.MEMOIR_DEBUG
-        }).filter(([, v]) => v != null)
-      )
-    });
-    let output = "";
-    child.stdout?.on("data", (chunk) => {
-      if (output.length < UI_OUTPUT_MAX_BYTES) output += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      if (output.length < UI_OUTPUT_MAX_BYTES) output += String(chunk);
-    });
-    const spawnFailed = new Promise((resolve2) => {
-      child.once("error", (error2) => resolve2(errorMessage(error2)));
-      child.once("spawn", () => resolve2(null));
-    });
-    const error = await spawnFailed;
-    if (error) {
-      lastError = `${spec.label}: ${error}`;
-      continue;
-    }
-    child.unref();
-    let childExited = false;
-    child.once("exit", () => {
-      childExited = true;
-    });
-    const urlPattern = /https?:\/\/(?:localhost|127\.0\.0\.1):\d+\S*/;
-    const deadline = Date.now() + UI_URL_DEADLINE_MS;
-    while (Date.now() < deadline && !childExited) {
-      const match = output.match(urlPattern);
-      if (match) {
-        const url = match[0];
-        const data = {
-          pid: child.pid,
-          url,
-          store,
-          command: spec.label,
-          started: (/* @__PURE__ */ new Date()).toISOString(),
-          reused: false
-        };
-        await writeFile(pidfile, JSON.stringify(data, null, 2));
-        return JSON.stringify(data, null, 2);
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, UI_URL_POLL_MS));
-    }
-    if (childExited) {
-      lastError = `${spec.label}: process exited before URL was detected. Output: ${output.slice(0, 500)}`.trim();
-      continue;
-    }
-    const msg = `Memoir UI started with ${spec.label} (pid ${child.pid ?? "unknown"}), but URL was not detected yet.
-${output.trim()}`;
-    return msg.trim();
-  }
-  return `Memoir UI failed to start: ${lastError || "no launcher succeeded"}`;
 }
-async function unmergedBranchesText(store) {
-  await ensureStore(store);
-  const branchResult = await runMemoir(["--json", "-s", store, "branch"], { cwd: store });
-  if (!branchResult.ok) {
-    return branchResult.error;
-  }
-  const data = JSON.parse(branchResult.stdout);
-  const branches = data?.branches ?? [];
-  const unmerged = [];
-  const diffResults = await Promise.all(
-    branches.filter((b) => b !== "main").map(async (branch) => {
-      const diffResult = await runMemoir(["-s", store, "diff", branch, "main", "--stat"], {
-        cwd: store
-      });
-      return { branch, diffResult };
-    })
-  );
-  for (const { branch, diffResult } of diffResults) {
-    if (!diffResult.ok) {
-      debugLog("command.execute.before: memoir diff failed", diffResult.error);
-      continue;
-    }
-    if (diffResult.stdout.trim()) {
-      unmerged.push(branch);
-    }
-  }
-  return unmerged.length > 0 ? `Unmerged branches:
-${unmerged.join("\n")}` : "All branches are merged into main.";
+function pruneBranchCache() {
+  branchCache.clear();
 }
 
-// src/commands.ts
-function pushText(output, text) {
-  output.parts.length = 0;
-  output.parts.push({ type: "text", text });
+// src/index.ts
+var sessionsWithStartupHint = /* @__PURE__ */ new Set();
+function errorMessage2(e) {
+  return e instanceof Error ? e.message : String(e);
 }
-function registerCommands(config) {
-  config.command = config.command ?? {};
-  config.command["memoir:status"] = {
-    description: "Show Memoir status for the current OpenCode project",
-    template: "Show Memoir status for this OpenCode project."
-  };
-  config.command["memoir:ui"] = {
-    description: "Launch or reopen the Memoir web UI for this project store",
-    template: "Launch or reopen the Memoir UI for this project."
-  };
-  config.command["memoir:remember"] = {
-    description: "Save a durable fact, preference, rule, or decision to Memoir",
-    template: `Use Memoir to save this durable memory now.
-
-USER REQUEST:
-$ARGUMENTS
-
-Extract the memory content, choose a semantic path if none is supplied, then call the memoir_remember tool. Never save secrets.`
-  };
-  config.command["memoir:recall"] = {
-    description: "Recall relevant facts from Memoir before answering",
-    template: `Recall relevant Memoir memories for this request.
-
-USER REQUEST:
-$ARGUMENTS
-
-Use memoir_recall first. It checks default plus onboard namespaces unless a namespace is specified. Then call memoir_get with the matching namespace for exact values before answering.`
-  };
-  config.command["memoir:onboard"] = {
-    description: "Populate or refresh Memoir onboarding for this project",
-    template: `Populate or refresh Memoir onboarding for the CURRENT OpenCode project only.
-
-USER REQUEST:
-$ARGUMENTS
+var MemoirOpenCode = async (_input, rawOptions) => {
+  const opts = rawOptions ?? {};
+  if (opts.store) setPluginStoreOverride(opts.store);
+  const storePath = deriveStorePath();
+  const mcpCommand = ["uvx", "--from", "memoir-ai[mcp]", "memoir-mcp"];
+  if (storePath) {
+    mcpCommand.push("--store", storePath);
+  }
+  const hooks = {
+    name: "memoir",
+    config: async (config) => {
+      config.command = config.command ?? {};
+      config.command["memoir:onboard"] = {
+        description: "Populate or refresh Memoir onboarding for this project",
+        template: `Populate or refresh Memoir onboarding for the current project.
 
 Workflow:
-- Stay inside the current project/worktree. Do not inspect parent directories.
 - First obtain a project file tree to understand structure.
 - Start studying from project documentation.
 - Continue only based on what the tree and documentation show.
@@ -879,307 +142,77 @@ Memory rules:
 - Do not use preferences.* paths unless the user explicitly stated a preference.
 - If a fact is your interpretation, do not save it; report it as uncertain instead.
 
-Then call memoir_remember with replace=true for durable onboarding facts. Use namespace codebase:onboard in git repositories and project:onboard outside git. Do not install or invoke separate skills/scripts.`
-  };
-  config.command["memoir:unmerged"] = {
-    description: "List memoir branches with changes not yet merged into main",
-    template: "List memoir branches that have diverged from main."
-  };
-}
-async function handleCommandExecuteBefore(storeRoot, input, output) {
-  try {
-    if (input.command === "memoir:status") {
-      pushText(output, await statusJson(storeRoot));
-    } else if (input.command === "memoir:ui") {
-      pushText(output, await launchUi(storeRoot));
-    } else if (input.command === "memoir:remember") {
-      const args = input.arguments;
-      if (args && isSecretSanitizationEnabled() && SECRET_PATTERN.test(args)) {
-        pushText(
-          output,
-          "Memoir: cannot remember content that matches secret patterns. Please remove sensitive data and try again."
-        );
-      }
-    } else if (input.command === "memoir:unmerged") {
-      pushText(output, await unmergedBranchesText(storeRoot));
-    }
-  } catch (error) {
-    pushText(output, `Memoir command failed: ${errorMessage(error)}`);
-  }
-}
-
-// src/session-context.ts
-var initContext = null;
-var initContextFetched = false;
-var MAX_TAXONOMY_RETRIES = 3;
-var taxonomyFetchRetries = 0;
-var SESSION_CONTEXT_TTL_MS = 60 * 60 * 1e3;
-var sessionsWithContext = /* @__PURE__ */ new Map();
-function hasSessionContext(sessionID) {
-  const ts = sessionsWithContext.get(sessionID);
-  if (ts === void 0) return false;
-  if (Date.now() - ts > SESSION_CONTEXT_TTL_MS) {
-    sessionsWithContext.delete(sessionID);
-    return false;
-  }
-  return true;
-}
-function markSessionContext(sessionID) {
-  sessionsWithContext.set(sessionID, Date.now());
-}
-function pruneStaleSessions() {
-  const now = Date.now();
-  for (const [id, ts] of sessionsWithContext) {
-    if (now - ts > SESSION_CONTEXT_TTL_MS) sessionsWithContext.delete(id);
-  }
-}
-async function handleEvent(storeRoot, input) {
-  if (input.event.type === "session.created" && !initContextFetched) {
-    initContextFetched = true;
-    fetchTaxonomy(storeRoot).catch((e) => {
-      debugLog("event: taxonomy fetch failed, will retry on next session:", errorMessage(e));
-      taxonomyFetchRetries++;
-      if (taxonomyFetchRetries >= MAX_TAXONOMY_RETRIES) {
-        debugLog("memoir: taxonomy fetch failed after max retries, giving up");
-        return;
-      }
-      initContextFetched = false;
-    });
-  }
-}
-async function fetchTaxonomy(storeRoot) {
-  const taxonomyResult = await runMemoir(
-    ["--json", "-s", storeRoot, "summarize", "--depth", "3", "-n", "default"],
-    { cwd: storeRoot }
-  );
-  if (!taxonomyResult.ok) {
-    throw new Error(taxonomyResult.error);
-  }
-  const pretty = tryPrettyJson(taxonomyResult.stdout);
-  initContext = `[memoir] Available taxonomy paths:
-${pretty}`;
-  taxonomyFetchRetries = 0;
-}
-async function handleSystemTransform(input, output) {
-  try {
-    const typedInput = input;
-    const typedOutput = output;
-    if (typedInput?.sessionID && !hasSessionContext(typedInput.sessionID)) {
-      markSessionContext(typedInput.sessionID);
-      if (initContext) {
-        typedOutput?.system?.unshift(initContext);
-      }
-    }
-    if (typedInput?.sessionID && pendingRecall.has(typedInput.sessionID)) {
-      pendingRecall.delete(typedInput.sessionID);
-      typedOutput?.system?.push(
-        "\n[memoir] The user may have relevant context in Memoir. Run memoir_recall to list available memories across default and onboard namespaces, then memoir_get with the matching namespace to fetch exact values."
-      );
-    }
-  } catch (e) {
-    debugLog("system.transform: failed:", errorMessage(e));
-  }
-}
-function clearSessionContext() {
-  pruneStaleSessions();
-  sessionsWithContext.clear();
-}
-
-// src/tools.ts
-import { tool } from "@opencode-ai/plugin";
-var memoirStatus = tool({
-  description: "Show Memoir status for the current OpenCode project store.",
-  args: {},
-  execute: async () => statusJson(deriveStorePath())
-});
-var memoirRemember = tool({
-  description: "Explicitly save a durable memory to Memoir at one or more semantic taxonomy paths.",
-  args: {
-    content: tool.schema.string().describe("Memory content to save. Do not include secrets."),
-    path: tool.schema.string().describe("Semantic taxonomy path, e.g. preferences.coding.style."),
-    namespace: tool.schema.string().optional().describe("Memoir namespace. Defaults to default."),
-    replace: tool.schema.boolean().optional().describe("Replace existing value at the path.")
-  },
-  execute: async (args) => {
-    const content = args.content?.trim();
-    if (!content) return "Memoir memory was not saved: content is empty.";
-    if (isSecretSanitizationEnabled() && SECRET_PATTERN.test(content)) {
-      return "Memoir memory was not saved: the content looks like a secret or credential. Save a redacted rule instead.";
-    }
-    const paths = coercePaths(args.path);
-    if (paths.length === 0) {
-      return "Memoir memory was not saved: provide a semantic path, e.g. preferences.coding.style.";
-    }
-    const store = deriveStorePath();
-    const storeError = await ensureStoreOrError(store);
-    if (storeError) return storeError;
-    const cliArgs = ["--json", "-s", store, "remember", content];
-    for (const p of paths) cliArgs.push("-p", p);
-    cliArgs.push("-n", args.namespace ?? "default");
-    if (args.replace) cliArgs.push("--replace");
-    const rememberResult = await runMemoir(cliArgs, { cwd: store });
-    if (!rememberResult.ok) return rememberResult.error;
-    return tryPrettyJson(rememberResult.stdout);
-  }
-});
-var memoirRecall = tool({
-  description: "List Memoir memory keys across relevant namespaces for relevance picking. Never calls legacy memoir recall.",
-  args: {
-    query: tool.schema.string().optional().describe("User query or topic to recall for."),
-    namespace: tool.schema.string().optional().describe(
-      "Single Memoir namespace to inspect. If omitted, checks default + onboard namespaces."
-    ),
-    namespaces: tool.schema.array(tool.schema.string()).optional().describe("Namespaces to inspect. Defaults to default, project:onboard, codebase:onboard."),
-    includeMetrics: tool.schema.boolean().optional().describe("Include metrics.* memories in the listing.")
-  },
-  execute: async (args) => {
-    const store = deriveStorePath();
-    const storeError = await ensureStoreOrError(store);
-    if (storeError) return storeError;
-    const namespaces = args.namespace ? [args.namespace] : args.namespaces && args.namespaces.length > 0 ? args.namespaces : DEFAULT_RECALL_NAMESPACES;
-    const results = await Promise.all(
-      namespaces.map(async (namespace) => {
-        const summarizeResult = await runMemoir(
-          ["--json", "-s", store, "summarize", "--depth", "3", "-n", namespace],
-          { cwd: store }
-        );
-        if (!summarizeResult.ok) return summarizeResult.error;
-        const output = tryPrettyJson(summarizeResult.stdout);
-        return `## namespace: ${namespace}
-${output}`;
-      })
-    );
-    const sections = [];
-    const errors = [];
-    for (const r of results) {
-      if (typeof r === "string") {
-        if (r.startsWith("Memoir command failed")) {
-          errors.push(r);
-        } else {
-          sections.push(r);
-        }
-      }
-    }
-    const note = args.includeMetrics ? "Metrics were included by request." : "Ignore metrics.* and taxonomy:v1:* entries unless explicitly needed. If default is empty or only metrics, inspect project:onboard/codebase:onboard before concluding there is no memory.";
-    const query = args.query ? `Query: ${args.query}
-` : "";
-    const errorBlock = errors.length > 0 ? `
-
-Note: some namespaces failed:
-${errors.map((e) => `  - ${e}`).join("\n")}` : "";
-    return `${query}${note}
-Pick at most 5-7 relevant exact keys across namespaces, then call memoir_get with the matching namespace if values are needed.
-${sections.join("\n\n")}${errorBlock}`;
-  }
-});
-var memoirGet = tool({
-  description: "Fetch exact Memoir memory keys after selecting them from memoir_recall output.",
-  args: {
-    keys: tool.schema.array(tool.schema.string()).describe("Exact memory keys to fetch."),
-    namespace: tool.schema.string().optional().describe("Memoir namespace. Defaults to default.")
-  },
-  execute: async (args) => {
-    const keys = args.keys?.map((key) => key.trim()).filter(Boolean) ?? [];
-    if (keys.length === 0) return "No Memoir keys were provided.";
-    if (keys.length > MEMOIR_GET_MAX_KEYS) {
-      return `Error: Too many keys requested (max ${MEMOIR_GET_MAX_KEYS}, got ${keys.length}). Narrow your selection from memoir_recall output.`;
-    }
-    const store = deriveStorePath();
-    const storeError = await ensureStoreOrError(store);
-    if (storeError) return storeError;
-    const getResult = await runMemoir(
-      ["--json", "-s", store, "get", ...keys, "-n", args.namespace ?? "default"],
-      { cwd: store }
-    );
-    if (!getResult.ok) return getResult.error;
-    return tryPrettyJson(getResult.stdout);
-  }
-});
-var memoirTools = {
-  memoir_status: memoirStatus,
-  memoir_remember: memoirRemember,
-  memoir_recall: memoirRecall,
-  memoir_get: memoirGet
-};
-
-// src/index.ts
-var MemoirOpenCode = async (_input, rawOptions) => {
-  const opts = rawOptions ?? {};
-  if (opts.store) setPluginStoreOverride(opts.store);
-  const storeRoot = deriveStorePath();
-  return {
-    name: "memoir",
-    tool: { ...memoirTools },
-    config: async (opencodeConfig) => {
-      registerCommands(opencodeConfig);
+Then call memoir_remember with replace=true for durable onboarding facts. Use namespace codebase:onboard in git repositories and project:onboard outside git.`
+      };
+      const mcp = config.mcp ?? {};
+      mcp.memoir = {
+        type: "local",
+        command: mcpCommand,
+        environment: storePath ? { MEMOIR_STORE: storePath } : void 0
+      };
+      config.mcp = mcp;
     },
-    "command.execute.before": async (input, output) => {
-      await handleCommandExecuteBefore(storeRoot, input, output);
-    },
-    /**
-     * Inject MEMOIR_STORE into every shell command's environment so any memoir
-     * invocation automatically targets the right store without manual -s flags.
-     * Uses the cached value resolved at init time (avoiding execFileSync overhead
-     * on every shell command).
-     */
     "shell.env": async (_input2, output) => {
-      await handleShellEnv(storeRoot, _input2, output);
-    },
-    /**
-     * Observe every tool execution for metrics and code-change tracking.
-     * Mirrors the observation phase of Claude Code's Stop hook.
-     * Never modifies the tool output.
-     */
-    "tool.execute.after": async (input, output) => {
-      await handleToolExecuteAfter(input, output);
-    },
-    /**
-     * Fires on every incoming user message.
-     *
-     * 1. Auto-match memoir branch to current git branch
-     *    (cf. UserPromptSubmit's auto_match_memoir_branch in Claude Code plugin).
-     * 2. Flush pending edits from the previous assistant turn
-     *    (cf. Stop hook code change audit, run after each turn).
-     * 3. Run the recall gate (cf. UserPromptSubmit).
-     *
-     * Steps 1–2 are skipped when MEMOIR_NO_CAPTURE=1.
-     */
-    "chat.message": async (input, output) => {
-      await handleChatMessage(storeRoot, input, output);
+      try {
+        if (storePath) {
+          output.env.MEMOIR_STORE = storePath;
+        }
+      } catch (e) {
+        debugLog("shell.env: failed:", errorMessage2(e));
+      }
     },
-    /**
-     * Fires on SDK events. On session.created, kick off a background fetch of
-     * the taxonomy overview so it's ready before the first LLM call.
-     * Mirrors Claude Code's SessionStart context injection.
-     */
-    event: async (input) => {
-      await handleEvent(storeRoot, input);
+    "chat.message": async (input, _output) => {
+      try {
+        const sid = input.sessionID ?? "default";
+        incrementMsgCount(sid);
+        await autoMatchMemoirBranch(storePath, sid);
+      } catch (e) {
+        debugLog("chat.message: failed:", errorMessage2(e));
+      }
     },
-    /**
-     * Fires before every LLM call.
-     *
-     * 1. Injects the memoir taxonomy context for this session (once per session).
-     * 2. If a recall is pending for this session, injects a brief instruction
-     *    telling the model to use memoir tools (one-shot per trigger).
-     */
     "experimental.chat.system.transform": async (input, output) => {
-      await handleSystemTransform(input, output);
+      try {
+        const sid = input.sessionID ?? "default";
+        if (input.sessionID && !sessionsWithStartupHint.has(sid)) {
+          sessionsWithStartupHint.add(sid);
+          output.system?.unshift(
+            '[memoir] You have Memoir MCP tools (memoir_recall, memoir_remember, memoir_get, memoir_summarize, memoir_status, memoir_branches, memoir_checkout).\nSAVE (memoir_remember) after: task completion, user stating preferences/constraints, discovering project facts. RECALL (memoir_recall \u2192 memoir_get) at session start for prior context, when user asks about prior work.\nNamespaces: "default" (user context), "codebase:onboard" (project facts in git repos). Taxonomy paths: preferences.*, project.*, codebase.*, decisions.*, learning.*.'
+          );
+        }
+        const count = sessionMsgCount.get(sid) ?? 0;
+        if (shouldRemind(count)) {
+          output.system?.push(
+            "\n[memoir] Reminder: Use memoir_remember to save context, memoir_recall to retrieve prior context."
+          );
+        }
+      } catch (e) {
+        debugLog("system.transform: failed:", errorMessage2(e));
+      }
     },
-    /**
-     * Fires when the plugin is shut down. Flushes any remaining code changes
-     * and metrics (cf. SessionEnd heartbeat cleanup + final metrics flush).
-     */
     dispose: async () => {
       try {
-        await flushAllCapture(storeRoot);
-        clearSessionContext();
+        if (process.env.MEMOIR_AUTO_SAVE !== "0") {
+          for (const [sid, count] of sessionMsgCount) {
+            await callMemoir(
+              [
+                "remember",
+                `session.${sid}`,
+                "--message",
+                `Session ended \u2014 ${count} user messages exchanged`
+              ],
+              storePath
+            );
+          }
+        }
       } catch (e) {
-        const msg = `memoir: dispose error: ${errorMessage(e)}`;
-        debugLog(msg);
-        console.error(msg);
+        debugLog("dispose: save failed:", errorMessage2(e));
       }
+      sessionsWithStartupHint.clear();
+      pruneBranchCache();
+      pruneAll();
     }
   };
+  return hooks;
 };
 var plugin = {
   id: "opencode-memoir",