@ephemushroom/opencode-claude-mem 0.2.5 → 0.3.1

package/README.md

@@ -9,7 +9,7 @@ into new OpenCode sessions automatically.
 
 > **Note:** This plugin is a thin OpenCode adapter for an existing Claude-Mem
 > installation. It does **not** install Claude-Mem, manage slash commands, or
-> start the worker for you.
+> register Claude Code MCP servers for you.
 
 ## Quick Start
 
@@ -30,17 +30,23 @@ into new OpenCode sessions automatically.
 
 - **Shared Memory** — Uses the same Claude-Mem worker and memory store as
   Claude Code.
+- **Auto-Start** — When the plugin loads and the Claude-Mem worker is not
+  already running, it spawns `bunx claude-mem start` once per OpenCode process
+  (skipped silently if `bun` is not on `PATH` or the worker is already up).
 - **Automatic Context Injection** — Injects relevant project memory into the
   system prompt for new OpenCode turns.
 - **Compaction Support** — Re-injects memory context during OpenCode session
   compaction so long conversations keep their historical context.
 - **Observation Capture** — Sends tool observations to Claude-Mem for future
   retrieval and summarization.
+- **Native Memory Search** — Exposes a `mem-search` OpenCode tool backed by the
+  Claude-Mem worker search API, so search remains available without the Claude
+  Code compatibility bridge.
 - **Observation Hardening** — Skips low-value meta tools, strips
   `<claude-mem-context>` and `<private>` tags before storage, and truncates
   oversized observation payloads by UTF-8 byte size.
-- **Graceful Degradation** — If the worker is offline, the plugin fails open
-  and OpenCode continues to work normally.
+- **Graceful Degradation** — If the worker is offline and cannot be started,
+  the plugin fails open and OpenCode continues to work normally.
 
 ## How It Works
 
@@ -48,14 +54,19 @@ into new OpenCode sessions automatically.
 OpenCode session
     |
     |-- plugin loads
-    |   '-- connect to Claude-Mem worker on port 37777
+    |   '-- connect to Claude-Mem worker from env/settings/default endpoint
     |
+    |-- tool(mem-search) ............... search memory via worker API
     |-- session.created ................ track session + reset cache
     |-- chat.message ................... init session with real user prompt
     |-- tool.execute.after ............. send tool observation
     |-- system.transform ............... inject memory into system prompt
     |-- session.compacting ............. preserve memory during compaction
-    '-- session.idle ................... summarize + complete session
+    |-- message.updated ................ capture assistant text (debounced)
+    |-- file.edited .................... record file edit observation
+    |-- session.compacted .............. summarize after compaction
+    |-- session.idle ................... flush + summarize
+    '-- session.deleted ................ flush + complete (no zombie sessions)
 ```
 
 The plugin is intentionally small. It only adapts OpenCode hook events to the
@@ -65,9 +76,13 @@ storage stay in upstream Claude-Mem.
 ## Architecture
 
 ```
-OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker (port 37777) <-> SQLite + ChromaDB
+OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker <-> SQLite + ChromaDB
 ```
 
+The worker endpoint is resolved in this order: `CLAUDE_MEM_WORKER_HOST` /
+`CLAUDE_MEM_WORKER_PORT` environment variables, then
+`~/.claude-mem/settings.json`, then `127.0.0.1:37777`.
+
 ### Hook Mapping
 
 | Claude Code | OpenCode plugin | Purpose |
@@ -76,8 +91,12 @@ OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker (port 37777) <-> SQLite +
 | `SessionStart` | `experimental.session.compacting` | Preserve memory during compaction |
 | `UserPromptSubmit` | `chat.message` | Initialize session with real user prompt |
 | `PostToolUse` | `tool.execute.after` | Capture tool observations |
-| `Stop` | `event` (`session.idle`) | Summarize the session |
-| `SessionEnd` | `event` (`session.idle`) | Mark session complete |
+| Claude-Mem MCP | `tool` (`mem-search`) | Search memory from OpenCode |
+| _(streaming)_ | `event` (`message.updated`) | Capture assistant text (debounced) |
+| _(streaming)_ | `event` (`file.edited`) | Record file edit observations |
+| _(compaction)_ | `event` (`session.compacted`) | Summarize after OpenCode compacts |
+| `Stop` | `event` (`session.idle`) | Flush + summarize |
+| `SessionEnd` | `event` (`session.deleted`) | Flush + complete (no zombie active rows) |
 
 ### Worker API Endpoints Used
 
@@ -89,6 +108,11 @@ OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker (port 37777) <-> SQLite +
 | `POST` | `/api/sessions/observations` | Store tool observation |
 | `POST` | `/api/sessions/summarize` | Trigger summarization |
 | `POST` | `/api/sessions/complete` | Complete session |
+| `GET` | `/api/search?query={query}&project={name}` | Search memory |
+
+Session and observation writes include `platformSource: "opencode"` so
+Claude-Mem can attribute new OpenCode memories separately from Claude Code,
+while context injection and `mem-search` still search the shared project memory.
 
 ## Installation
 
@@ -97,7 +121,8 @@ OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker (port 37777) <-> SQLite +
 - [Claude Code](https://claude.com/claude-code) with
   [Claude-Mem](https://github.com/thedotmack/claude-mem) installed
 - [OpenCode](https://opencode.ai) with plugin support
-- A running Claude-Mem worker on port `37777` (default)
+- A running Claude-Mem worker (default `127.0.0.1:37777`, or your
+  `CLAUDE_MEM_WORKER_HOST` / `CLAUDE_MEM_WORKER_PORT` settings)
 
 ### Step 1: Install Claude-Mem
 
@@ -141,22 +166,38 @@ Once installed, the plugin works automatically:
   OpenCode’s compaction path so memory survives conversation compression.
 - **Tool observation capture** — Tool executions are stored as observations,
   except for low-value/meta tools and Claude-Mem search tools.
-- **Session summarization** — On `session.idle`, the plugin fetches the latest
-  user and assistant messages and asks Claude-Mem to summarize them.
+- **Memory search** — The `mem-search` tool queries the worker's `/api/search`
+  endpoint for the current project.
+- **Assistant message capture** — Assistant text from `message.updated` is
+  buffered with 250ms debounce per session and sent as a single
+  `assistant_message` observation per turn (avoids streaming-chunk floods).
+- **File edit capture** — `file.edited` events are forwarded as `file_edit`
+  observations (path only; OpenCode does not include diff in the event).
+- **Session summarization** — On `session.compacted` and `session.idle`, the
+  plugin flushes any pending assistant buffer, fetches the latest user and
+  assistant messages, and asks Claude-Mem to summarize them.
+- **Session lifecycle hygiene** — On `session.deleted` the plugin tells the
+  worker to `completeSession`, preventing zombie `'active'` rows from
+  accumulating stale `pending_messages` (the "queueDepth never decreases"
+  failure mode).
 
 ## Memory Search
 
-Memory search is provided by Claude-Mem’s MCP server, not by this plugin.
+This plugin provides a native OpenCode tool named `mem-search`. It calls the
+Claude-Mem worker's `/api/search` endpoint for the current project and returns
+the same formatted result text the worker exposes over HTTP.
 
-If your OpenCode environment already has Claude-Mem MCP tools configured, the
-assistant can query project memory directly with Claude-Mem’s search workflow:
+Claude Code's claude-mem plugin also registers an MCP server through its own
+`.mcp.json`. OpenCode does not automatically load Claude Code plugin MCP
+servers. If you previously saw Claude-Mem MCP tools in OpenCode, they were most
+likely supplied by a Claude Code compatibility bridge such as oh-my-openagent.
+Disabling that bridge for `claude-mem@thedotmack` removes those bridged MCP
+tools; `mem-search` is the native replacement inside this plugin.
 
-1. `search(query="...")`
-2. `timeline(anchor=ID)`
-3. `get_observations(ids=[...])`
-
-This plugin focuses on sending memory data to the worker and injecting returned
-context back into OpenCode sessions.
+The richer Claude-Mem MCP workflow (`search`, `timeline`, `get_observations`) can
+still be configured separately in OpenCode if you want it. It is not required for
+automatic context injection, observation capture, summarization, or the built-in
+`mem-search` tool.
 
 ## Key Implementation Details
 
@@ -168,6 +209,11 @@ context back into OpenCode sessions.
   avoiding startup crashes caused by early TUI access.
 - **Real prompt initialization** — `chat.message` sends the actual user prompt
   to Claude-Mem instead of a synthetic placeholder.
+- **OpenCode attribution** — Session, observation, summarize, and complete
+  payloads include `platformSource: "opencode"`.
+- **Worker endpoint resolution** — The plugin reads `CLAUDE_MEM_WORKER_HOST` /
+  `CLAUDE_MEM_WORKER_PORT`, then `~/.claude-mem/settings.json`, then defaults to
+  `127.0.0.1:37777`.
 - **Real summarize payloads** — On `session.idle`, the plugin reads the latest
   session messages and sends the last user and assistant messages for summary.
 - **Context caching** — Memory context is fetched once per session and reused
@@ -179,6 +225,10 @@ context back into OpenCode sessions.
   reduce token waste and avoid oversize worker payloads.
 - **Field name correctness** — Worker payloads use `contentSessionId`, not
   `claudeSessionId`.
+- **PreToolUse file context** — Claude Code's native `PreToolUse Read`
+  `file-context` hook is not mirrored because the current OpenCode plugin
+  `tool.execute.before` API only lets plugins alter tool args; it has no channel
+  to inject extra LLM context before the tool call.
 
 ## Differences from `bloodf/opencode-mem`
 
@@ -207,7 +257,15 @@ curl -s http://127.0.0.1:37777/api/health
 
 ### OpenCode shows `Worker offline`
 
-- Restart Claude Code to bring Claude-Mem back up.
+The plugin will try to launch the worker via `bunx claude-mem start` once on
+plugin load. If that toast still appears:
+
+- Confirm `bun` is on your `PATH` — `bun --version` should print a version.
+- Confirm `claude-mem` is installed for `bunx`/`npx` — run
+  `bunx claude-mem --version` once to populate the cache.
+- On Windows after a forced kill, port `37777` may stay in `TIME_WAIT` for
+  30-120 seconds; wait it out or restart Claude Code.
+- Restart Claude Code to bring Claude-Mem back up via its own supervisor.
 - Verify the worker port is still `37777`.
 
 ### OpenCode crashes on startup
@@ -225,9 +283,10 @@ curl -s http://127.0.0.1:37777/api/health
 
 ### Memory search is unavailable
 
-- This plugin does not configure MCP tools for you.
-- Configure Claude-Mem’s MCP server separately in your OpenCode environment if
-  you want in-editor memory search.
+- Use the built-in `mem-search` tool exposed by this plugin.
+- If you specifically need Claude-Mem's MCP `timeline` or `get_observations`
+  tools, configure the Claude-Mem MCP server separately in OpenCode or enable a
+  compatible bridge for MCP only.
 
 ## Development
 

package/dist/index.d.ts

@@ -3,9 +3,11 @@ import { type Plugin } from '@opencode-ai/plugin';
  * OpenCode Plugin for Claude-Mem
  *
  * Hooks used:
- * - `event` — session lifecycle (session.created, session.idle)
+ * - `event` — session lifecycle (session.created, session.idle, session.compacted,
+ *             session.deleted, message.updated, file.edited)
  * - `tool.execute.after` — capture tool observations
  * - `experimental.chat.system.transform` — inject memory context into system prompt
+ * - `experimental.session.compacting` — preserve memory context during compaction
  * - `chat.message` — session init with real user prompt
  *
  * Memory context is automatically injected into every conversation via system prompt.

package/dist/index.js

@@ -1,12 +1,97 @@
 // @bun
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+
 // src/worker-client.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+var HEALTH_TIMEOUT_MS = 1000;
+var AUTOSTART_POLL_INTERVAL_MS = 500;
+var AUTOSTART_POLL_MAX_ATTEMPTS = 16;
+var DEFAULT_WORKER_HOST = "127.0.0.1";
+var DEFAULT_WORKER_PORT = 37777;
+var PLATFORM_SOURCE = "opencode";
+var SETTINGS_FILE = join(homedir(), ".claude-mem", "settings.json");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function readPort(value) {
+  const text = readString(value);
+  if (!text || !/^\d+$/.test(text)) {
+    return null;
+  }
+  const port = Number(text);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+function parseSettings(rawSettings) {
+  if (!rawSettings) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(rawSettings);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseWorkerEndpoint(env, rawSettings) {
+  const settings = parseSettings(rawSettings);
+  const host = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
+  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? DEFAULT_WORKER_PORT;
+  return { host, port };
+}
+function readSettingsRaw() {
+  try {
+    return readFileSync(SETTINGS_FILE, "utf8");
+  } catch {
+    return null;
+  }
+}
+function getWorkerBaseUrl() {
+  const endpoint = parseWorkerEndpoint(process.env, readSettingsRaw());
+  return `http://${endpoint.host}:${endpoint.port}`;
+}
+function extractTextContent(value) {
+  if (typeof value === "string") {
+    return value.trim() || null;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  const { content } = value;
+  if (typeof content === "string") {
+    return content.trim() || null;
+  }
+  if (Array.isArray(content)) {
+    const text2 = content.map((part) => {
+      if (!isRecord(part) || part["type"] !== "text" || typeof part["text"] !== "string") {
+        return "";
+      }
+      return part["text"];
+    }).filter(Boolean).join(`
+`).trim();
+    return text2 || null;
+  }
+  const text = JSON.stringify(value, null, 2);
+  return text === "{}" || text === "null" ? null : text;
+}
+
 class WorkerClient {
-  static PORT = 37777;
-  static BASE_URL = `http://127.0.0.1:${WorkerClient.PORT}`;
+  static BASE_URL = getWorkerBaseUrl();
+  static autoStartPromise = null;
   static async isHealthy() {
     try {
       const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), 1000);
+      const timeoutId = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
       const response = await fetch(`${this.BASE_URL}/api/health`, {
         signal: controller.signal
       });
@@ -16,15 +101,83 @@ class WorkerClient {
       return false;
     }
   }
-  static async ensureRunning(_projectRoot) {
-    return await this.isHealthy();
+  static async ensureRunning() {
+    const result = await this.tryAutoStart();
+    return result === "already-running" || result === "started";
+  }
+  static tryAutoStart() {
+    if (!this.autoStartPromise) {
+      this.autoStartPromise = this.runAutoStart().catch(() => "spawn-failed");
+    }
+    return this.autoStartPromise;
+  }
+  static async runAutoStart() {
+    if (await this.isHealthy()) {
+      return "already-running";
+    }
+    const bunPath = this.findBun();
+    if (!bunPath) {
+      return "no-bun";
+    }
+    try {
+      const child = spawn(bunPath, ["x", "claude-mem", "start"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: process.env
+      });
+      child.on("error", () => {});
+      child.unref();
+    } catch {
+      return "spawn-failed";
+    }
+    for (let i = 0;i < AUTOSTART_POLL_MAX_ATTEMPTS; i++) {
+      await new Promise((resolve) => setTimeout(resolve, AUTOSTART_POLL_INTERVAL_MS));
+      if (await this.isHealthy()) {
+        return "started";
+      }
+    }
+    return "timeout";
+  }
+  static findBun() {
+    const bunGlobal = globalThis.Bun;
+    if (bunGlobal && typeof bunGlobal.which === "function") {
+      try {
+        const found = bunGlobal.which("bun");
+        if (typeof found === "string" && found) {
+          return found;
+        }
+      } catch {}
+    }
+    const path = process.env.PATH || "";
+    const sep = process.platform === "win32" ? ";" : ":";
+    const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+    const slash = process.platform === "win32" ? "\\" : "/";
+    const dirs = path.split(sep).filter(Boolean);
+    for (const dir of dirs) {
+      const trailing = dir.endsWith("/") || dir.endsWith("\\") ? "" : slash;
+      for (const ext of exts) {
+        const candidate = `${dir}${trailing}bun${ext}`;
+        try {
+          if (existsSync(candidate)) {
+            return candidate;
+          }
+        } catch {}
+      }
+    }
+    return null;
   }
   static async sessionInit(contentSessionId, project, prompt) {
     try {
       const response = await fetch(`${this.BASE_URL}/api/sessions/init`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ contentSessionId, project, prompt })
+        body: JSON.stringify({
+          contentSessionId,
+          project,
+          prompt,
+          platformSource: PLATFORM_SOURCE
+        })
       });
       if (!response.ok) {
         return null;
@@ -44,7 +197,8 @@ class WorkerClient {
           tool_name: toolName,
           tool_input: toolInput,
           tool_response: toolResponse,
-          cwd
+          cwd,
+          platformSource: PLATFORM_SOURCE
         })
       });
     } catch {}
