opencode-memoir 1.0.4 → 1.0.6

package/dist/index.js

@@ -1,464 +1,877 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { tool } from '@opencode-ai/plugin';
-import { autoMatchMemoirBranch, codeGitBranch, deriveStorePath, ensureStore, memoirResolved, memoirSpawnSpecs, runMemoir, setPluginStoreOverride } from './store.js';
-import { EDIT_TOOLS, flushCapture, getCachedBranch, recordEdit, recordToolMetrics, setCachedBranch } from './capture.js';
-import { DEFAULT_RECALL_NAMESPACES, isSecretSanitizationEnabled, pendingRecall, SECRET_PATTERN, shouldTriggerRecall } from './recall-gate.js';
-import { debugLog } from './debug.js';
-async function statusJson(store) {
-    await ensureStore(store);
-    const raw = await runMemoir(['--json', '-s', store, 'status'], { cwd: store });
+// 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";
+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;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  process.stderr.write(`[memoir ${ts}] ${args.map((a) => String(a)).join(" ")}
+`);
+}
+
+// src/store.ts
+var execFileAsync = promisify(execFile);
+var MEMOIR_PACKAGE = "memoir-ai";
+var MEMOIR_AI_PIN = "0.2.2";
+var _noGitCache = /* @__PURE__ */ new Set();
+function _main_worktree_root(cwd) {
+  if (_noGitCache.has(cwd)) return "";
+  try {
+    const gitDir = execFileSync("git", ["rev-parse", "--git-dir"], { cwd, encoding: "utf8", timeout: 3e3 }).trim();
+    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], { cwd, encoding: "utf8", timeout: 3e3 }).trim();
+    const resolvePath = (path) => {
+      if (path.startsWith("/")) return path;
+      return join(cwd, path);
+    };
+    const gitDirAbs = resolvePath(gitDir);
+    const gitCommonDirAbs = resolvePath(gitCommonDir);
+    if (gitDirAbs === gitCommonDirAbs) {
+      return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", timeout: 3e3 }).trim();
+    }
+    const worktreeList = execFileSync("git", ["worktree", "list", "--porcelain"], { cwd, encoding: "utf8", timeout: 3e3 });
+    const firstLine = worktreeList.split("\n")[0];
+    if (firstLine.startsWith("worktree ")) {
+      const mainWorktree = firstLine.substring("worktree ".length).trim();
+      if (mainWorktree && mainWorktree !== "(bare)") {
+        return mainWorktree;
+      }
+    }
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", timeout: 3e3 }).trim();
+  } catch (e) {
+    debugLog("_main_worktree_root: not a git repo or git error:", e instanceof Error ? e.message : String(e));
+    _noGitCache.add(cwd);
+    return "";
+  }
+}
+function deriveStorePath(cwd = process.cwd()) {
+  if (pluginStoreOverride) return pluginStoreOverride;
+  const configured = process.env.MEMOIR_STORE;
+  if (configured) return configured;
+  let projectDir;
+  try {
+    const gitRoot = _main_worktree_root(cwd);
+    if (gitRoot) {
+      projectDir = gitRoot;
+    } else {
+      projectDir = resolve(cwd);
+    }
+  } catch (e) {
+    debugLog("deriveStorePath: unexpected error:", e instanceof Error ? e.message : String(e));
+    projectDir = cwd;
+  }
+  const slug = projectDir.replace(/[/.]/g, "-");
+  return join(homedir(), ".memoir", slug);
+}
+var pluginStoreOverride;
+function setPluginStoreOverride(store) {
+  pluginStoreOverride = store;
+}
+var ensuredStores = /* @__PURE__ */ new Set();
+var storeCreations = /* @__PURE__ */ new Map();
+async function ensureStore(store) {
+  if (ensuredStores.has(store)) return;
+  const inFlight = storeCreations.get(store);
+  if (inFlight) {
+    await inFlight;
+    return;
+  }
+  try {
+    await access(join(store, ".git"));
+    ensuredStores.add(store);
+    return;
+  } catch {
+    await mkdir(join(store, ".."), { recursive: true }).catch((e) => debugLog("ensureStore: mkdir failed:", e instanceof Error ? e.message : String(e)));
+  }
+  const creationPromise = (async () => {
+    const tmpDir = join(tmpdir(), `memoir-scratch-${Date.now()}`);
     try {
-        const data = JSON.parse(raw);
-        const branch = await codeGitBranch();
-        data.opencode = { store, project_git_root: process.cwd(), project_git_branch: branch };
-        return JSON.stringify(data, null, 2);
+      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);
+      }
+      ensuredStores.add(store);
+    } finally {
+      rm(tmpDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  })();
+  storeCreations.set(store, creationPromise);
+  try {
+    await creationPromise;
+  } finally {
+    storeCreations.delete(store);
+  }
+}
+var memoirResolved = null;
+async function runMemoir(args, options = {}) {
+  const specs = memoirSpawnSpecs(args);
+  if (memoirResolved) {
+    const idx = specs.findIndex((s) => s.label === memoirResolved);
+    if (idx > 0) {
+      const [cached] = specs.splice(idx, 1);
+      specs.unshift(cached);
+    }
+  }
+  for (const spec of specs) {
+    try {
+      const { stdout } = await execFileAsync(spec.command, spec.args, {
+        cwd: options.cwd ?? process.cwd(),
+        env: process.env,
+        maxBuffer: 1024 * 1024,
+        timeout: 15e3
+        // prevent hang if memoir CLI stalls
+      });
+      memoirResolved = spec.label;
+      return stdout.trim();
+    } catch (e) {
+      debugLog("runMemoir: fallback", spec.label, "failed:", e instanceof Error ? e.message : String(e));
+      if (memoirResolved === spec.label) memoirResolved = null;
     }
-    catch (e) {
-        debugLog('statusJson: failed to parse JSON:', e instanceof Error ? e.message : String(e));
-        return raw;
+  }
+  try {
+    const { stdout } = await execFileAsync("memoir", args, {
+      cwd: options.cwd ?? process.cwd(),
+      env: process.env,
+      maxBuffer: 1024 * 1024,
+      timeout: 15e3
+    });
+    return stdout.trim();
+  } catch (memoirError) {
+    const err = memoirError;
+    const detail = (err.stderr || err.stdout || err.message).trim();
+    return `Memoir command failed${err.code ? ` (${err.code})` : ""}: ${detail}`;
+  }
+}
+function memoirSpawnSpecs(args) {
+  return [
+    { command: "memoir", args, label: "memoir" },
+    { command: "uvx", args: ["--from", `${MEMOIR_PACKAGE}==${MEMOIR_AI_PIN}`, "memoir", ...args], label: "uvx" },
+    { command: "uv", args: ["tool", "run", "--from", `${MEMOIR_PACKAGE}==${MEMOIR_AI_PIN}`, "memoir", ...args], label: "uv tool run" }
+  ];
+}
+async function getCurrentBranch(store) {
+  try {
+    const raw = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
+    const data = JSON.parse(raw);
+    return data.branch || "unknown";
+  } catch (e) {
+    debugLog("getCurrentBranch: failed:", e instanceof Error ? e.message : String(e));
+    return "unknown";
+  }
+}
+async function codeGitBranch() {
+  try {
+    const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { encoding: "utf8", timeout: 3e3 });
+    return stdout.trim();
+  } catch (e) {
+    debugLog("codeGitBranch: failed:", e instanceof Error ? e.message : String(e));
+    return "";
+  }
+}
+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 branches = data?.branches ?? [];
+    return branches.includes(name);
+  } catch (e) {
+    debugLog("branchExistsInMemoir: failed:", e instanceof Error ? e.message : String(e));
+    return false;
+  }
+}
+async function autoMatchMemoirBranch(store) {
+  const codeBranch = await codeGitBranch();
+  if (!codeBranch) {
+    return getCurrentBranch(store);
+  }
+  const current = await getCurrentBranch(store);
+  if (current === codeBranch) return current;
+  if (!await branchExistsInMemoir(store, codeBranch)) {
+    const result2 = await runMemoir(["-s", store, "branch", codeBranch, "--from", "main"], { cwd: store });
+    if (result2.startsWith("Memoir command failed")) {
+      debugLog("autoMatchMemoirBranch: create branch failed:", result2);
+      return getCurrentBranch(store);
     }
+  }
+  const result = await runMemoir(["-s", store, "checkout", codeBranch], { cwd: store });
+  if (result.startsWith("Memoir command failed")) {
+    debugLog("autoMatchMemoirBranch: checkout failed:", result);
+    return getCurrentBranch(store);
+  }
+  return codeBranch;
 }
