opencode-memoir 2.1.0 → 3.0.0

package/dist/index.js

@@ -1,215 +1,866 @@
 // 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(" ")}
-`);
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function resolveLogFile() {
+  const raw = process.env.MEMOIR_LOG;
+  if (raw === "stderr") return null;
+  if (raw) return raw;
+  const stateHome = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state");
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join(stateHome, "opencode", `memoir-plugin-${date}.log`);
+}
+function formatValue(value) {
+  if (value instanceof Error) {
+    if (process.env.MEMOIR_DEBUG === "1") {
+      return value.stack ?? `${value.name}: ${value.message}`;
+    }
+    return value.message;
+  }
+  return String(value);
+}
+function formatArgs(args) {
+  const [message, ...details] = args;
+  if (typeof message === "string" && details[0] instanceof Error) {
+    return `${message.replace(/:\s*$/, "")}: ${details.map(formatValue).join(" ")}`;
+  }
+  return args.map(formatValue).join(" ");
+}
+function writeLog(args) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", "");
+  const line = `[memoir ${ts}] ${formatArgs(args)}
+`;
+  const logFilePath = resolveLogFile();
+  if (logFilePath) {
+    try {
+      mkdirSync(dirname(logFilePath), { recursive: true });
+      appendFileSync(logFilePath, line);
+      return;
+    } catch {
+    }
+  }
+  process.stderr.write(line);
+}
+function log(...args) {
+  writeLog(args);
 }
 
-// src/memory-saver.ts
-var sessionMsgCount = /* @__PURE__ */ new Map();
-var REMINDER_INTERVAL = Math.max(0, parseInt(process.env.MEMOIR_REMINDER_INTERVAL ?? "5", 10));
-function incrementMsgCount(sessionID) {
-  const count = (sessionMsgCount.get(sessionID) ?? 0) + 1;
-  sessionMsgCount.set(sessionID, count);
-  return count;
+// src/prompts.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var cache = /* @__PURE__ */ new Map();
+function loadPrompt(file) {
+  const cached = cache.get(file);
+  if (cached !== void 0) return cached;
+  const path = fileURLToPath(new URL(`./prompts/${file}`, import.meta.url));
+  const text = readFileSync(path, "utf8");
+  cache.set(file, text);
+  return text;
 }
-function shouldRemind(count) {
-  return REMINDER_INTERVAL > 0 && count > 1 && count % REMINDER_INTERVAL === 0;
+
+// src/subagent.ts
+var MEMOIR_AGENT_NAME = "memoir";
+var MEMOIR_CHECKOUT_TOOL = "memoir_memoir_checkout";
+var MEMOIR_AGENT_PROMPT = loadPrompt("subagent-system.tmpl");
+function buildMemoirAgent(model) {
+  const agent = {
+    mode: "subagent",
+    description: "Memoir memory agent \u2014 captures durable facts and recalls prior context via the memoir MCP server.",
+    prompt: MEMOIR_AGENT_PROMPT,
+    permission: {
+      "*": "deny",
+      doom_loop: "allow",
+      "memoir_*": "allow",
+      [MEMOIR_CHECKOUT_TOOL]: "deny"
+    },
+    temperature: 0,
+    steps: 8
+  };
+  if (model) agent.model = model;
+  return agent;
+}
+function resolveMemoirModel(opts) {
+  const candidates = [
+    process.env.MEMOIR_AGENT_MODEL?.trim(),
+    opts.summarizeModel,
+    opts.smallModel,
+    opts.model
+  ];
+  return candidates.find((candidate) => candidate?.includes("/"));
 }
-function pruneAll() {
-  sessionMsgCount.clear();
+async function runMemoirSubagent(client, parentSessionID, task) {
+  const api = client?.session;
+  if (!api?.promptAsync) {
+    throw new Error("client.session.promptAsync unavailable");
+  }
+  try {
+    await api.promptAsync({
+      path: { id: parentSessionID },
+      body: {
+        parts: [
+          {
+            type: "subtask",
+            agent: MEMOIR_AGENT_NAME,
+            description: "memoir capture",
+            prompt: task,
+            command: ""
+          }
+        ]
+      }
+    });
+    log("memoir subtask accepted (session", parentSessionID, ", task", task.length, "chars)");
+  } catch (e) {
+    log("runMemoirSubagent failed", e);
+    throw e;
+  }
 }
 
-// src/store.ts
-import { execFile, execFileSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-function errorMessage(e) {
-  return e instanceof Error ? e.message : String(e);
+// src/capture.ts
+var DEFAULT_CAPTURE_MIN_CHARS = 16;
+function captureMinChars() {
+  const raw = process.env.MEMOIR_CAPTURE_MIN_CHARS?.trim();
+  if (raw === void 0 || raw === "") return DEFAULT_CAPTURE_MIN_CHARS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) ? n : DEFAULT_CAPTURE_MIN_CHARS;
+}
+function autoSaveEnabled() {
+  return process.env.MEMOIR_AUTO_SAVE !== "0";
+}
+function messageText(msg) {
+  const parts = msg.parts ?? [];
+  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n").trim();
+}
+function formatRole(role) {
+  switch (role) {
+    case "user":
+      return "USER";
+    case "assistant":
+      return "ASSISTANT";
+    case "system":
+      return "SYSTEM";
+    default:
+      return (role ?? "unknown").toUpperCase();
+  }
+}
+function formatSessionTranscript(messages) {
+  return messages.map((m) => {
+    const text = messageText(m);
+    if (!text) return null;
+    return `${formatRole(m.info?.role)}
+${text}`;
+  }).filter((line) => line !== null).join("\n\n");
+}
+function lastTurnTranscript(messages) {
+  let assistantIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].info?.role === "assistant" && messageText(messages[i])) {
+      assistantIdx = i;
+      break;
+    }
+  }
+  if (assistantIdx < 0) return null;
+  const userIdx = (() => {
+    for (let i = assistantIdx - 1; i >= 0; i--) {
+      if (messages[i].info?.role === "user") return i;
+    }
+    return -1;
+  })();
+  if (userIdx < 0) return null;
+  const turn = messages.slice(userIdx, assistantIdx + 1);
+  return formatSessionTranscript(turn);
+}
+function shouldCaptureTurn(transcript, minChars = captureMinChars()) {
+  if (minChars <= 0) return transcript !== null && transcript.length > 0;
+  return transcript !== null && transcript.length >= minChars;
+}
+var CAPTURE_TASK_TEMPLATE = loadPrompt("capture-task.tmpl");
+function buildTurnCaptureTask(transcript, tools = []) {
+  const captureTools = tools.filter((tool) => tool.name !== MEMOIR_CHECKOUT_TOOL);
+  const toolsSection = captureTools.length ? `Available memory tools (name \u2014 what it does):
+${captureTools.map((tool) => `- ${tool.name} \u2014 ${tool.description}`).join("\n")}
+` : "";
+  return CAPTURE_TASK_TEMPLATE.replace("{{TOOLS_SECTION}}", toolsSection).replace(
+    "{{TRANSCRIPT}}",
+    transcript
+  );
+}
+function lastAssistantMessageId(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].info?.role === "assistant" && messageText(messages[i])) {
+      return messages[i].info?.id ?? null;
+    }
+  }
+  return null;
+}
+async function captureTurn(client, sessionID, _directory, lastCaptured, tools = []) {
+  if (!autoSaveEnabled()) {
+    log("captureTurn: MEMOIR_AUTO_SAVE=0, skipping");
+    return;
+  }
+  log("captureTurn: started for session", sessionID);
+  try {
+    const api = client?.session;
+    if (!api?.messages) {
+      log("captureTurn: client.session.messages unavailable");
+      log("captureTurn: skipped \u2014 session messages API unavailable");
+      return;
+    }
+    const res = await api.messages({
+      path: { id: sessionID },
+      query: { limit: 50 }
+    });
+    const raw = res.data;
+    const messages = Array.isArray(raw) ? raw : [];
+    if (messages.length === 0) return;
+    const turnId = lastAssistantMessageId(messages);
+    if (!turnId) return;
+    if (lastCaptured.get(sessionID) === turnId) {
+      log("captureTurn: skipped \u2014 already captured this turn");
+      return;
+    }
+    const transcript = lastTurnTranscript(messages);
+    if (!shouldCaptureTurn(transcript)) {
+      log("captureTurn: transcript below min-chars, skipping");
+      log("captureTurn: skipped \u2014 transcript below min-chars");
+      lastCaptured.set(sessionID, turnId);
+      return;
+    }
+    if (transcript === null) return;
+    log("captureTurn: submitting memoir subtask (transcript", transcript.length, "chars)");
+    await runMemoirSubagent(client, sessionID, buildTurnCaptureTask(transcript, tools));
+    lastCaptured.set(sessionID, turnId);
+  } catch (e) {
+    log("captureTurn failed", e);
+  }
 }
-function deriveStorePath(cwd = process.cwd()) {
-  if (pluginStoreOverride) return pluginStoreOverride;
+
+// src/capture-lifecycle.ts
+var CaptureLifecycle = class {
+  active = /* @__PURE__ */ new Map();
+  callsByChild = /* @__PURE__ */ new Map();
+  begin(callID) {
+    if (this.active.has(callID)) return;
+    let resolve2;
+    const done = new Promise((doneResolve) => {
+      resolve2 = doneResolve;
+    });
+    this.active.set(callID, { done, resolve: resolve2 });
+  }
+  background(callID, childSessionID) {
+    const capture = this.active.get(callID);
+    if (!capture) return;
+    capture.childSessionID = childSessionID;
+    this.callsByChild.set(childSessionID, callID);
+  }
+  finishCall(callID) {
+    const capture = this.active.get(callID);
+    if (!capture) return;
+    if (capture.childSessionID) this.callsByChild.delete(capture.childSessionID);
+    this.active.delete(callID);
+    capture.resolve();
+  }
+  finishSession(sessionID) {
+    const callID = this.callsByChild.get(sessionID);
+    if (callID) this.finishCall(callID);
+  }
+  async drain(timeoutMs = 1e4) {
+    const pending = [...this.active.values()].map((capture) => capture.done);
+    if (pending.length === 0) return true;
+    let timer;
+    const timedOut = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(false), timeoutMs);
+    });
+    const drained = Promise.all(pending).then(() => true);
+    const result = await Promise.race([drained, timedOut]);
+    if (timer) clearTimeout(timer);
+    if (!result) log("capture lifecycle: drain timed out; branch switch deferred");
+    return result;
+  }
+  clear() {
+    for (const callID of [...this.active.keys()]) this.finishCall(callID);
+  }
+};
+
+// src/mcp-client.ts
+import { spawn } from "node:child_process";
+import { createConnection, createServer } from "node:net";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/path.ts
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2, resolve } from "node:path";
+function safeRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function slugify(p) {
+  return p.replace(/[/.]/g, "-");
+}
+function deriveStorePath(cwd = process.cwd(), override) {
+  if (override) return override;
   const envStore = process.env.MEMOIR_STORE;
   if (envStore) return envStore;
+  const realCwd = safeRealpath(cwd);
   let projectDir;
   try {
     const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd,
+      cwd: realCwd,
       encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 3e3
     }).trim();
-    projectDir = gitRoot;
+    projectDir = safeRealpath(gitRoot);
   } catch {
-    projectDir = resolve(cwd);
+    projectDir = resolve(realCwd);
+  }
+  return join2(homedir2(), ".memoir", slugify(projectDir));
+}
+
+// src/mcp-client.ts
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var LOW_PORT = 49152;
+var HIGH_PORT = 65535;
+function randomHighPort() {
+  return LOW_PORT + Math.floor(Math.random() * (HIGH_PORT - LOW_PORT + 1));
+}
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const srv = createServer();
+    srv.once("error", () => resolve2(false));
+    srv.once("listening", () => srv.close(() => resolve2(true)));
+    srv.listen(port, "127.0.0.1");
+  });
+}
+async function pickFreeHighPort(tries = 20) {
+  for (let i = 0; i < tries; i++) {
+    const port = randomHighPort();
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error("memoir: could not find a free high port for the HTTP server");
+}
+function waitForPort(port, timeoutMs = 1e4) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve2, reject) => {
+    const attempt = () => {
+      const sock = createConnection({ port, host: "127.0.0.1" });
+      sock.once("connect", () => {
+        sock.destroy();
+        resolve2();
+      });
+      sock.once("error", () => {
+        sock.destroy();
+        if (Date.now() > deadline) {
+          reject(new Error("memoir: HTTP server did not start in time"));
+        } else {
+          setTimeout(attempt, 100);
+        }
+      });
+    };
+    attempt();
+  });
+}
+var MemoirRuntime = class {
+  constructor(command, env, cwd, dependencies = {}) {
+    this.command = command;
+    this.env = env;
+    this.cwd = cwd;
+    this.dependencies = dependencies;
+  }
+  command;
+  env;
+  cwd;
+  dependencies;
+  state = null;
+  connecting = null;
+  serverProc = null;
+  serverUrl = null;
+  serverPort = null;
+  startingServer = null;
+  tools = null;
+  cleanupClient() {
+    this.state = null;
+    this.connecting = null;
+    this.tools = null;
+  }
+  async start() {
+    if (this.serverUrl && this.serverProc) return this.serverUrl;
+    if (this.startingServer) return this.startingServer;
+    const start = (async () => {
+      if (process.env.NODE_ENV === "test") {
+        return new URL("http://127.0.0.1:9/mcp");
+      }
+      const port = this.serverPort ?? await pickFreeHighPort();
+      this.serverPort = port;
+      const url = new URL(`http://127.0.0.1:${port}/mcp`);
+      const args = [
+        ...this.command.slice(1),
+        "--http",
+        "--host",
+        "127.0.0.1",
+        "--port",
+        String(port)
+      ];
+      const proc = spawn(this.command[0], args, {
+        // Merge with the parent env so PATH (and other essentials) survive —
+        // passing only `env` would wipe PATH and break command resolution.
+        env: { ...process.env, ...this.env },
+        // Run in the real (symlink-resolved) project dir so memoir-mcp's
+        // portable store slug is identical whether the repo is entered via a
+        // symlink or its real path.
+        cwd: this.cwd ? safeRealpath(this.cwd) : process.cwd(),
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+      this.serverProc = proc;
+      if (proc.stderr) {
+        proc.stderr.on("data", (chunk) => {
+          log("memoir-mcp:", chunk.toString().trimEnd());
+        });
+      }
+      proc.on("exit", (code) => {
+        log("memoir-mcp HTTP server exited with code", code);
+        if (this.serverProc !== proc) return;
+        this.serverProc = null;
+        this.serverUrl = null;
+        this.startingServer = null;
+        this.cleanupClient();
+      });
+      await new Promise((resolve2, reject) => {
+        proc.once("spawn", resolve2);
+        proc.once("error", reject);
+      }).catch((e) => {
+        throw new Error(`memoir: failed to spawn ${this.command[0]}: ${errorMessage(e)}`);
+      });
+      await waitForPort(port);
+      this.serverUrl = url;
+      log("memoir-mcp HTTP server up at", url.toString());
+      return url;
+    })();
+    this.startingServer = start;
+    try {
+      return await start;
+    } catch (e) {
+      this.startingServer = null;
+      this.serverUrl = null;
+      if (this.serverProc) this.serverProc.kill();
+      this.serverProc = null;
+      throw e;
+    }
+  }
+  /** Get the lazily-connected internal client for this plugin instance. */
+  async connect() {
+    if (this.state) return this.state.client;
+    if (!this.connecting) {
+      this.connecting = (async () => {
+        const url = await this.start();
+        const { client, transport } = this.dependencies.createClientConnection?.(url) ?? {
+          client: new Client({ name: "opencode-memoir", version: "1.0.0" }, { capabilities: {} }),
+          transport: new StreamableHTTPClientTransport(url)
+        };
+        transport.onclose = () => {
+          log("mcp-client: transport closed, resetting state");
+          this.cleanupClient();
+        };
+        try {
+          await client.connect(transport);
+        } catch (e) {
+          this.cleanupClient();
+          throw e;
+        }
+        this.state = { client };
+        return client;
+      })();
+    }
+    return this.connecting;
+  }
+  /** Discover the live tool catalog once per connection for the small-model prompt. */
+  async listTools(client) {
+    if (this.tools) return this.tools;
+    try {
+      const result = await client.listTools();
+      this.tools = (result.tools ?? []).map((tool) => ({
+        // OpenCode exposes remote MCP tools as <server>_<raw-name>. The server
+        // is registered as "memoir", so the prompt must use the same names the
+        // subagent actually sees (for example memoir_memoir_remember).
+        name: `memoir_${tool.name}`,
+        description: typeof tool.description === "string" ? tool.description : ""
+      }));
+      return this.tools;
+    } catch (e) {
+      log("MemoirRuntime.listTools failed", e);
+      return [];
+    }
+  }
+  /** Close the MCP client and stop this instance's HTTP server. */
+  async close() {
+    if (this.state) {
+      try {
+        await this.state.client.close();
+      } catch (e) {
+        log("closeMemoirClient: close failed", e);
+      }
+      this.cleanupClient();
+    }
+    if (this.serverProc) {
+      const proc = this.serverProc;
+      this.serverProc = null;
+      try {
+        await new Promise((resolve2) => {
+          if (proc.exitCode !== null) {
+            resolve2();
+            return;
+          }
+          const timer = setTimeout(resolve2, 1e3);
+          timer.unref();
+          proc.once("exit", () => {
+            clearTimeout(timer);
+            resolve2();
+          });
+          proc.once("error", () => {
+            clearTimeout(timer);
+            resolve2();
+          });
+          proc.kill();
+        });
+      } catch (e) {
+        log("closeMemoirClient: kill failed", e);
+      }
+    }
+    this.serverUrl = null;
+    this.startingServer = null;
+    this.connecting = null;
+    this.tools = null;
+  }
+};
+async function callMemoirTool(client, name, args) {
+  try {
+    const result = await client.callTool({
+      name,
+      arguments: args
+    });
+    if (result.isError) {
+      log(`callMemoirTool: ${name} returned error`);
+      return null;
+    }
+    for (const block of result.content) {
+      if (block.type === "text" && block.text != null) {
+        return block.text;
+      }
+    }
+    return null;
+  } catch (e) {
+    log(`callMemoirTool: ${name} failed`, e);
+    return null;
   }
-  const slug = projectDir.replace(/[/.]/g, "-");
-  return join(homedir(), ".memoir", slug);
 }