@@ -57,7 +211,8 @@ class WorkerClient {
         body: JSON.stringify({
           contentSessionId,
           last_user_message: lastUserMessage,
-          last_assistant_message: lastAssistantMessage
+          last_assistant_message: lastAssistantMessage,
+          platformSource: PLATFORM_SOURCE
         })
       });
     } catch {}
@@ -67,7 +222,7 @@ class WorkerClient {
       await fetch(`${this.BASE_URL}/api/sessions/complete`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ contentSessionId })
+        body: JSON.stringify({ contentSessionId, platformSource: PLATFORM_SOURCE })
       });
     } catch {}
   }
@@ -79,15 +234,7 @@ class WorkerClient {
       }
       const contentType = response.headers.get("content-type") || "";
       if (contentType.includes("application/json")) {
-        const data = await response.json();
-        if (typeof data === "string") {
-          return data;
-        }
-        if (data && typeof data.content === "string") {
-          return data.content;
-        }
-        const text2 = JSON.stringify(data, null, 2);
-        return text2 === "{}" || text2 === "null" ? null : text2;
+        return extractTextContent(await response.json());
       }
       const text = await response.text();
       return text.trim() || null;
@@ -95,16 +242,38 @@ class WorkerClient {
       return null;
     }
   }
+  static async search(query, project, limit) {
+    try {
+      const params = new URLSearchParams({ query, project });
+      if (limit !== undefined) {
+        params.set("limit", String(limit));
+      }
+      const response = await fetch(`${this.BASE_URL}/api/search?${params.toString()}`);
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        return extractTextContent(await response.json()) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
 }
 
 // src/index.ts
 var MAX_OBSERVATION_BYTES = 24 * 1024;
 var MAX_TAG_REPLACEMENTS = 100;
+var ASSISTANT_FLUSH_DEBOUNCE_MS = 250;
 var META_TOOLS = new Set([
   "askuserquestion",
   "getmcpresource",
   "listmcpresourcestool",
   "listmcptools",
+  "mem-search",
   "skill",
   "slashcommand",
   "todowrite"
@@ -170,7 +339,10 @@ function shouldSkipObservationTool(toolName) {
     return true;
   }
   const normalizedName = toolName.toLowerCase();
-  return normalizedName.startsWith("claude-mem_mcp-search_") || META_TOOLS.has(normalizedName);
+  if (normalizedName.includes("mcp-search") || normalizedName.includes("mem-search")) {
+    return true;
+  }
+  return META_TOOLS.has(normalizedName);
 }
 function normalizeToolOutput(output) {
   if (typeof output === "string") {
@@ -185,6 +357,13 @@ function normalizeToolOutput(output) {
     return String(output);
   }
 }
+function extractTextFromParts(parts) {
+  if (!parts || !Array.isArray(parts)) {
+    return "";
+  }
+  return parts.filter((p) => p && p.type === "text" && typeof p.text === "string" && !p.synthetic && !p.ignored).map((p) => p.text).join(`
+`).trim();
+}
 var ClaudeMemPlugin = async (ctx) => {
   const { project, directory, client } = ctx;
   const projectRoot = directory || process.cwd();
@@ -209,20 +388,60 @@ var ClaudeMemPlugin = async (ctx) => {
   let initToastShown = false;
   async function checkWorkerAndToast() {
     if (workerHealthy === null) {
-      workerHealthy = await WorkerClient.isHealthy();
+      workerHealthy = await WorkerClient.ensureRunning();
     }
     if (!initToastShown) {
       initToastShown = true;
       if (workerHealthy) {
         await toast(`Memory active \xB7 ${projectName}`, "success");
       } else {
-        await toast("Worker offline \u2014 start Claude Code first", "warning", 5000);
+        await toast("Worker offline \u2014 install Claude-Mem (bunx claude-mem start) or start Claude Code first", "warning", 5000);
       }
     }
     return workerHealthy;
   }
   let currentSessionId = null;
   const initializedSessions = new Set;
+  const assistantBuffers = new Map;
+  async function flushAssistantBuffer(sessionId) {
+    const buf = assistantBuffers.get(sessionId);
+    if (!buf || !buf.messageId) {
+      return;
+    }
+    if (buf.timer) {
+      clearTimeout(buf.timer);
+      buf.timer = null;
+    }
+    const { messageId } = buf;
+    buf.messageId = null;
+    try {
+      const text = await fetchAssistantMessageText(sessionId, messageId);
+      const sanitized = truncateUtf8Bytes(stripTaggedContent(text), MAX_OBSERVATION_BYTES);
+      if (sanitized) {
+        await WorkerClient.sendObservation(sessionId, "assistant_message", { messageId }, sanitized, projectRoot);
+      }
+    } catch {}
+  }
+  function scheduleAssistantFlush(sessionId) {
+    const buf = assistantBuffers.get(sessionId);
+    if (!buf) {
+      return;
+    }
+    if (buf.timer) {
+      clearTimeout(buf.timer);
+    }
+    buf.timer = setTimeout(() => {
+      buf.timer = null;
+      flushAssistantBuffer(sessionId);
+    }, ASSISTANT_FLUSH_DEBOUNCE_MS);
+  }
+  function discardAssistantBuffer(sessionId) {
+    const buf = assistantBuffers.get(sessionId);
+    if (buf?.timer) {
+      clearTimeout(buf.timer);
+    }
+    assistantBuffers.delete(sessionId);
+  }
   async function ensureSessionInit(sessionId, prompt) {
     if (initializedSessions.has(sessionId)) {
       return true;
@@ -240,56 +459,160 @@ var ClaudeMemPlugin = async (ctx) => {
       return false;
     }
   }
-  function extractTextFromParts(parts) {
-    if (!parts || !Array.isArray(parts)) {
-      return "";
-    }
-    return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
-`).trim();
+  async function fetchAssistantMessageText(sessionId, messageId) {
+    try {
+      const result = await client.session.messages({ path: { id: sessionId } });
+      if (result.data && Array.isArray(result.data)) {
+        const target = result.data.find((m) => m?.info?.id === messageId);
+        if (target) {
+          return extractTextFromParts(target.parts);
+        }
+      }
+    } catch {}
+    return "";
+  }
+  async function fetchLastMessages(sessionId) {
+    let user = "";
+    let assistant = "";
+    try {
+      const result = await client.session.messages({ path: { id: sessionId } });
+      if (result.data && Array.isArray(result.data)) {
+        const messages = result.data;
+        for (let i = messages.length - 1;i >= 0; i--) {
+          if (messages[i].info.role === "user") {
+            user = extractTextFromParts(messages[i].parts);
+            break;
+          }
+        }
+        for (let i = messages.length - 1;i >= 0; i--) {
+          if (messages[i].info.role === "assistant") {
+            assistant = extractTextFromParts(messages[i].parts);
+            break;
+          }
+        }
+      }
+    } catch {}
+    return { user, assistant };
   }
   return {
+    tool: {
+      "mem-search": tool({
+        description: "Search Claude-Mem persistent memory for this OpenCode project.",
+        args: {
+          query: tool.schema.string().min(1).describe("Search query for Claude-Mem memory"),
+          limit: tool.schema.number().int().positive().max(50).optional().describe("Maximum number of search results")
+        },
+        execute: async ({ query, limit }) => {
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return "Claude-Mem worker is offline. Start Claude-Mem and retry the search.";
+          }
+          const result = await WorkerClient.search(query, projectName, limit);
+          return result || `No Claude-Mem results found for "${query}".`;
+        }
+      })
+    },
     event: async ({ event }) => {
-      if (event.type === "session.created") {
-        const sessionId = event.properties?.info?.id;
-        if (!sessionId) {
+      switch (event.type) {
+        case "session.created": {
+          const sessionId = event.properties?.info?.id;
+          if (!sessionId) {
+            return;
+          }
+          currentSessionId = sessionId;
+          contextCache = undefined;
+          await checkWorkerAndToast();
           return;
         }
-        currentSessionId = sessionId;
-        contextCache = undefined;
-        await checkWorkerAndToast();
-      }
-      if (event.type === "session.idle") {
-        const sessionId = event.properties?.sessionID || currentSessionId;
-        if (!sessionId) {
+        case "message.updated": {
+          const info = event.properties?.info;
+          const sessionId = info?.sessionID;
+          const messageId = info?.id;
+          if (!sessionId || !messageId || info?.role !== "assistant") {
+            return;
+          }
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return;
+          }
+          if (!await ensureSessionInit(sessionId)) {
+            return;
+          }
+          let buf = assistantBuffers.get(sessionId);
+          if (!buf) {
+            buf = { messageId: null, timer: null };
+            assistantBuffers.set(sessionId, buf);
+          }
+          buf.messageId = messageId;
+          scheduleAssistantFlush(sessionId);
           return;
         }
-        try {
-          let lastUserMessage = "";
-          let lastAssistantMessage = "";
+        case "file.edited": {
+          const filePath = event.properties?.file;
+          const sessionId = currentSessionId;
+          if (!sessionId || !filePath) {
+            return;
+          }
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return;
+          }
+          if (!await ensureSessionInit(sessionId)) {
+            return;
+          }
           try {
-            const result = await client.session.messages({
-              path: { id: sessionId }
-            });
-            if (result.data && Array.isArray(result.data)) {
-              const messages = result.data;
-              for (let i = messages.length - 1;i >= 0; i--) {
-                if (messages[i].info.role === "user") {
-                  lastUserMessage = extractTextFromParts(messages[i].parts);
-                  break;
-                }
-              }
-              for (let i = messages.length - 1;i >= 0; i--) {
-                if (messages[i].info.role === "assistant") {
-                  lastAssistantMessage = extractTextFromParts(messages[i].parts);
-                  break;
-                }
-              }
-            }
+            await WorkerClient.sendObservation(sessionId, "file_edit", { path: filePath }, `File edited: ${filePath}`, projectRoot);
           } catch {}
-          await WorkerClient.summarize(sessionId, lastUserMessage, lastAssistantMessage);
-          await WorkerClient.completeSession(sessionId);
-          await toast("Session summarized", "success", 2000);
-        } catch {}
+          return;
+        }
+        case "session.compacted": {
+          const sessionId = event.properties?.sessionID || currentSessionId;
+          if (!sessionId) {
+            return;
+          }
+          await flushAssistantBuffer(sessionId);
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return;
+          }
+          try {
+            const { user, assistant } = await fetchLastMessages(sessionId);
+            await WorkerClient.summarize(sessionId, user, assistant);
+          } catch {}
+          return;
+        }
+        case "session.idle": {
+          const sessionId = event.properties?.sessionID || currentSessionId;
+          if (!sessionId) {
+            return;
+          }
+          await flushAssistantBuffer(sessionId);
+          try {
+            const { user, assistant } = await fetchLastMessages(sessionId);
+            await WorkerClient.summarize(sessionId, user, assistant);
+            await toast("Session summarized", "success", 2000);
+          } catch {}
+          return;
+        }
+        case "session.deleted": {
+          const sessionId = event.properties?.info?.id || currentSessionId;
+          if (!sessionId) {
+            return;
+          }
+          await flushAssistantBuffer(sessionId);
+          discardAssistantBuffer(sessionId);
+          initializedSessions.delete(sessionId);
+          if (currentSessionId === sessionId) {
+            currentSessionId = null;
+          }
+          try {
+            await WorkerClient.completeSession(sessionId);
+          } catch {}
+          return;
+        }
+        default: {
+          return;
+        }
       }
     },
     "chat.message": async (input, output) => {

package/dist/worker-client.d.ts

@@ -1,18 +1,45 @@
-/**
- * Worker Client for Claude-Mem
- * Handles communication with the local worker service running on port 37777.
- */
+export interface WorkerEndpoint {
+    readonly host: string;
+    readonly port: number;
+}
+export type AutoStartResult = 'already-running' | 'started' | 'no-bun' | 'spawn-failed' | 'timeout' | 'skipped';
+export declare function parseWorkerEndpoint(env: Record<string, string | undefined>, rawSettings: string | null): WorkerEndpoint;
 export declare class WorkerClient {
-    private static readonly PORT;
     private static readonly BASE_URL;
+    /** Per-process guard so multiple OpenCode windows don't all spawn workers. */
+    private static autoStartPromise;
     /**
      * Check if the worker is healthy
      */
     static isHealthy(): Promise<boolean>;
     /**
-     * Ensure the worker is running.
+     * Ensure the worker is running. If healthy, returns true. Otherwise tries
+     * to spawn it via `bunx claude-mem start` in the background and resolves
+     * once the worker reports healthy or the timeout is reached.
+     *
+     * Idempotent + serialised within the process via `autoStartPromise`.
+     */
+    static ensureRunning(): Promise<boolean>;
+    /**
+     * Try to auto-start the Claude-Mem worker via `bunx claude-mem start`.
+     *
+     * Behaviour:
+     * - If the worker is already healthy, returns 'already-running' immediately.
+     * - If `bun` is not on PATH, returns 'no-bun' without attempting to spawn.
+     * - Otherwise spawns a detached `bunx claude-mem start` process and polls
+     *   /api/health for ~8 seconds. Returns 'started' on success, 'timeout' on
+     *   failure to come up, 'spawn-failed' if the spawn itself errored.
+     *
+     * Concurrent calls share the same in-flight promise.
+     */
+    static tryAutoStart(): Promise<AutoStartResult>;
+    private static runAutoStart;
+    /**
+     * Locate the `bun` executable. Prefers Bun's own runtime detector when the
+     * plugin is loaded inside Bun (which OpenCode currently is), then falls back
+     * to PATH probing via `process.env.PATH`.
      */
-    static ensureRunning(_projectRoot: string): Promise<boolean>;
+    private static findBun;
     /**
      * Initialize a session
      */
@@ -37,4 +64,5 @@ export declare class WorkerClient {
      * Uses /api/context/inject which returns rich markdown with observations + session summaries.
      */
     static getContext(project: string): Promise<string | null>;
+    static search(query: string, project: string, limit?: number): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ephemushroom/opencode-claude-mem",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "OpenCode plugin for Claude-Mem persistent memory system",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,7 +19,7 @@
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js --target bun --format esm --external @opencode-ai/plugin && tsc --emitDeclarationOnly",
+    "build": "bun build src/index.ts --outfile dist/index.js --target bun --format esm --external @opencode-ai/plugin && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
     "lint": "oxlint",