opencode-memoir 1.1.4 → 1.1.6

package/dist/index.js

@@ -1,10 +1,3 @@
-// src/store.ts
-import { execFile, execFileSync } from "node:child_process";
-import { access, mkdir, rm } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { homedir, tmpdir } from "node:os";
-import { promisify } from "node:util";
-
 // src/debug.ts
 function debugLog(...args) {
   if (process.env.MEMOIR_DEBUG !== "1") return;
@@ -13,6 +6,13 @@ 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 [];
@@ -54,12 +54,39 @@ 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();
+    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);
@@ -67,9 +94,17 @@ function _main_worktree_root(cwd) {
     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();
+      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 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();
@@ -77,11 +112,16 @@ function _main_worktree_root(cwd) {
         return mainWorktree;
       }
     }
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", timeout: GIT_TIMEOUT_MS }).trim();
+    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 "";
   }
 }
@@ -124,7 +164,9 @@ async function ensureStore(store) {
     if (ensuredStores.size > ENSURED_STORES_MAX) ensuredStores.clear();
     return;
   } catch {
-    await mkdir(join(store, ".."), { recursive: true }).catch((e) => debugLog("ensureStore: mkdir failed:", errorMessage(e)));
+    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()}`);
@@ -141,7 +183,9 @@ async function ensureStore(store) {
       debugLog("ensureStore: creation failed:", errorMessage(e));
       throw e;
     } finally {
-      rm(tmpDir, { recursive: true, force: true }).catch((e) => debugLog("tmp cleanup failed:", errorMessage(e)));
+      rm(tmpDir, { recursive: true, force: true }).catch(
+        (e) => debugLog("tmp cleanup failed:", errorMessage(e))
+      );
     }
   })();
   storeCreations.set(store, creationPromise);
@@ -191,8 +235,16 @@ async function runMemoir(args, options = {}) {
 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" }
+    {
+      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) {
@@ -210,7 +262,10 @@ async function getCurrentBranch(store) {
 async function codeGitBranch() {
   try {
     const execFn = _storeTestOverrides.execFileAsyncFn ?? execFileAsync;
-    const { stdout } = await execFn("git", ["branch", "--show-current"], { encoding: "utf8", timeout: GIT_TIMEOUT_MS });
+    const { stdout } = await execFn("git", ["branch", "--show-current"], {
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS
+    });
     return stdout.trim();
   } catch (e) {
     debugLog("codeGitBranch: failed:", errorMessage(e));
@@ -240,7 +295,9 @@ async function autoMatchMemoirBranch(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 });
+    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);
@@ -256,7 +313,9 @@ async function autoMatchMemoirBranch(store) {
 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 });
+    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 ?? [];
@@ -269,128 +328,224 @@ async function readMemoirValue(store, key, namespace = "default") {
 }
 var _storeTestOverrides = {};
 
-// src/tools.ts
-import { tool } from "@opencode-ai/plugin";
-
-// 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) {
-  try {
-    await ensureStore(store);
-    return null;
-  } catch (error) {
-    return 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);
 }
-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;
+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
+  });
 }
-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`);
+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 {
-    const existing = JSON.parse(await readFile(pidfile, "utf8"));
-    if (existing?.pid && existing?.url) {
+    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 {
-        process.kill(Number(existing.pid), 0);
-        return JSON.stringify({ ...existing, reused: true }, null, 2);
+        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) {
-        debugLog("launchUi: process dead, relaunching:", errorMessage(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("launchUi: failed to read pidfile:", errorMessage(e));
-    await rm2(pidfile, { force: true }).catch((e2) => debugLog("launchUi: failed to remove stale pidfile", errorMessage(e2)));
-  }
-  let lastError = "";
-  let uiSpecs = memoirSpawnSpecs(["ui", store]);
-  if (memoirResolved) {
-    const winner = uiSpecs.find((s) => s.label === memoirResolved);
-    if (winner) uiSpecs = reorderResolver(uiSpecs, winner);
+    debugLog("flushCapture: failed:", errorMessage(e));
   }
-  for (const spec of uiSpecs) {
-    const child = spawn(spec.command, spec.args, {
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
-    });
-    let output = "";
-    child.stdout?.on("data", (chunk) => {
-      output += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      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();
-    const urlPattern = /https?:\/\/(?:localhost|127\.0\.0\.1):\d+\S*/;
-    const deadline = Date.now() + UI_URL_DEADLINE_MS;
-    while (Date.now() < deadline) {
-      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));
-    }
-    return `Memoir UI started with ${spec.label} (pid ${child.pid ?? "unknown"}), but URL was not detected yet.
-${output.trim()}`.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 = [];
-  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.";
 }
 
 // src/recall-gate.ts
@@ -432,405 +587,291 @@ function shouldTriggerRecall(text) {
 }
 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: {},
-  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().optional().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);
+// src/capture-hooks.ts
+async function handleShellEnv(storeRoot, _input, output) {
+  try {
+    output.env.MEMOIR_STORE = storeRoot;
+  } catch (e) {
+    debugLog("shell.env: failed:", errorMessage(e));
   }
-});
-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 sections = [];
-    for (const namespace of namespaces) {
-      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}`);
+}
+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 });
     }
-    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}
-` : "";
-    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")}`;
-  }
-});
-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.`;
+    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()
+        });
+      }
     }
-    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);
+  } catch (e) {
+    debugLog("tool.execute.after: failed:", errorMessage(e));
   }
-});
-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) {
+async function handleChatMessage(storeRoot, input, output) {
   try {
-    if (input.command === "memoir:status") {
-      pushText(output, await statusJson(storeRoot));
-    }
-    if (input.command === "memoir:ui") {
-      pushText(output, await launchUi(storeRoot));
+    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);
     }
-    if (input.command === "memoir:unmerged") {
-      pushText(output, await unmergedBranchesText(storeRoot));
+    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 (error) {
-    pushText(output, `Memoir command failed: ${errorMessage(error)}`);
+  } catch (e) {
+    debugLog("chat.message: failed:", errorMessage(e));
   }
 }
-
-// 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);
+async function flushAllCapture(storeRoot) {
+  await flushCapture(storeRoot);
 }
-function recordEdit(sessionID, edit) {
-  let edits = pendingEditsBySession.get(sessionID);
-  if (!edits) {
-    edits = [];
-    pendingEditsBySession.set(sessionID, edits);
-    evictOldest(pendingEditsBySession, 500);
+
+// 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;
+async function ensureStoreOrError(store) {
+  try {
+    await ensureStore(store);
+    return null;
+  } catch (error) {
+    return errorMessage(error);
   }
-  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
-    });
+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;
   }
-  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;
+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`);
   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;