-async function launchUi(store) {
+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 items = parsed?.items ?? [];
+    const value = items[0]?.value?.content;
+    return typeof value === "string" ? value : "";
+  } catch (e) {
+    debugLog("readMemoirValue: failed:", e instanceof Error ? e.message : String(e));
+    return "";
+  }
+}
+
+// src/capture.ts
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "apply_patch", "ApplyPatch", "MultiFileEdit"]);
+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);
+}
+function recordEdit(sessionID, edit) {
+  let edits = pendingEditsBySession.get(sessionID);
+  if (!edits) {
+    edits = [];
+    pendingEditsBySession.set(sessionID, edits);
+  }
+  edits.push(edit);
+}
+function recordToolMetrics(sessionID, tool2, metrics) {
+  let sessionMetrics = toolMetricsBySession.get(sessionID);
+  if (!sessionMetrics) {
+    sessionMetrics = /* @__PURE__ */ new Map();
+    toolMetricsBySession.set(sessionID, sessionMetrics);
+  }
+  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 pidDir = join(homedir(), '.memoir', 'ui-servers');
-    await mkdir(pidDir, { recursive: true });
-    const hash = createHash('sha256').update(store).digest('hex').slice(0, 8);
-    const pidfile = join(pidDir, `${hash}.json`);
+    const releaseLock = await acquireFlushLock(store);
     try {
-        const existing = JSON.parse(await readFile(pidfile, 'utf8'));
-        if (existing?.pid && existing?.url) {
-            try {
-                process.kill(Number(existing.pid), 0); // check if alive
-                return JSON.stringify({ ...existing, reused: true }, null, 2);
+      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 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 ? readMemoirValue(store, `metrics.code.${branchKey}`) : Promise.resolve(""),
+            metrics.size > 0 ? 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:", e instanceof Error ? e.message : String(e));
+              }
+            }
+            acc.entries.push(entry);
+            if (acc.entries.length > METRICS_CODE_MAX) acc.entries = acc.entries.slice(-METRICS_CODE_MAX);
+            codeWrite = 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 });
             }
