opencode-memoir 1.1.3 → 1.1.5

package/dist/index.js

@@ -1,11 +1,3 @@
-// src/index.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 { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-import { tool } from "@opencode-ai/plugin";
-
 // src/store.ts
 import { execFile, execFileSync } from "node:child_process";
 import { access, mkdir, rm } from "node:fs/promises";
@@ -62,9 +54,28 @@ var GIT_TIMEOUT_MS = 3e3;
 var MEMOIR_TIMEOUT_MS = 15e3;
 var MEMOIR_MAX_BUFFER = 1024 * 1024;
 var NO_GIT_CACHE_MAX = 500;
-var _noGitCache = /* @__PURE__ */ new Set();
+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 (_noGitCache.has(cwd)) return "";
+  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();
@@ -88,8 +99,9 @@ function _main_worktree_root(cwd) {
     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));
-    _noGitCache.add(cwd);
-    if (_noGitCache.size > NO_GIT_CACHE_MAX) _noGitCache.clear();
+    sweepNoGitCache();
+    _noGitCache.set(cwd, Date.now());
+    if (_noGitCache.size > NO_GIT_CACHE_MAX) evictOldestNoGit();
     return "";
   }
 }
@@ -140,8 +152,8 @@ async function ensureStore(store) {
       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.startsWith("Memoir command failed")) {
-        throw new Error(result);
+      if (!result.ok) {
+        throw new Error(result.error);
       }
       ensuredStores.add(store);
       if (ensuredStores.size > ENSURED_STORES_MAX) ensuredStores.clear();
@@ -175,6 +187,7 @@ async function runMemoir(args, options = {}) {
     if (winner) specs = reorderResolver(specs, winner);
   }
   let lastError = "";
+  let lastResolver;
   for (const spec of specs) {
     try {
       const { stdout } = await execFileAsync(spec.command, spec.args, {
@@ -185,14 +198,15 @@ async function runMemoir(args, options = {}) {
         // prevent hang if memoir CLI stalls
       });
       memoirResolved = spec.label;
-      return stdout.trim();
+      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 `Memoir command failed: ${lastError}`;
+  return { ok: false, error: `Memoir command failed: ${lastError}`, resolver: lastResolver };
 }
 function memoirSpawnSpecs(args) {
   return [
@@ -203,8 +217,10 @@ function memoirSpawnSpecs(args) {
 }
 async function getCurrentBranch(store) {
   try {
-    const raw = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
-    const data = JSON.parse(raw);
+    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));
@@ -213,7 +229,8 @@ async function getCurrentBranch(store) {
 }
 async function codeGitBranch() {
   try {
-    const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { encoding: "utf8", timeout: GIT_TIMEOUT_MS });
+    const execFn = _storeTestOverrides.execFileAsyncFn ?? execFileAsync;
+    const { stdout } = await execFn("git", ["branch", "--show-current"], { encoding: "utf8", timeout: GIT_TIMEOUT_MS });
     return stdout.trim();
   } catch (e) {
     debugLog("codeGitBranch: failed:", errorMessage(e));
@@ -223,8 +240,10 @@ async function codeGitBranch() {
 async function branchExistsInMemoir(store, name) {
   if (!name) return false;
   try {
-    const raw = await runMemoir(["--json", "-s", store, "branch"], { cwd: store });
-    const data = JSON.parse(raw);
+    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) {
@@ -233,6 +252,7 @@ async function branchExistsInMemoir(store, name) {
   }
 }
 async function autoMatchMemoirBranch(store) {
+  const runFn = _storeTestOverrides.runMemoirFn ?? runMemoir;
   const codeBranch = await codeGitBranch();
   if (!codeBranch) {
     return getCurrentBranch(store);
@@ -240,23 +260,25 @@ async function autoMatchMemoirBranch(store) {
   const current = await getCurrentBranch(store);
   if (current === codeBranch) return current;
   if (!await branchExistsInMemoir(store, codeBranch)) {
-    const result2 = await runMemoir(["-s", store, "branch", codeBranch, "--from", "main"], { cwd: store });
-    if (result2.startsWith("Memoir command failed")) {
-      debugLog("autoMatchMemoirBranch: create branch failed:", result2);
+    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 runMemoir(["-s", store, "checkout", codeBranch], { cwd: store });
-  if (result.startsWith("Memoir command failed")) {
-    debugLog("autoMatchMemoirBranch: checkout failed:", result);
+  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 raw = await runMemoir(["--json", "-s", store, "get", key, "-n", namespace], { cwd: store });
-    const parsed = JSON.parse(raw);
+    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 : "";
@@ -265,221 +287,17 @@ async function readMemoirValue(store, key, namespace = "default") {
     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();
-function getCachedBranch(sessionID) {
-  return cachedBranchBySession.get(sessionID) ?? "unknown";
-}
-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;
-}
-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;
-  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 results = await Promise.all([codeWrite, turnWrite].filter(Boolean));
-          for (const result of results) {
-            if (typeof result === "string" && result.startsWith("Memoir command failed")) {
-              throw new Error(`Memoir write failed: ${result}`);
-            }
-          }
-        }
-      } 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/tools.ts
+import { tool } from "@opencode-ai/plugin";
 
-// src/index.ts
+// 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 { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 var UI_URL_DEADLINE_MS = 5e3;
 var UI_URL_POLL_MS = 100;
 async function ensureStoreOrError(store) {
@@ -493,15 +311,16 @@ async function ensureStoreOrError(store) {
 async function statusJson(store) {
   const storeErr = await ensureStoreOrError(store);
   if (storeErr) return `Memoir command failed: ${storeErr}`;
-  const raw = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
+  const result = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
+  if (!result.ok) return result.error;
   try {
-    const data = JSON.parse(raw);
+    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 raw;
+    return result.stdout;
   }
 }
 async function launchUi(store) {
@@ -534,7 +353,10 @@ async function launchUi(store) {
     const child = spawn(spec.command, spec.args, {
       detached: true,
       stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
+      // Scrub process.env — only forward whitelisted vars to avoid leaking secrets
+      env: Object.fromEntries(
+        Object.entries({ 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) => {
@@ -570,86 +392,70 @@ ${output.trim()}`.trim();
   }
   return `Memoir UI failed to start: ${lastError || "no launcher succeeded"}`;
 }
-function pushText(output, text) {
-  output.parts.length = 0;
-  output.parts.push({ type: "text", text });
-}
-var initContext = null;
-var initContextFetched = false;
-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;
+async function unmergedBranchesText(store) {
+  await ensureStore(store);
+  const branchResult = await runMemoir(["--json", "-s", store, "branch"], { cwd: store });
+  if (!branchResult.ok) {
+    return branchResult.error;
   }
-  return true;
-}
-function markSessionContext(sessionID) {
-  sessionsWithContext.set(sessionID, Date.now());
+  const data = JSON.parse(branchResult.stdout);
+  const branches = data?.branches ?? [];
+  const unmerged = [];
+  for (const branch of branches) {
+    if (branch === "main") continue;
+    const diffResult = await runMemoir(["-s", store, "diff", branch, "main", "--stat"], { cwd: store });
+    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 pruneStaleSessions() {
-  const now = Date.now();
-  for (const [id, ts] of sessionsWithContext) {
-    if (now - ts > SESSION_CONTEXT_TTL_MS) sessionsWithContext.delete(id);
-  }
-}
-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
 
-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.
-
-Memory rules:
-- Record only verified facts from files/docs/code or explicit user statements.
-- Do not write inferred user thoughts, intentions, preferences, or opinions.
-- 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."
-  };
+// 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/tools.ts
 var memoirStatus = tool({
   description: "Show Memoir status for the current OpenCode project store.",
   args: {},
@@ -680,7 +486,9 @@ var memoirRemember = tool({
     for (const p of paths) cliArgs.push("-p", p);
     cliArgs.push("-n", args.namespace ?? "default");
     if (args.replace) cliArgs.push("--replace");
-    return tryPrettyJson(await runMemoir(cliArgs, { cwd: store }));
+    const rememberResult = await runMemoir(cliArgs, { cwd: store });
+    if (!rememberResult.ok) return rememberResult.error;
+    return tryPrettyJson(rememberResult.stdout);
   }
 });
 var memoirRecall = tool({
@@ -698,7 +506,9 @@ var memoirRecall = tool({
     const namespaces = args.namespace ? [args.namespace] : args.namespaces && args.namespaces.length > 0 ? args.namespaces : DEFAULT_RECALL_NAMESPACES;
     const sections = [];
     for (const namespace of namespaces) {
-      const output = tryPrettyJson(await runMemoir(["--json", "-s", store, "summarize", "--depth", "3", "-n", namespace], { cwd: store }));
+      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);
       sections.push(`## namespace: ${namespace}
 ${output}`);
     }
@@ -725,59 +535,418 @@ var memoirGet = tool({
     const store = deriveStorePath();
     const storeError = await ensureStoreOrError(store);
     if (storeError) return storeError;
-    return tryPrettyJson(await runMemoir(["--json", "-s", store, "get", ...keys, "-n", args.namespace ?? "default"], { cwd: store }));
+    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/commands.ts
+function pushText(output, text) {
+  output.parts.length = 0;
+  output.parts.push({ type: "text", text });
+}
+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
+
+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.
+
+Memory rules:
+- Record only verified facts from files/docs/code or explicit user statements.
+- Do not write inferred user thoughts, intentions, preferences, or opinions.
+- 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));
+    }
+    if (input.command === "memoir:ui") {
+      pushText(output, await launchUi(storeRoot));
+    }
+    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.");
+      }
+    }
+    if (input.command === "memoir:unmerged") {
+      pushText(output, await unmergedBranchesText(storeRoot));
+    }
+  } catch (error) {
+    pushText(output, `Memoir command failed: ${errorMessage(error)}`);
+  }
+}
+
+// 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();
+function getCachedBranch(sessionID) {
+  return cachedBranchBySession.get(sessionID) ?? "unknown";
+}
+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;
+}
+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;
+  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/capture-hooks.ts
+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" && 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_CAPTURE !== "1" && 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() });
+      }
+    }
+  } 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;
+    setCachedBranch(sid, await autoMatchMemoirBranch(storeRoot));
+    if (process.env.MEMOIR_NO_CAPTURE !== "1") {
+      await flushCapture(storeRoot, prevBranch, sid);
+    }
+  } catch (e) {
+    debugLog("chat.message: failed:", errorMessage(e));
+  }
+}
+async function flushAllCapture(storeRoot) {
+  await flushCapture(storeRoot);
+}
+
+// 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/index.ts
 var MemoirOpenCode = async (_input, rawOptions) => {
   const opts = rawOptions ?? {};
   if (opts.store) setPluginStoreOverride(opts.store);
   const storeRoot = deriveStorePath();
   return {
     name: "memoir",
-    tool: {
-      memoir_status: memoirStatus,
-      memoir_remember: memoirRemember,
-      memoir_recall: memoirRecall,
-      memoir_get: memoirGet
-    },
+    tool: { ...memoirTools },
     config: async (opencodeConfig) => {
       registerCommands(opencodeConfig);
     },
     "command.execute.before": async (input, output) => {
-      try {
-        if (input.command === "memoir:status") {
-          pushText(output, await statusJson(storeRoot));
-        }
-        if (input.command === "memoir:ui") {
-          pushText(output, await launchUi(storeRoot));
-        }
-        if (input.command === "memoir:unmerged") {
-          const store = storeRoot;
-          await ensureStore(store);
-          const raw = await runMemoir(["--json", "-s", store, "branch"], { cwd: store });
-          const data = JSON.parse(raw);
-          const branches = data?.branches ?? [];
-          const unmerged = [];
-          for (const branch of branches) {
-            if (branch === "main") continue;
-            const diffOut = await runMemoir(["-s", store, "diff", branch, "main", "--stat"], { cwd: store });
-            if (diffOut.startsWith("Memoir command failed")) {
-              debugLog("command.execute.before: memoir diff failed", diffOut);
-              continue;
-            }
-            if (diffOut.trim()) {
-              unmerged.push(branch);
-            }
-          }
-          pushText(
-            output,
-            unmerged.length > 0 ? `Unmerged branches:
-${unmerged.join("\n")}` : "All branches are merged into main."
-          );
-        }
-      } catch (error) {
-        pushText(output, `Memoir command failed: ${errorMessage(error)}`);
-      }
+      await handleCommandExecuteBefore(storeRoot, input, output);
     },
     /**
      * Inject MEMOIR_STORE into every shell command's environment so any memoir
@@ -786,11 +955,7 @@ ${unmerged.join("\n")}` : "All branches are merged into main."
      * on every shell command).
      */
     "shell.env": async (_input2, output) => {
-      try {
-        output.env.MEMOIR_STORE = storeRoot;
-      } catch (e) {
-        debugLog("shell.env: failed:", errorMessage(e));
-      }
+      await handleShellEnv(storeRoot, _input2, output);
     },
     /**
      * Observe every tool execution for metrics and code-change tracking.
@@ -798,22 +963,7 @@ ${unmerged.join("\n")}` : "All branches are merged into main."
      * Never modifies the tool output.
      */
     "tool.execute.after": async (input, output) => {
-      try {
-        const sid = input.sessionID ?? "default";
-        if (process.env.MEMOIR_NO_CAPTURE !== "1" && process.env.MEMOIR_NO_METRICS !== "1") {
-          const calls = 1;
-          const errors = output.metadata?.error || output.output?.startsWith("Error:") ? 1 : 0;
-          recordToolMetrics(sid, input.tool, { calls, errors });
-        }
-        if (process.env.MEMOIR_NO_CAPTURE !== "1" && process.env.MEMOIR_NO_CODE_SUMMARY !== "1" && EDIT_TOOLS.has(input.tool)) {
-          const filePath = typeof input.args?.filePath === "string" ? input.args.filePath : typeof input.args?.path === "string" ? input.args.path : "";
-          if (filePath) {
-            recordEdit(sid, { tool: input.tool, filePath, snippet: "", timestamp: Date.now() });
-          }
-        }
-      } catch (e) {
-        debugLog("tool.execute.after: failed:", errorMessage(e));
-      }
+      await handleToolExecuteAfter(input, output);
     },
     /**
      * Fires on every incoming user message.
@@ -827,50 +977,15 @@ ${unmerged.join("\n")}` : "All branches are merged into main."
      * Steps 1–2 are skipped when MEMOIR_NO_CAPTURE=1.
      */
     "chat.message": async (input, output) => {
-      try {
-        const sid = input.sessionID ?? "default";
-        const text = output.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;
-        setCachedBranch(sid, await autoMatchMemoirBranch(storeRoot));
-        if (process.env.MEMOIR_NO_CAPTURE !== "1") {
-          await flushCapture(storeRoot, prevBranch, sid);
-        }
-      } catch (e) {
-        debugLog("chat.message: failed:", errorMessage(e));
-      }
+      await handleChatMessage(storeRoot, input, output);
     },
     /**
      * 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 ({ event: evt }) => {
-      if (evt.type === "session.created" && !initContextFetched) {
-        initContextFetched = true;
-        (async () => {
-          try {
-            const taxonomy = await runMemoir(
-              ["--json", "-s", storeRoot, "summarize", "--depth", "3", "-n", "default"],
-              { cwd: storeRoot }
-            );
-            if (taxonomy.startsWith("Memoir command failed")) {
-              throw new Error(taxonomy);
-            }
-            const pretty = tryPrettyJson(taxonomy);
-            initContext = `[memoir] Available taxonomy paths:
-${pretty}`;
-          } catch (e) {
-            debugLog("event: taxonomy fetch failed, will retry on next session:", errorMessage(e));
-            initContextFetched = false;
-          }
-        })().catch(() => {
-          initContextFetched = false;
-        });
-      }
+    event: async (input) => {
+      await handleEvent(storeRoot, input);
     },
     /**
      * Fires before every LLM call.
@@ -880,22 +995,7 @@ ${pretty}`;
      *    telling the model to use memoir tools (one-shot per trigger).
      */
     "experimental.chat.system.transform": async (input, output) => {
-      try {
-        if (input.sessionID && !hasSessionContext(input.sessionID)) {
-          markSessionContext(input.sessionID);
-          if (initContext) {
-            output.system.unshift(initContext);
-          }
-        }
-        if (input.sessionID && pendingRecall.has(input.sessionID)) {
-          pendingRecall.delete(input.sessionID);
-          output.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));
-      }
+      await handleSystemTransform(input, output);
     },
     /**
      * Fires when the plugin is shut down. Flushes any remaining code changes
@@ -903,11 +1003,12 @@ ${pretty}`;
      */
     dispose: async () => {
       try {
-        await flushCapture(storeRoot);
-        pruneStaleSessions();
-        sessionsWithContext.clear();
+        await flushAllCapture(storeRoot);
+        clearSessionContext();
       } catch (e) {
-        debugLog("dispose: failed:", errorMessage(e));
+        const msg = `memoir: dispose error: ${errorMessage(e)}`;
+        debugLog(msg);
+        console.error(msg);
       }
     }
   };