+    const existing = JSON.parse(await readFile(pidfile, "utf8"));
+    if (existing?.pid && existing?.url) {
       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}`);
-            }
-          }
-        }
+        process.kill(Number(existing.pid), 0);
+        return JSON.stringify({ ...existing, reused: true }, null, 2);
       } 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;
+        debugLog("launchUi: process dead, relaunching:", errorMessage(e));
+      }
+    }
+  } 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))
+    );
+  }
+  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({
+          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) => {
+      output += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      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();
+    const urlPattern = /https?:\/\/(?:localhost|127\.0\.0\.1):\d+\S*/;
+    const deadline = Date.now() + UI_URL_DEADLINE_MS;
+    while (Date.now() < deadline) {
+      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);
       }
-    } finally {
-      releaseLock();
+      await new Promise((resolve2) => setTimeout(resolve2, UI_URL_POLL_MS));
     }
-  } catch (e) {
-    debugLog("flushCapture: failed:", errorMessage(e));
+    return `Memoir UI started with ${spec.label} (pid ${child.pid ?? "unknown"}), but URL was not detected yet.
+${output.trim()}`.trim();
   }
+  return `Memoir UI failed to start: ${lastError || "no launcher succeeded"}`;
 }
-
-// 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 unmergedBranchesText(store) {
+  await ensureStore(store);
+  const branchResult = await runMemoir(["--json", "-s", store, "branch"], { cwd: store });
+  if (!branchResult.ok) {
+    return branchResult.error;
   }
-}
-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 });
+  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 (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() });
-      }
+    if (diffResult.stdout.trim()) {
+      unmerged.push(branch);
     }
-  } catch (e) {
-    debugLog("tool.execute.after: failed:", errorMessage(e));
   }
+  return unmerged.length > 0 ? `Unmerged branches:
+${unmerged.join("\n")}` : "All branches are merged into main.";
 }
-async function handleChatMessage(storeRoot, input, output) {
+
+// 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 {
-    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);
+    if (input.command === "memoir:status") {
+      pushText(output, await statusJson(storeRoot));
     }
-    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);
+    if (input.command === "memoir:ui") {
+      pushText(output, await launchUi(storeRoot));
     }
-  } catch (e) {
-    debugLog("chat.message: failed:", errorMessage(e));
+    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)}`);
   }
 }
-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) {
@@ -854,27 +895,30 @@ function pruneStaleSessions() {
 async function handleEvent(storeRoot, input) {
   if (input.event.type === "session.created" && !initContextFetched) {
     initContextFetched = true;
-    (async () => {
-      try {
-        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}`;
-      } catch (e) {
-        debugLog("event: taxonomy fetch failed, will retry on next session:", errorMessage(e));
-        initContextFetched = false;
+    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;
       }
-    })().catch(() => {
       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;
@@ -900,6 +944,107 @@ function clearSessionContext() {
   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().optional().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 sections = [];
+    for (const namespace of namespaces) {
+      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}`);
+    }
+    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}
+` : "";
+    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")}`;
+  }
+});
+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 ?? {};
@@ -972,6 +1117,9 @@ var MemoirOpenCode = async (_input, rawOptions) => {
         await flushAllCapture(storeRoot);
         clearSessionContext();
       } catch (e) {
+        const msg = `memoir: dispose error: ${errorMessage(e)}`;
+        debugLog(msg);
+        console.error(msg);
       }
     }
   };