-            catch (e) {
-                debugLog('launchUi: process dead, relaunching:', e instanceof Error ? e.message : String(e));
-                // process is dead — fall through to relaunch
+            turnWrite = 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('launchUi: failed to read pidfile:', e instanceof Error ? e.message : String(e));
-        await rm(pidfile, { force: true }).catch(() => undefined);
+  } catch (e) {
+    debugLog("flushCapture: failed:", e instanceof Error ? e.message : String(e));
+  }
+}
+
+// src/recall-gate.ts
+var SECRET_PATTERN = /(api[_-]?key|auth_token|access_token|\btoken\b|\bsecret\b|\bpassword\b|\bpasswd\b|private[_-]?key|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
+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/index.ts
+async function statusJson(store) {
+  await ensureStore(store);
+  const raw = await runMemoir(["--json", "-s", store, "status"], { cwd: store });
+  try {
+    const data = JSON.parse(raw);
+    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:", e instanceof Error ? e.message : String(e));
+    return raw;
+  }
+}
+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 {
+    const existing = JSON.parse(await readFile(pidfile, "utf8"));
+    if (existing?.pid && existing?.url) {
+      try {
+        process.kill(Number(existing.pid), 0);
+        return JSON.stringify({ ...existing, reused: true }, null, 2);
+      } catch (e) {
+        debugLog("launchUi: process dead, relaunching:", e instanceof Error ? e.message : String(e));
+      }
     }
-    let lastError = '';
-    const uiSpecs = memoirSpawnSpecs(['ui', store]);
-    // Reorder: put cached memoir resolver first, same as runMemoir
-    if (memoirResolved) {
-        const idx = uiSpecs.findIndex(s => s.label === memoirResolved);
-        if (idx > 0) {
-            const [cached] = uiSpecs.splice(idx, 1);
-            uiSpecs.unshift(cached);
-        }
+  } catch (e) {
+    debugLog("launchUi: failed to read pidfile:", e instanceof Error ? e.message : String(e));
+    await rm2(pidfile, { force: true }).catch(() => void 0);
+  }
+  let lastError = "";
+  const uiSpecs = memoirSpawnSpecs(["ui", store]);
+  if (memoirResolved) {
+    const idx = uiSpecs.findIndex((s) => s.label === memoirResolved);
+    if (idx > 0) {
+      const [cached] = uiSpecs.splice(idx, 1);
+      uiSpecs.unshift(cached);
     }
-    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(resolve => {
-            child.once('error', error => resolve(String(error.message || error)));
-            child.once('spawn', () => resolve(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() + 5000;
-        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: new Date().toISOString(), reused: false };
-                await writeFile(pidfile, JSON.stringify(data, null, 2));
-                return JSON.stringify(data, null, 2);
-            }
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        return `Memoir UI started with ${spec.label} (pid ${child.pid ?? 'unknown'}), but URL was not detected yet.\n${output.trim()}`.trim();
+  }
+  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(String(error2.message || 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() + 5e3;
+    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, 100));
     }
-    return `Memoir UI failed to start: ${lastError || 'no launcher succeeded'}`;
+    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"}`;
 }
-export function coercePaths(path) {
-    if (!path)
-        return [];
-    return Array.isArray(path) ? path.filter(Boolean) : [path];
+function coercePaths(path) {
+  if (!path) return [];
+  return Array.isArray(path) ? path.filter(Boolean) : [path];
 }
 function pushText(output, text) {
-    output.parts.length = 0;
-    output.parts.push({ type: 'text', text });
+  output.parts.length = 0;
+  output.parts.push({ type: "text", text });
 }
-/** Format JSON string with 2-space indentation. Passes non-JSON through unchanged. */
-export function tryPrettyJson(text) {
-    try {
-        return JSON.stringify(JSON.parse(text), null, 2);
-    }
-    catch {
-        return text;
-    }
+function tryPrettyJson(text) {
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return text;
+  }
 }
-/** Cached session init context (taxonomy overview). Fetched once, injected per-session. */
-let initContext = null;
-let initContextFetched = false;
-/**
- * Tracks sessions that have received initial context injection.
- * Uses a Map with timestamp so stale entries can be evicted.
- * Cleaned on dispose. Sessions older than 1 hour are considered stale.
- */
-const SESSION_CONTEXT_TTL_MS = 60 * 60 * 1000;
-const sessionsWithContext = new Map();
-/** Check if a session has received context (and prune stale entries opportunistically). */
+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 === undefined)
-        return false;
-    if (Date.now() - ts > SESSION_CONTEXT_TTL_MS) {
-        sessionsWithContext.delete(sessionID);
-        return false;
-    }
-    return true;
+  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;
 }
-/** Mark a session as having received context. */
 function markSessionContext(sessionID) {
-    sessionsWithContext.set(sessionID, Date.now());
+  sessionsWithContext.set(sessionID, Date.now());
 }
-/** Prune all stale session entries. */
 function pruneStaleSessions() {
-    const now = Date.now();
-    for (const [id, ts] of sessionsWithContext) {
-        if (now - ts > SESSION_CONTEXT_TTL_MS)
-            sessionsWithContext.delete(id);
-    }
+  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.\n\nUSER REQUEST:\n$ARGUMENTS\n\nExtract 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.\n\nUSER REQUEST:\n$ARGUMENTS\n\nUse 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.\n\nUSER REQUEST:\n$ARGUMENTS\n\nWorkflow:\n- Stay inside the current project/worktree. Do not inspect parent directories.\n- First obtain a project file tree to understand structure.\n- Start studying from project documentation.\n- Continue only based on what the tree and documentation show.\n\nMemory rules:\n- Record only verified facts from files/docs/code or explicit user statements.\n- Do not write inferred user thoughts, intentions, preferences, or opinions.\n- Do not use preferences.* paths unless the user explicitly stated a preference.\n- If a fact is your interpretation, do not save it; report it as uncertain instead.\n\nThen 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.',
-    };
+  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."
+  };
 }
