@ephemushroom/opencode-claude-mem 0.2.4 → 0.3.0

package/README.md

@@ -1,57 +1,20 @@
 # opencode-claude-mem
 
-OpenCode plugin for [Claude-Mem](https://github.com/thedotmack/claude-mem) persistent memory system.
+Persistent memory for [OpenCode](https://opencode.ai), powered by
+[Claude-Mem](https://github.com/thedotmack/claude-mem).
 
-Enables OpenCode to share the same memory database as Claude Code — observations, summaries, and context injection all work across both editors.
+Share the same Claude-Mem worker, database, and search tools between Claude Code
+and OpenCode. Once connected, previous observations and summaries are injected
+into new OpenCode sessions automatically.
 
-## How It Works
-
-This plugin communicates with the Claude-Mem worker service (HTTP API on port 37777) to:
-
-- **Inject memory context** — previous session context is automatically injected into the system prompt on every LLM call
-- **Capture tool observations** — every tool execution is recorded as a structured observation
-- **Summarize sessions** — when a session goes idle, the last user/assistant messages are sent for summarization
-- **Search memory** — memory search is available via claude-mem's MCP server
-
-## Differences from Claude Code Version
-
-The Claude Code version of claude-mem uses shell-based hooks where `SessionStart` stdout is automatically injected into the system prompt — one-time, at session start.
-
-This OpenCode version works differently:
-
-| | Claude Code | OpenCode (this plugin) |
-|---|---|---|
-| **Architecture** | Shell commands (`node script.js`) | JavaScript plugin API |
-| **Context injection** | `SessionStart` hook stdout → system prompt (once) | `experimental.chat.system.transform` → system prompt (every LLM call, session-level cache) |
-| **Context freshness** | Snapshot at session start | Cached once per session (same as Claude Code) |
-| **Session init** | `UserPromptSubmit` hook | `chat.message` hook with real user prompt |
-| **Observations** | `PostToolUse` hook | `tool.execute.after` hook (with circular memory protection) |
-| **Summarization** | `Stop` hook | `session.idle` event |
-| **Memory search** | MCP server | MCP server (same — no custom tool needed) |
-
-Both versions behave the same way: context is fetched once per session and cached. The OpenCode plugin uses `experimental.chat.system.transform` which fires on every LLM call, but the context is session-level cached so the worker is only called once.
-
-## Prerequisites
-
-- [Claude Code](https://claude.com/claude-code) with [claude-mem plugin](https://github.com/thedotmack/claude-mem) installed and running
-- [OpenCode](https://opencode.ai) with plugin support
-
-## Installation
-
-### Step 1: Install Claude-Mem (if not already)
+> **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.
 
-In Claude Code terminal:
+## Quick Start
 
-```
-/plugin marketplace add thedotmack/claude-mem
-/plugin install claude-mem
-```
-
-Restart Claude Code. The worker service will start automatically on port 37777.
-
-### Step 2: Add the Plugin
-
-Add to your `opencode.json` (project or global `~/.config/opencode/opencode.json`):
+1. Install and configure Claude-Mem in Claude Code.
+2. Add this plugin to your `opencode.json`:
 
 ```json
 {
@@ -59,241 +22,252 @@ Add to your `opencode.json` (project or global `~/.config/opencode/opencode.json
 }
 ```
 
-Restart OpenCode. The plugin will be installed automatically.
+3. Restart OpenCode.
+4. Start a session — memory context will be injected automatically when the
+   Claude-Mem worker is available.
+
+## Key Features
+
+- **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.
+- **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 and cannot be started,
+  the plugin fails open and OpenCode continues to work normally.
 
-### Step 3: Verify
-
-```bash
-# Check worker is running
-curl -s http://127.0.0.1:37777/api/health
+## How It Works
 
-# Restart OpenCode — you should see toast: "Memory active · {project}"
 ```
-
-## Usage
-
-### Automatic (no action needed)
-
-Once installed, the plugin works automatically:
-
-- **System prompt injection** — memory context is automatically injected into every LLM call via `experimental.chat.system.transform`. The LLM sees your project's observation history, past decisions, and session summaries. Context is cached once per session to avoid redundant worker calls.
-- **Tool observation capture** — every tool execution (file reads, edits, searches, etc.) is recorded as an observation in the memory database. Claude-mem's own MCP tools are automatically filtered to prevent circular memory.
-- **Session summarization** — when a session goes idle, the last user/assistant exchange is summarized and stored.
-- **Toast notification** — on session start, a "Memory active · {project}" toast confirms the plugin is connected to the worker.
-
-**Note**: Memory context is injected transparently into every conversation. You don't need to run any commands — the plugin works automatically in the background.
-
-### Memory Search
-
-Memory search is provided by claude-mem's MCP server. If you have the claude-mem MCP configured in OpenCode, the LLM can search project history directly via MCP tools — no plugin-level tool needed.
-
-### Alternative: Manual Installation (from source)
-
-If you prefer to install from source instead of npm:
-
-```bash
-git clone https://github.com/Ephemushroom/opencode-claude-mem.git
-cd opencode-claude-mem
-bun install
-bun run build
+OpenCode session
+    |
+    |-- plugin loads
+    |   '-- connect to Claude-Mem worker on port 37777
+    |
+    |-- 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
+    |-- message.updated ................ capture assistant text (debounced)
+    |-- file.edited .................... record file edit observation
+    |-- session.compacted .............. summarize after compaction
+    |-- session.idle ................... flush + summarize + complete session
+    '-- session.deleted ................ flush + complete (no zombie sessions)
 ```
 
-Then symlink into OpenCode:
+The plugin is intentionally small. It only adapts OpenCode hook events to the
+Claude-Mem worker HTTP API. All indexing, summarization, memory search, and
+storage stay in upstream Claude-Mem.
 
-**macOS / Linux:**
+## Architecture
 
-```bash
-mkdir -p ~/.config/opencode/plugin
-ln -sf "$(pwd)/dist/index.js" ~/.config/opencode/plugin/claude-mem.js
 ```
-
-**Windows (requires elevated terminal):**
-
-```powershell
-# Option A: If you have gsudo / sudo installed
-sudo powershell -Command "New-Item -ItemType SymbolicLink -Path '$env:USERPROFILE\.config\opencode\plugin\claude-mem.js' -Target 'D:\path\to\opencode-claude-mem\dist\index.js'"
-
-# Option B: Run PowerShell as Administrator
-New-Item -ItemType SymbolicLink -Path "$env:USERPROFILE\.config\opencode\plugin\claude-mem.js" -Target "D:\path\to\opencode-claude-mem\dist\index.js"
+OpenCode <-> Plugin (this repo) <-> Claude-Mem Worker (port 37777) <-> SQLite + ChromaDB
 ```
 
----
+### Hook Mapping
 
-## Windows-Specific Setup
-
-### Python Version for ChromaDB
+| Claude Code | OpenCode plugin | Purpose |
+|---|---|---|
+| `SessionStart` | `experimental.chat.system.transform` | Inject memory context |
+| `SessionStart` | `experimental.session.compacting` | Preserve memory during compaction |
+| `UserPromptSubmit` | `chat.message` | Initialize session with real user prompt |
+| `PostToolUse` | `tool.execute.after` | Capture tool observations |
+| _(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 + complete |
+| `SessionEnd` | `event` (`session.deleted`) | Flush + complete (no zombie active rows) |
 
-Claude-Mem uses ChromaDB for vector semantic search. ChromaDB's `chroma-mcp` tool requires **Python ≤ 3.13** (Pydantic V1 is incompatible with Python 3.14+).
+### Worker API Endpoints Used
 
-If `uv` defaults to Python 3.14, you'll see:
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `GET` | `/api/health` | Health check |
+| `GET` | `/api/context/inject?project={name}` | Fetch formatted memory context |
+| `POST` | `/api/sessions/init` | Initialize session |
+| `POST` | `/api/sessions/observations` | Store tool observation |
+| `POST` | `/api/sessions/summarize` | Trigger summarization |
+| `POST` | `/api/sessions/complete` | Complete session |
 
-```
-Chroma connection failed: Chroma server not reachable.
-```
+## Installation
 
-**Fix — set global Python version:**
+### Prerequisites
 
-```bash
-uv python pin --global 3.13
-```
+- [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)
 
-This creates a global `.python-version` file in `%APPDATA%\uv\` so all `uvx` calls default to 3.13.
+### Step 1: Install Claude-Mem
 
-### ChromaDB on Windows x64
+In Claude Code:
 
-The npm `chromadb` package only supports Windows ARM64, not x64. The worker will fail to start Chroma natively.
+```text
+/plugin marketplace add thedotmack/claude-mem
+/plugin install claude-mem
+```
 
-**Fix — use Python ChromaDB instead:**
+Restart Claude Code so the worker can start and initialize its data directory.
 
-```bash
-# Install Python ChromaDB CLI
-uv tool install chromadb --python 3.13
-```
+### Step 2: Add the OpenCode Plugin
 
-Update `~/.claude-mem/settings.json`:
+Add this plugin to your project or global `opencode.json`:
 
 ```json
 {
-  "CLAUDE_MEM_CHROMA_MODE": "remote"
+  "plugin": ["@ephemushroom/opencode-claude-mem"]
 }
 ```
 
-Start Chroma server manually:
-
-```bash
-chroma run --path %USERPROFILE%\.claude-mem\vector-db --host 127.0.0.1 --port 8000
-```
+Then restart OpenCode.
 
-> **Note**: Chroma server must be running before Claude Code starts. Consider creating a startup script or scheduled task.
-
-### ChromaDB Embedding Model Crash (Bun Runtime)
-
-After connecting to Chroma, the worker may crash with:
+### Step 3: Verify
 
-```
-Collection setup failed: undefined is not an object
-  (evaluating 'e.cacheDir = ...')
+```bash
+curl -s http://127.0.0.1:37777/api/health
 ```
 
-This happens because `@huggingface/transformers` returns `undefined` when imported through Bun's CJS shim.
+If the worker is healthy, OpenCode should show a toast like
+`Memory active · <project>` when a session starts.
 
-**Fix — patch `worker-service.cjs`:**
+## Usage
 
-Locate the bundled worker file:
+Once installed, the plugin works automatically:
 
-```
-~/.claude/plugins/cache/thedotmack/claude-mem/<version>/scripts/worker-service.cjs
-```
+- **Context injection** — Memory is injected into the system prompt on each LLM
+  call, with session-level caching to avoid repeated worker requests.
+- **Compaction preservation** — The same cached memory context is pushed into
+  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.
+- **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.
+
+If your OpenCode environment already has Claude-Mem MCP tools configured, the
+assistant can query project memory directly with Claude-Mem’s search workflow:
+
+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.
 
-Find this pattern (minified):
+## Key Implementation Details
 
-```javascript
-let{env:e}=await Promise.resolve().then(()=>(F9(),N9));
-```
+- **Thin client architecture** — `src/index.ts` handles OpenCode hooks and
+  session state; `src/worker-client.ts` is a static HTTP client.
+- **No console logging** — The plugin never writes to `console.*` because that
+  can corrupt the OpenCode TUI.
+- **Deferred toast** — Health toasts only happen after hook execution begins,
+  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.
+- **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
+  across prompt injection and compaction.
+- **Circular memory protection** — Injected context is wrapped in
+  `<claude-mem-context>` tags, Claude-Mem MCP search tools are skipped, and
+  memory-related tags are stripped before storing observations.
+- **UTF-8 truncation** — Large observation outputs are capped by byte size to
+  reduce token waste and avoid oversize worker payloads.
+- **Field name correctness** — Worker payloads use `contentSessionId`, not
+  `claudeSessionId`.
+
+## Differences from `bloodf/opencode-mem`
+
+This project intentionally stays smaller in scope.
+
+- **This plugin does**: bridge OpenCode hooks to an already-installed
+  Claude-Mem worker.
+- **This plugin does not**: auto-install Claude-Mem, auto-edit OpenCode config,
+  auto-copy skills, auto-register slash commands, or auto-start the worker.
+
+That keeps the runtime behavior predictable and leaves worker ownership with the
+upstream Claude-Mem installation.
 
-Replace with:
+## Troubleshooting
 
-```javascript
-let{env:e}=await import("@huggingface/transformers");
-```
+### No memory appears in OpenCode
 
-Then install the dependency:
+- Confirm the worker is running:
 
 ```bash
-cd ~/.claude/plugins/cache/thedotmack/claude-mem/<version>
-bun install
+curl -s http://127.0.0.1:37777/api/health
 ```
 
-> ⚠️ **This patch is lost on plugin updates.** You'll need to re-apply after each claude-mem version upgrade.
+- Make sure Claude-Mem has already been installed and used from Claude Code.
+- Start a fresh OpenCode session after the worker is healthy.
 
-### Verifying ChromaDB Works
+### OpenCode shows `Worker offline`
 
-```bash
-# Check Chroma server
-curl -s http://127.0.0.1:8000/api/v1/heartbeat
+The plugin will try to launch the worker via `bunx claude-mem start` once on
+plugin load. If that toast still appears:
 
-# Check worker health
-curl -s http://127.0.0.1:37777/api/health
+- 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`.
 
-# Check for sync errors in worker logs
-# Open http://localhost:37777 in browser for the web viewer
-```
+### OpenCode crashes on startup
 
-When working correctly, worker logs should show:
+- Update to a version with deferred TUI access.
+- Ensure there are no `console.log`, `console.warn`, or `console.error` calls in
+  local plugin modifications.
 
-```
-CHROMA_SYNC connected (remote mode, 127.0.0.1:8000)
-```
+### Observations are missing or incomplete
 
-> **ChromaDB is optional.** Without it, claude-mem falls back to SQLite FTS5 full-text search. You lose semantic/vector search but keyword search still works.
+- Ensure the worker API payload uses `contentSessionId`.
+- Be aware that low-value meta tools and Claude-Mem search tools are skipped by
+  design.
+- Very large tool outputs are truncated before storage.
 
----
+### Memory search is unavailable
 
-## Development
+- 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.
 
-After editing source:
+## Development
 
 ```bash
+bun install
 bun run build
-# Restart OpenCode to pick up changes
+bun run lint
+bun run fmt:check
 ```
 
-If using symlink install, changes are picked up after rebuild. If using npm install, bump version and republish.
-
-## Architecture
-
-```
-OpenCode ←→ Plugin (this repo) ←→ Claude-Mem Worker (port 37777) ←→ SQLite + ChromaDB
-```
-
-The plugin is a thin HTTP client. All heavy lifting (LLM processing, storage, search) happens in the worker.
-
-### Hook Mapping (Claude Code → OpenCode)
-
-| Claude Code Hook | OpenCode Hook | Purpose |
-|-----------------|---------------|---------|
-| `SessionStart` → context | `experimental.chat.system.transform` | Inject memory into system prompt (every LLM call, session-level cache) |
-| `UserPromptSubmit` → session-init | `chat.message` | Init session with real user prompt |
-| `PostToolUse` → observation | `tool.execute.after` | Capture tool executions |
-| `Stop` → summarize | `event` (session.idle) | Summarize with real message content |
-| `Stop` → session-complete | `event` (session.idle) | Mark session complete |
-| *(no equivalent)* | `config` + `command.execute.before` | `/memory` command for user-visible context |
-
-### Worker API Endpoints Used
-
-| Method | Endpoint | Purpose |
-|--------|----------|---------|
-| `GET` | `/api/health` | Health check |
-| `GET` | `/api/context/inject?project={name}` | Get formatted context for system prompt |
-| `POST` | `/api/sessions/init` | Initialize session |
-| `POST` | `/api/sessions/observations` | Send tool observation |
-| `POST` | `/api/sessions/summarize` | Trigger summarization |
-| `POST` | `/api/sessions/complete` | Complete session |
-
-## Key Implementation Details
-
-- **Field name**: All worker API calls use `contentSessionId` (not `claudeSessionId`) — using the wrong field name causes silent failures
-- **No console output**: All `console.log/warn/error` removed to avoid corrupting OpenCode TUI
-- **Deferred toast**: `client.tui.showToast()` is deferred to first hook invocation (TUI not ready during plugin init, calling it crashes OpenCode)
-- **Real prompt**: `chat.message` hook extracts actual user input instead of hardcoded "SESSION_START"
-- **Real summarize**: `session.idle` fetches last user/assistant messages via `client.session.messages()` for meaningful summaries
-- **Context caching**: `getCachedContext()` caches context once per session (invalidated on `session.created`) to avoid redundant worker calls
-- **Content-type handling**: Worker returns `text/plain` markdown — `getContext()` checks content-type and uses `response.text()` instead of `response.json()`
-- **Context tag wrapping**: Injected context is wrapped in `<claude-mem-context>` tags so the worker's tag-stripping logic can remove it from observations, preventing circular memory
-- **Circular memory protection**: `tool.execute.after` filters out claude-mem's own MCP tools (`claude-mem_mcp-search_*`) to prevent search results from being re-recorded as observations
-- **`/memory` command**: Registered via `config` hook, handled by `command.execute.before` — displays context as an `ignored: true` message (visible to user, not sent to LLM)
-
-## Troubleshooting
-
-| Symptom | Cause | Fix |
-|---------|-------|-----|
-| No toast on startup | Worker not running | Start Claude Code first, or check `curl http://127.0.0.1:37777/api/health` |
-| "Worker offline" toast | Worker crashed or not started | Restart Claude Code |
-| OpenCode crashes on startup | Plugin calling TUI too early | Update to latest version (deferred toast fix) |
-| TUI display corrupted | console.log in plugin code | Ensure no console output in source |
-| "SESSION_START" in prompts | Old version bug | Update — `session.created` no longer calls sessionInit |
-| Chroma sync failed | Python version or Chroma not running | See [Windows-Specific Setup](#windows-specific-setup) |
-| Observations not saved | Wrong field name | Ensure `contentSessionId` (not `claudeSessionId`) |
+If you edit source code locally, rebuild and restart OpenCode to pick up the new
+plugin bundle.
 
 ## License
 

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,19 @@
 // @bun
 // src/worker-client.ts
+import { existsSync } from "fs";
+import { spawn } from "child_process";
+var HEALTH_TIMEOUT_MS = 1000;
+var AUTOSTART_POLL_INTERVAL_MS = 500;
+var AUTOSTART_POLL_MAX_ATTEMPTS = 16;
+
 class WorkerClient {
   static PORT = 37777;
   static BASE_URL = `http://127.0.0.1:${WorkerClient.PORT}`;
+  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,8 +23,71 @@ 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 {
@@ -98,6 +168,101 @@ class WorkerClient {
 }
 
 // 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",
+  "skill",
+  "slashcommand",
+  "todowrite"
+]);
+var PRIVATE_TAG_REGEX = /<private>[\s\S]*?<\/private>/g;
+var CONTEXT_TAG_REGEX = /<claude-mem-context>[\s\S]*?<\/claude-mem-context>/g;
+function stripTaggedContent(text) {
+  if (!text) {
+    return text;
+  }
+  let result = text;
+  let replacements = 0;
+  while (replacements < MAX_TAG_REPLACEMENTS && PRIVATE_TAG_REGEX.test(result)) {
+    PRIVATE_TAG_REGEX.lastIndex = 0;
+    result = result.replace(PRIVATE_TAG_REGEX, "");
+    replacements++;
+  }
+  PRIVATE_TAG_REGEX.lastIndex = 0;
+  while (replacements < MAX_TAG_REPLACEMENTS && CONTEXT_TAG_REGEX.test(result)) {
+    CONTEXT_TAG_REGEX.lastIndex = 0;
+    result = result.replace(CONTEXT_TAG_REGEX, "");
+    replacements++;
+  }
+  CONTEXT_TAG_REGEX.lastIndex = 0;
+  return result.trim();
+}
+function sanitizeObservationValue(value) {
+  if (typeof value === "string") {
+    return stripTaggedContent(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeObservationValue(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeObservationValue(item)]));
+  }
+  return value;
+}
+function truncateUtf8Bytes(text, maxBytes) {
+  const encoder = new TextEncoder;
+  if (encoder.encode(text).length <= maxBytes) {
+    return text;
+  }
+  const suffix = `
+[truncated]`;
+  const suffixBytes = encoder.encode(suffix).length;
+  const budget = Math.max(maxBytes - suffixBytes, 0);
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    const candidate = text.slice(0, mid);
+    if (encoder.encode(candidate).length <= budget) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return `${text.slice(0, low)}${suffix}`;
+}
+function shouldSkipObservationTool(toolName) {
+  if (!toolName) {
+    return true;
+  }
+  const normalizedName = toolName.toLowerCase();
+  return normalizedName.startsWith("claude-mem_mcp-search_") || META_TOOLS.has(normalizedName);
+}
+function normalizeToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  if (output === undefined || output === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(output);
+  } catch {
+    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();
@@ -122,20 +287,59 @@ 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.text) {
+      return;
+    }
+    if (buf.timer) {
+      clearTimeout(buf.timer);
+      buf.timer = null;
+    }
+    const { text } = buf;
+    buf.text = "";
+    try {
+      const sanitized = truncateUtf8Bytes(stripTaggedContent(text), MAX_OBSERVATION_BYTES);
+      if (sanitized) {
+        await WorkerClient.sendObservation(sessionId, "assistant_message", buf.messageId ? { messageId: buf.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;
@@ -153,56 +357,149 @@ 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 {
     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;
+          }
+          const text = await fetchAssistantMessageText(sessionId, messageId);
+          if (!text) {
+            return;
+          }
+          let buf = assistantBuffers.get(sessionId);
+          if (!buf) {
+            buf = { text: "", messageId: null, timer: null };
+            assistantBuffers.set(sessionId, buf);
+          }
+          buf.text = text;
+          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 WorkerClient.completeSession(sessionId);
+            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) => {
@@ -227,6 +524,25 @@ var ClaudeMemPlugin = async (ctx) => {
           output.system.push(`<claude-mem-context>
 [Claude-Mem] Memory Active. Previous Context:
 ${context}
+</claude-mem-context>`);
+        }
+      } catch {}
+    },
+    "experimental.session.compacting": async (input, output) => {
+      const sessionId = input.sessionID;
+      if (sessionId) {
+        await ensureSessionInit(sessionId);
+      }
+      const isHealthy = await checkWorkerAndToast();
+      if (!isHealthy) {
+        return;
+      }
+      try {
+        const context = await getCachedContext();
+        if (context) {
+          output.context.push(`<claude-mem-context>
+[Claude-Mem] Memory Active. Previous Context:
+${context}
 </claude-mem-context>`);
         }
       } catch {}
@@ -236,12 +552,14 @@ ${context}
       if (!sessionId) {
         return;
       }
-      if (input.tool.startsWith("claude-mem_mcp-search_")) {
+      if (shouldSkipObservationTool(input.tool)) {
         return;
       }
       await ensureSessionInit(sessionId);
       try {
-        await WorkerClient.sendObservation(sessionId, input.tool, input.args || {}, output.output, projectRoot);
+        const sanitizedToolInput = sanitizeObservationValue(input.args || {});
+        const sanitizedToolOutput = truncateUtf8Bytes(stripTaggedContent(normalizeToolOutput(output.output)), MAX_OBSERVATION_BYTES);
+        await WorkerClient.sendObservation(sessionId, input.tool, sanitizedToolInput, sanitizedToolOutput, projectRoot);
       } catch {}
     }
   };

package/dist/worker-client.d.ts

@@ -1,18 +1,41 @@
-/**
- * Worker Client for Claude-Mem
- * Handles communication with the local worker service running on port 37777.
- */
+export type AutoStartResult = 'already-running' | 'started' | 'no-bun' | 'spawn-failed' | 'timeout' | 'skipped';
 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(_projectRoot: string): Promise<boolean>;
+    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`.
+     */
+    private static findBun;
     /**
      * Initialize a session
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ephemushroom/opencode-claude-mem",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "OpenCode plugin for Claude-Mem persistent memory system",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",