-var pluginStoreOverride;
-function setPluginStoreOverride(store) {
-  pluginStoreOverride = store;
+
+// src/store.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+function deriveStorePath2(cwd, override) {
+  return deriveStorePath(cwd, override);
 }
 function currentGitBranch(cwd = process.cwd()) {
   try {
-    return execFileSync("git", ["branch", "--show-current"], {
-      cwd,
+    return execFileSync2("git", ["branch", "--show-current"], {
+      cwd: safeRealpath(cwd),
       encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 3e3
     }).trim();
   } catch {
     return "";
   }
 }
-var branchCache = /* @__PURE__ */ new Map();
-function getCachedBranch(sessionID) {
-  return branchCache.get(sessionID) ?? "";
-}
-function setCachedBranch(sessionID, branch) {
-  branchCache.set(sessionID, branch);
-}
-async function callMemoir(args, store) {
-  try {
-    const { stdout } = await execFileAsync("memoir", ["--store", store, ...args], {
-      encoding: "utf8",
-      timeout: 15e3,
-      maxBuffer: 1024 * 1024
+var MemoirBranchMatcher = class {
+  matching = Promise.resolve();
+  match(client, cwd, drain) {
+    const next = this.matching.then(() => this.matchNow(client, cwd, drain));
+    this.matching = next.catch(() => void 0);
+    return next;
+  }
+  async currentBranch(client) {
+    const raw = await callMemoirTool(client, "memoir_status");
+    if (!raw) return "";
+    try {
+      const status = JSON.parse(raw);
+      return typeof status.branch === "string" ? status.branch : "";
+    } catch {
+      return "";
+    }
+  }
+  async matchNow(client, cwd, drain) {
+    const codeBranch = currentGitBranch(cwd);
+    if (!codeBranch) return;
+    if (await this.currentBranch(client) === codeBranch) return;
+    if (drain && !await drain()) return;
+    if (await this.currentBranch(client) === codeBranch) return;
+    await callMemoirTool(client, "memoir_checkout", {
+      target: codeBranch,
+      create: true
     });
-    return stdout.trim();
-  } catch (e) {
-    debugLog("callMemoir failed:", errorMessage(e));
-    return null;
   }
-}
-async function autoMatchMemoirBranch(store, sessionID) {
-  const codeBranch = currentGitBranch();
-  if (!codeBranch) return;
-  const cached = getCachedBranch(sessionID);
-  if (cached === codeBranch) return;
-  const branchResult = await callMemoir(["--json", "branch"], store);
-  if (branchResult === null) return;
+  clear() {
+    this.matching = Promise.resolve();
+  }
+};
+
+// src/turn-status.ts
+function buildTurnStatus(statusRaw) {
+  let branch = "";
+  let memoryCount = 0;
   try {
-    const data = JSON.parse(branchResult);
-    const branches = data?.branches ?? [];
-    if (!branches.includes(codeBranch)) {
-      await callMemoir(["branch", codeBranch], store);
-    }
-    await callMemoir(["checkout", codeBranch], store);
-    setCachedBranch(sessionID, codeBranch);
-  } catch (e) {
-    debugLog("autoMatchMemoirBranch: parsing failed:", errorMessage(e));
+    const status = JSON.parse(statusRaw ?? "");
+    if (typeof status.branch === "string") branch = status.branch;
+    if (typeof status.memory_count === "number") memoryCount = status.memory_count;
+  } catch {
+    return "";
   }
-}
-function pruneBranchCache() {
-  branchCache.clear();
+  if (!branch && memoryCount <= 0) return "";
+  if (!branch) return `[memoir] memory available (${memoryCount} memories)`;
+  return `[memoir] ${branch}${memoryCount > 0 ? ` \xB7 memory available (${memoryCount} memories)` : ""}`;
 }
 
 // src/index.ts
-var sessionsWithStartupHint = /* @__PURE__ */ new Set();
-function errorMessage2(e) {
-  return e instanceof Error ? e.message : String(e);
+function envFlag(name) {
+  const value = process.env[name]?.trim().toLowerCase();
+  if (value === void 0 || value === "") return void 0;
+  return value === "1" || value === "true";
+}
+function backgroundSubagentsEnabled() {
+  return envFlag("OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS") ?? envFlag("OPENCODE_EXPERIMENTAL") ?? false;
 }
-var MemoirOpenCode = async (_input, rawOptions) => {
+var MemoirOpenCode = async (input, rawOptions) => {
   const opts = rawOptions ?? {};
-  if (opts.store) setPluginStoreOverride(opts.store);
-  const storePath = deriveStorePath();
+  const pluginInput = input ?? {};
+  const sdkClient = pluginInput.client;
+  const directory = safeRealpath(pluginInput.directory ?? process.cwd());
+  const storePath = deriveStorePath2(directory, opts.store);
   const mcpCommand = ["memoir-mcp"];
   if (storePath) {
     mcpCommand.push("--store", storePath);
   }
+  const environment = storePath ? { MEMOIR_STORE: storePath } : void 0;
+  const runtime = new MemoirRuntime(mcpCommand, environment, directory);
+  const branchMatcher = new MemoirBranchMatcher();
+  const sessionsWithStartupHint = /* @__PURE__ */ new Set();
+  const parentSessions = /* @__PURE__ */ new Set();
+  const lastCaptured = /* @__PURE__ */ new Map();
+  const capturePending = /* @__PURE__ */ new Set();
+  const captureLifecycle = new CaptureLifecycle();
+  const messageCounts = /* @__PURE__ */ new Map();
+  const turnStatus = /* @__PURE__ */ new Map();
+  let mcpServer;
+  const connectClient = async () => {
+    if (process.env.NODE_ENV === "test") return null;
+    try {
+      return await runtime.connect();
+    } catch (e) {
+      log("plugin: failed to connect memoir client", e);
+      return null;
+    }
+  };
+  const discoverTools = async () => {
+    const client = await connectClient();
+    return client ? runtime.listTools(client) : [];
+  };
+  const dispatchCapture = async (sid) => {
+    if (!sdkClient || !parentSessions.has(sid) || capturePending.has(sid)) return;
+    capturePending.add(sid);
+    try {
+      const client = await connectClient();
+      if (client) await branchMatcher.match(client, directory, () => captureLifecycle.drain());
+      await captureTurn(sdkClient, sid, directory, lastCaptured, await discoverTools());
+    } catch (e) {
+      log("dispatchCapture failed", e);
+    } finally {
+      capturePending.delete(sid);
+    }
+  };
   const hooks = {
     name: "memoir",
     config: async (config) => {
-      debugLog("config hook: mcpCommand =", JSON.stringify(mcpCommand));
-      debugLog("config hook: mcpCommand length =", mcpCommand.length);
+      log("config hook: mcpCommand =", JSON.stringify(mcpCommand));
+      try {
+        const url = await runtime.start();
+        mcpServer = { type: "remote", url: url.toString(), enabled: true };
+        log("memoir MCP server registered at", url.toString(), "| store:", storePath);
+      } catch (e) {
+        log("config hook: failed to start memoir HTTP server", e);
+        mcpServer = void 0;
+      }
+      const mcp = config.mcp ?? {};
+      if (mcpServer) mcp.memoir = mcpServer;
+      config.mcp = mcp;
+      if (mcpServer) hooks.mcp = { memoir: mcpServer };
+      const agentModel = resolveMemoirModel({
+        summarizeModel: process.env.MEMOIR_AGENT_MODEL,
+        smallModel: config.small_model,
+        model: config.model
+      });
+      const agentField = config;
+      agentField.agent = {
+        ...agentField.agent ?? {},
+        [MEMOIR_AGENT_NAME]: buildMemoirAgent(agentModel)
+      };
+      log("memoir subagent registered | model:", agentModel ?? "(opencode default)");
+      log(
+        "memoir capture execution mode:",
+        backgroundSubagentsEnabled() ? "native background" : "foreground",
+        "| OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS:",
+        process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS ?? "(unset)",
+        "| OPENCODE_EXPERIMENTAL:",
+        process.env.OPENCODE_EXPERIMENTAL ?? "(unset)"
+      );
       config.command = config.command ?? {};
       config.command["memoir:onboard"] = {
         description: "Populate or refresh Memoir onboarding for this project",
-        template: `Populate or refresh Memoir onboarding for the current project.
-
-Workflow:
-- 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_memoir_remember with replace=true for durable onboarding facts. Use namespace codebase:onboard in git repositories and project:onboard outside git.`
+        template: loadPrompt("onboard.tmpl")
       };
-      const mcp = config.mcp ?? {};
-      mcp.memoir = {
-        type: "local",
-        command: mcpCommand,
-        environment: storePath ? { MEMOIR_STORE: storePath } : void 0,
-        enabled: true
-      };
-      config.mcp = mcp;
-      debugLog("config hook: registered mcp.memoir.command =", JSON.stringify(mcp.memoir?.command));
     },
-    "shell.env": async (_input2, output) => {
+    "shell.env": async (_input, output) => {
       try {
         if (storePath) {
           output.env.MEMOIR_STORE = storePath;
         }
       } catch (e) {
-        debugLog("shell.env: failed:", errorMessage2(e));
+        log("shell.env: failed", e);
       }
     },
-    "chat.message": async (input, _output) => {
+    "chat.message": async (input2, output) => {
       try {
-        const sid = input.sessionID ?? "default";
-        incrementMsgCount(sid);
-        await autoMatchMemoirBranch(storePath, sid);
+        const sid = input2.sessionID ?? "default";
+        const parts = output.parts ?? [];
+        const isMemoirSubtask = parts.some(
+          (part) => part.type === "subtask" && part.agent === MEMOIR_AGENT_NAME
+        );
+        const isSynthetic = parts.length > 0 && parts.every((part) => part.synthetic === true);
+        if (input2.agent === MEMOIR_AGENT_NAME || isMemoirSubtask || isSynthetic) return;
+        parentSessions.add(sid);
+        messageCounts.set(sid, (messageCounts.get(sid) ?? 0) + 1);
+        const client = await connectClient();
+        if (client) {
+          await branchMatcher.match(client, directory, () => captureLifecycle.drain());
+          const status = await callMemoirTool(client, "memoir_status", {});
+          const line = buildTurnStatus(status);
+          if (line) turnStatus.set(sid, line);
+          else turnStatus.delete(sid);
+        }
+        log("chat.message: submitting capture for previous completed turn", sid);
+        await dispatchCapture(sid);
       } catch (e) {
-        debugLog("chat.message: failed:", errorMessage2(e));
+        log("chat.message: failed", e);
       }
     },
-    "experimental.chat.system.transform": async (input, output) => {
+    "tool.execute.before": async (input2, output) => {
       try {
-        const sid = input.sessionID ?? "default";
-        if (input.sessionID && !sessionsWithStartupHint.has(sid)) {
-          sessionsWithStartupHint.add(sid);
-          output.system?.unshift(
-            '[memoir] You have Memoir MCP tools (memoir_memoir_recall, memoir_memoir_remember, memoir_memoir_get, memoir_memoir_summarize, memoir_memoir_status, memoir_memoir_branches, memoir_memoir_checkout).\nSAVE (memoir_memoir_remember) after: task completion, user stating preferences/constraints, discovering project facts. RECALL (memoir_memoir_recall \u2192 memoir_memoir_get) at session start for prior context, when user asks about prior work.\nNamespaces: "default" (user context), "codebase:onboard" (project facts in git repos). Taxonomy paths: preferences.*, project.*, codebase.*, decisions.*, learning.*.'
+        if (input2.tool !== "task" || output.args?.subagent_type !== MEMOIR_AGENT_NAME) return;
+        captureLifecycle.begin(input2.callID);
+        if (!backgroundSubagentsEnabled()) {
+          log(
+            "memoir task remains foreground: OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS is disabled"
           );
+          return;
         }
-        const count = sessionMsgCount.get(sid) ?? 0;
-        if (shouldRemind(count)) {
-          output.system?.push(
-            "\n[memoir] Reminder: Use memoir_memoir_remember to save context, memoir_memoir_recall to retrieve prior context."
-          );
+        output.args.background = true;
+        log("memoir capture task promoted to native background job");
+      } catch (e) {
+        log("tool.execute.before: failed", e);
+      }
+    },
+    "tool.execute.after": async (input2, output) => {
+      try {
+        if (input2.tool !== "task" || input2.args?.subagent_type !== MEMOIR_AGENT_NAME) return;
+        const childSessionID = output?.metadata?.sessionId;
+        if (output?.metadata?.background === true && childSessionID) {
+          captureLifecycle.background(input2.callID, childSessionID);
+          return;
+        }
+        captureLifecycle.finishCall(input2.callID);
+      } catch (e) {
+        log("tool.execute.after: failed", e);
+        captureLifecycle.finishCall(input2.callID);
+      }
+    },
+    event: async (input2) => {
+      try {
+        const event = input2.event;
+        if (event?.type !== "session.idle" && event?.type !== "session.error") return;
+        const sessionID = event.properties?.sessionID;
+        if (sessionID) captureLifecycle.finishSession(sessionID);
+      } catch (e) {
+        log("event: failed", e);
+      }
+    },
+    "experimental.chat.system.transform": async (input2, output) => {
+      try {
+        const sid = input2.sessionID ?? "default";
+        const status = turnStatus.get(sid);
+        if (status) output.system?.push(status);
+        if (input2.sessionID && parentSessions.has(sid) && !sessionsWithStartupHint.has(sid)) {
+          sessionsWithStartupHint.add(sid);
+          log("system.transform: startup hint injected for session", sid);
+          output.system?.unshift(loadPrompt("startup-hint.tmpl"));
+          const client = await connectClient();
+          if (client) {
+            if (process.env.MEMOIR_SUMMARIZE !== "0") {
+              const summary = await callMemoirTool(client, "memoir_summarize", {
+                depth: 1
+              });
+              if (summary) {
+                output.system?.unshift(
+                  `[memoir] Prior context already stored (memoir):
+${summary}`
+                );
+                log("system.transform: proactive recall injected for session", sid);
+              }
+            } else {
+              log("system.transform: recall skipped (MEMOIR_SUMMARIZE=0)");
+            }
+            const status2 = await callMemoirTool(client, "memoir_status", {});
+            if (status2) {
+              output.system?.unshift(`[memoir] Memory store status:
+${status2}`);
+              log("system.transform: store status injected for session", sid);
+            }
+          }
         }
       } catch (e) {
-        debugLog("system.transform: failed:", errorMessage2(e));
+        log("system.transform: failed", e);
       }
     },
     dispose: async () => {
       try {
         if (process.env.MEMOIR_AUTO_SAVE === "1") {
-          for (const [sid, count] of sessionMsgCount) {
-            await callMemoir(
-              [
-                "remember",
-                `session.${sid}`,
-                "--message",
-                `Session ended \u2014 ${count} user messages exchanged`
-              ],
-              storePath
-            );
+          const client = await connectClient();
+          if (client) {
+            for (const [sid, count] of messageCounts) {
+              await callMemoirTool(client, "memoir_remember", {
+                content: `Session ended \u2014 ${count} user messages exchanged`,
+                path: `session.${sid}`,
+                merge_policy: "replace"
+              });
+            }
           }
         }
       } catch (e) {
-        debugLog("dispose: save failed:", errorMessage2(e));
+        log("dispose: save failed", e);
       }
       sessionsWithStartupHint.clear();
-      pruneBranchCache();
-      pruneAll();
+      parentSessions.clear();
+      capturePending.clear();
+      captureLifecycle.clear();
+      branchMatcher.clear();
+      messageCounts.clear();
+      turnStatus.clear();
+      lastCaptured.clear();
+      await runtime.close();
     }
   };
   return hooks;