-const memoirStatus = tool({
-    description: 'Show Memoir status for the current OpenCode project store.',
-    args: {},
-    execute: async () => statusJson(deriveStorePath()),
+var memoirStatus = tool({
+  description: "Show Memoir status for the current OpenCode project store.",
+  args: {},
+  execute: async () => statusJson(deriveStorePath())
 });
-const 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.'),
+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();
+    try {
+      await ensureStore(store);
+    } catch (error) {
+      return String(error.message || error);
+    }
+    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");
+    return tryPrettyJson(await runMemoir(cliArgs, { cwd: store }));
+  }
+});
+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();
+    try {
+      await ensureStore(store);
+    } catch (error) {
+      return String(error.message || error);
+    }
+    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 }));
+      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 MEMOIR_GET_MAX_KEYS = 20;
+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();
+    try {
+      await ensureStore(store);
+    } catch (error) {
+      return String(error.message || error);
+    }
+    return tryPrettyJson(await runMemoir(["--json", "-s", store, "get", ...keys, "-n", args.namespace ?? "default"], { cwd: store }));
+  }
+});
+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
     },
-    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.';
+    config: async (opencodeConfig) => {
+      registerCommands(opencodeConfig);
+    },
+    "command.execute.before": async (input, output) => {
+      try {
+        if (input.command === "memoir:status") {
+          pushText(output, await statusJson(deriveStorePath()));
         }
-        const store = deriveStorePath();
-        try {
-            await ensureStore(store);
+        if (input.command === "memoir:ui") {
+          pushText(output, await launchUi(deriveStorePath()));
         }
-        catch (error) {
-            return String(error.message || error);
+        if (input.command === "memoir:unmerged") {
+          const store = deriveStorePath();
+          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 }).catch(() => "");
+            if (diffOut.trim()) {
+              unmerged.push(branch);
+            }
+          }
+          pushText(
+            output,
+            unmerged.length > 0 ? `Unmerged branches:
+${unmerged.join("\n")}` : "All branches are merged into main."
+          );
         }
-        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');
-        return tryPrettyJson(await runMemoir(cliArgs, { cwd: store }));
+      } catch (error) {
+        pushText(output, `Memoir command failed: ${String(error.message || error)}`);
+      }
     },
-});
-const 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.'),
+    /**
+     * Inject MEMOIR_STORE into every shell command's environment so any memoir
+     * invocation automatically targets the right store without manual -s flags.
+     * Uses the cached value resolved at init time (avoiding execFileSync overhead
+     * on every shell command).
+     */
+    "shell.env": async (_input2, output) => {
+      try {
+        output.env.MEMOIR_STORE = storeRoot;
+      } catch (e) {
+        debugLog("shell.env: failed:", e instanceof Error ? e.message : String(e));
+      }
     },
-    execute: async (args) => {
-        const store = deriveStorePath();
-        try {
-            await ensureStore(store);
+    /**
+     * Observe every tool execution for metrics and code-change tracking.
+     * Mirrors the observation phase of Claude Code's Stop hook.
+     * Never modifies the tool output.
+     */
+    "tool.execute.after": async (input, output) => {
+      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 (error) {
-            return String(error.message || error);
+      } catch (e) {
+        debugLog("tool.execute.after: failed:", e instanceof Error ? e.message : String(e));
+      }
+    },
+    /**
+     * Fires on every incoming user message.
+     *
+     * 1. Auto-match memoir branch to current git branch
+     *    (cf. UserPromptSubmit's auto_match_memoir_branch in Claude Code plugin).
+     * 2. Flush pending edits from the previous assistant turn
+     *    (cf. Stop hook code change audit, run after each turn).
+     * 3. Run the recall gate (cf. UserPromptSubmit).
+     *
+     * Steps 1–2 are skipped when MEMOIR_NO_CAPTURE=1.
+     */
+    "chat.message": async (input, output) => {
+      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 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 }));
-            sections.push(`## namespace: ${namespace}\n${output}`);
+        const prevBranch = getCachedBranch(sid) === "unknown" ? void 0 : getCachedBranch(sid);
+        setCachedBranch(sid, await autoMatchMemoirBranch(storeRoot));
+        if (process.env.MEMOIR_NO_CAPTURE !== "1") {
+          await flushCapture(storeRoot, prevBranch, sid);
         }
-        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}\n` : '';
-        return `${query}${note}\nPick at most 5-7 relevant exact keys across namespaces, then call memoir_get with the matching namespace if values are needed.\n${sections.join('\n\n')}`;
+      } catch (e) {
+        debugLog("chat.message: failed:", e instanceof Error ? e.message : String(e));
+      }
     },
-});
-/** Max keys memoir_get accepts to avoid hitting OS arg-length limits. */
-export const MEMOIR_GET_MAX_KEYS = 20;
-const 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.'),
+    /**
+     * 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:", e instanceof Error ? e.message : String(e));
+            initContextFetched = false;
+          }
+        })();
+      }
     },
-    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.`;
+    /**
+     * Fires before every LLM call.
+     *
+     * 1. Injects the memoir taxonomy context for this session (once per session).
+     * 2. If a recall is pending for this session, injects a brief instruction
+     *    telling the model to use memoir tools (one-shot per trigger).
+     */
+    "experimental.chat.system.transform": async (input, output) => {
+      try {
+        if (input.sessionID && !hasSessionContext(input.sessionID)) {
+          markSessionContext(input.sessionID);
+          if (initContext) {
+            output.system.unshift(initContext);
+          }
         }
-        const store = deriveStorePath();
-        try {
-            await ensureStore(store);
+        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 (error) {
-            return String(error.message || error);
-        }
-        return tryPrettyJson(await runMemoir(['--json', '-s', store, 'get', ...keys, '-n', args.namespace ?? 'default'], { cwd: store }));
+      } catch (e) {
+        debugLog("system.transform: failed:", e instanceof Error ? e.message : String(e));
+      }
     },
-});
-const MemoirOpenCode = async (_input, rawOptions) => {
-    const opts = (rawOptions ?? {});
-    if (opts.store)
-        setPluginStoreOverride(opts.store);
-    // Resolve store path once at init so shell.env doesn't call execFileSync
-    // on every shell command (mirrors Claude Code's MEMOIR_STORE_PATH caching).
-    const storeRoot = deriveStorePath();
-    return ({
-        name: 'memoir',
-        tool: {
-            memoir_status: memoirStatus,
-            memoir_remember: memoirRemember,
-            memoir_recall: memoirRecall,
-            memoir_get: memoirGet,
-        },
-        config: async (opencodeConfig) => {
-            registerCommands(opencodeConfig);
-        },
-        'command.execute.before': async (input, output) => {
-            try {
-                if (input.command === 'memoir:status') {
-                    pushText(output, await statusJson(deriveStorePath()));
-                }
-                if (input.command === 'memoir:ui') {
-                    pushText(output, await launchUi(deriveStorePath()));
-                }
-                if (input.command === 'memoir:unmerged') {
-                    const store = deriveStorePath();
-                    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 }).catch(() => '');
-                        if (diffOut.trim()) {
-                            unmerged.push(branch);
-                        }
-                    }
-                    pushText(output, unmerged.length > 0
-                        ? `Unmerged branches:\n${unmerged.join('\n')}`
-                        : 'All branches are merged into main.');
-                }
-            }
-            catch (error) {
-                pushText(output, `Memoir command failed: ${String(error.message || error)}`);
-            }
-        },
-        /**
-         * Inject MEMOIR_STORE into every shell command's environment so any memoir
-         * invocation automatically targets the right store without manual -s flags.
-         * Uses the cached value resolved at init time (avoiding execFileSync overhead
-         * on every shell command).
-         */
-        'shell.env': async (_input, output) => {
-            try {
-                output.env.MEMOIR_STORE = storeRoot;
-            }
-            catch (e) {
-                debugLog('shell.env: failed:', e instanceof Error ? e.message : String(e));
-            }
-        },
-        /**
-         * Observe every tool execution for metrics and code-change tracking.
-         * Mirrors the observation phase of Claude Code's Stop hook.
-         * Never modifies the tool output.
-         */
-        'tool.execute.after': async (input, output) => {
-            try {
-                // Per-session state key
-                const sid = input.sessionID ?? 'default';
-                // Accumulate per-tool metrics (cf. collect-metrics.sh).
-                // Skipped when MEMOIR_NO_CAPTURE or MEMOIR_NO_METRICS is set.
-                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 });
-                }
-                // Track file edits (cf. collect-edits.sh).
-                // Skipped when MEMOIR_NO_CAPTURE or MEMOIR_NO_CODE_SUMMARY is set.
-                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:', e instanceof Error ? e.message : String(e));
-            }
-        },
-        /**
-         * Fires on every incoming user message.
-         *
-         * 1. Auto-match memoir branch to current git branch
-         *    (cf. UserPromptSubmit's auto_match_memoir_branch in Claude Code plugin).
-         * 2. Flush pending edits from the previous assistant turn
-         *    (cf. Stop hook code change audit, run after each turn).
-         * 3. Run the recall gate (cf. UserPromptSubmit).
-         *
-         * Steps 1–2 are skipped when MEMOIR_NO_CAPTURE=1.
-         */
-        'chat.message': async (input, output) => {
-            try {
-                const sid = input.sessionID ?? 'default';
-                // C4: run recall gate BEFORE any await — otherwise system.transform
-                // could fire before pendingRecall is set.
-                const text = output.parts
-                    .filter((p) => p.type === 'text')
-                    .map(p => p.text)
-                    .join(' ');
-                if (shouldTriggerRecall(text)) {
-                    pendingRecall.add(sid);
-                }
-                // Snapshot previous branch BEFORE switching — edits from the last turn
-                // belong to the OLD branch. (C2 fix: prevents misattribution when the
-                // user switches git branch between turns.)
-                const prevBranch = getCachedBranch(sid) === 'unknown' ? undefined : getCachedBranch(sid);
-                setCachedBranch(sid, await autoMatchMemoirBranch(storeRoot));
-                // Skip capture flush when MEMOIR_NO_CAPTURE is set.
-                // Flush under the PREVIOUS branch (the one edits were made on).
-                if (process.env.MEMOIR_NO_CAPTURE !== '1') {
-                    await flushCapture(storeRoot, prevBranch, sid);
-                }
-            }
-            catch (e) {
-                debugLog('chat.message: failed:', e instanceof Error ? e.message : String(e));
-            }
-        },
-        /**
-         * Fires on SDK events. On session.created, kick off a background fetch of
-         * the taxonomy overview so it's ready before the first LLM call.
-         * Mirrors Claude Code's SessionStart context injection.
-         */
-        event: async ({ 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:\n${pretty}`;
-                    }
-                    catch (e) {
-                        debugLog('event: taxonomy fetch failed, will retry on next session:', e instanceof Error ? e.message : String(e));
-                        // Allow a later session to retry — the store may not have been ready yet.
-                        initContextFetched = false;
-                    }
-                })();
-            }
-        },
-        /**
-         * Fires before every LLM call.
-         *
-         * 1. Injects the memoir taxonomy context for this session (once per session).
-         * 2. If a recall is pending for this session, injects a brief instruction
-         *    telling the model to use memoir tools (one-shot per trigger).
-         */
-        'experimental.chat.system.transform': async (input, output) => {
-            try {
-                // Inject initial context on the first LLM call of each session
-                if (input.sessionID && !hasSessionContext(input.sessionID)) {
-                    markSessionContext(input.sessionID);
-                    if (initContext) {
-                        output.system.unshift(initContext);
-                    }
-                }
-                // Inject recall instruction (one-shot per trigger)
-                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:', e instanceof Error ? e.message : String(e));
-            }
-        },
-        /**
-         * Fires when the plugin is shut down. Flushes any remaining code changes
-         * and metrics (cf. SessionEnd heartbeat cleanup + final metrics flush).
-         */
-        dispose: async () => {
-            // No sessionID → flushCapture flushes ALL sessions
-            await flushCapture(storeRoot);
-            pruneStaleSessions();
-            sessionsWithContext.clear();
-        },
-    });
+    /**
+     * Fires when the plugin is shut down. Flushes any remaining code changes
+     * and metrics (cf. SessionEnd heartbeat cleanup + final metrics flush).
+     */
+    dispose: async () => {
+      await flushCapture(storeRoot);
+      pruneStaleSessions();
+      sessionsWithContext.clear();
+    }
+  };
+};
+var index_default = MemoirOpenCode;
+export {
+  MEMOIR_GET_MAX_KEYS,
+  coercePaths,
+  index_default as default,
+  tryPrettyJson
 };
-export default MemoirOpenCode;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map