opencode-memsearch 0.2.0 → 0.3.0

package/README.md

@@ -10,27 +10,34 @@ This plugin gives your OpenCode agent long-term memory. It automatically summari
 - **Cold-start context** — the last 30 lines of the 2 most recent memory files are injected into the system prompt when a new session starts
 - **Semantic search** — two custom tools (`memsearch_search` and `memsearch_expand`) let the agent search and drill into past memories
 - **Per-project isolation** — memory collections are scoped by project directory
-- **Local embeddings** — uses memsearch's local embedding provider, so no API calls are needed for vector search
+- **Local embeddings** — works with memsearch's ONNX or local embedding providers, so no API keys are needed for vector search
+- **Daemon mode** — optional background daemon keeps the embedding model loaded in memory, reducing search latency from ~5-10s to ~50ms
 - **Memory protocol** — a system prompt directive instructs the agent to check memory at session start and whenever it encounters a topic that might have prior context
 
 ## Prerequisites
 
-You need the `memsearch` CLI installed. The easiest way is via [uv](https://docs.astral.sh/uv/):
+You need the `memsearch` CLI installed with ONNX embeddings. The easiest way is via [uv](https://docs.astral.sh/uv/):
 
 ```bash
 # Install uv (if you don't have it)
 curl -LsSf https://astral.sh/uv/install.sh | sh
 
-# Install memsearch with local embeddings
-uv tool install 'memsearch[local]'
+# Install memsearch with ONNX embeddings (recommended)
+uv tool install 'memsearch[onnx]'
+
+# Configure the ONNX embedding provider
+memsearch config set embedding.provider onnx
 ```
 
 Or install directly with pip:
 
 ```bash
-pip install 'memsearch[local]'
+pip install 'memsearch[onnx]'
+memsearch config set embedding.provider onnx
 ```
 
+The ONNX provider uses the `bge-m3` embedding model locally on your machine — no API keys or network requests needed for vector search. If you prefer a different embedding provider (e.g., OpenAI, a local `all-MiniLM-L6-v2` via `memsearch[local]`, or Ollama), see the [memsearch documentation](https://github.com/nicobako/memsearch) for configuration options.
+
 If `memsearch` is not installed, the plugin's tools will return a clear error message asking the agent to tell you to install it.
 
 ## Install
@@ -92,17 +99,19 @@ You should add `.memsearch/` to your `.gitignore`.
 
 ## Seed script
 
-The repo includes a seed script (`scripts/seed-memories.ts`) that can backfill memory from existing OpenCode sessions. This is useful when first installing the plugin on a project you've already been working on:
+The package includes a seed script that can backfill memory from existing OpenCode sessions. This is useful when first installing the plugin on a project you've already been working on.
+
+The seed script requires [Bun](https://bun.sh/) to run.
 
 ```bash
 # Seed from the last 14 days of sessions (default)
-bun run scripts/seed-memories.ts
+npx opencode-memsearch-seed
 
 # Seed from the last 30 days
-bun run scripts/seed-memories.ts --days 30
+npx opencode-memsearch-seed --days 30
 ```
 
-The script reads directly from the OpenCode SQLite database, summarizes each conversation turn, and writes the results to `.memsearch/memory/`. The seed script respects the same [configuration](#configuration) as the plugin (config file and environment variables).
+Run the script from your project directory. It reads directly from the OpenCode SQLite database, summarizes each conversation turn, and writes the results to `.memsearch/memory/`. The seed script respects the same [configuration](#configuration) as the plugin (config file and environment variables).
 
 ## Configuration
 
@@ -122,7 +131,7 @@ Both files use the same schema. Values from the project config override the glob
 ```json
 {
   "summarization_model": "anthropic/claude-sonnet-4-5",
-  "auto_configure_embedding": true
+  "use_daemon": true
 }
 ```
 
@@ -131,7 +140,7 @@ All fields are optional. The full schema:
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `summarization_model` | `string` | `"anthropic/claude-haiku-4-5"` | The OpenCode model ID used to summarize conversation turns |
-| `auto_configure_embedding` | `boolean` | `true` | Whether the plugin auto-configures memsearch to use local embeddings on startup |
+| `use_daemon` | `boolean` | `true` | Whether to use a background daemon for faster search/index operations |
 
 ### Summarization model
 
@@ -179,47 +188,39 @@ To switch back to local mode:
 memsearch config set milvus.uri "~/.memsearch/milvus.db"
 ```
 
-### Embedding provider
+### Daemon mode
 
-By default, the plugin auto-configures memsearch to use **local embeddings** (`embedding.provider = local`). This is important because memsearch's own default is `openai`, which would require an API key and make network requests for every index and search operation.
+By default, the plugin starts a background daemon process that keeps the memsearch embedding model loaded in memory. This avoids the Python cold-start penalty (~5-10s) on every search, index, or expand operation — reducing latency to ~50ms.
 
-With local embeddings, the `all-MiniLM-L6-v2` model runs on your machine — no API calls needed for vector search.
+The daemon:
+- Starts automatically on session creation
+- Listens on a Unix domain socket at `.memsearch/daemon.sock`
+- Falls back to the CLI transparently if the daemon is unavailable
+- Writes logs to `.memsearch/daemon.log`
+- Stores its PID in `.memsearch/daemon.pid`
 
-To manage the embedding provider yourself (e.g., to use OpenAI embeddings or a custom endpoint), disable auto-configuration:
+To disable the daemon and use the CLI for all operations:
 
 ```json
 {
-  "auto_configure_embedding": false
+  "use_daemon": false
 }
 ```
 
 Or via environment variable:
 
 ```bash
-export MEMSEARCH_AUTO_CONFIGURE_EMBEDDING=false
-```
-
-Then configure memsearch directly:
-
-```bash
-# Example: use OpenAI embeddings
-memsearch config set embedding.provider openai
-memsearch config set embedding.api_key "env:OPENAI_API_KEY"
-
-# Example: use a custom OpenAI-compatible endpoint
-memsearch config set embedding.provider openai
-memsearch config set embedding.base_url http://localhost:11434/v1
-memsearch config set embedding.model nomic-embed-text
+export MEMSEARCH_USE_DAEMON=false
 ```
 
-See the [memsearch documentation](https://github.com/nicobako/memsearch) for all available embedding options.
+The daemon is most beneficial on machines where Python startup is slow (older hardware, CPU-only inference). On fast machines with NVMe storage, the difference may be negligible.
 
 ### Environment variables
 
 | Variable | Description |
 |----------|-------------|
 | `MEMSEARCH_SUMMARIZATION_MODEL` | Override the model used for summarization (takes precedence over config file) |
-| `MEMSEARCH_AUTO_CONFIGURE_EMBEDDING` | Set to `false` or `0` to disable automatic local embedding configuration |
+| `MEMSEARCH_USE_DAEMON` | Set to `false` or `0` to disable the background daemon (uses CLI for all operations) |
 | `MEMSEARCH_DISABLE` | Set to any value to disable the plugin entirely (used internally to prevent recursion during summarization) |
 
 ### Precedence

package/dist/index.js

@@ -1,9 +1,12 @@
 // src/index.ts
 import { tool } from "@opencode-ai/plugin";
 import { createHash } from "crypto";
-import { readdir, readFile, appendFile, mkdir, writeFile, unlink } from "fs/promises";
-import { join, basename, resolve } from "path";
+import { readdir, readFile, appendFile, mkdir, writeFile, unlink, access } from "fs/promises";
+import { join, basename, resolve, dirname } from "path";
 import { tmpdir, homedir } from "os";
+import { createConnection } from "net";
+import { fileURLToPath } from "url";
+var __dirname = "/Users/jdormit/opencode-memsearch/src";
 var DEFAULT_SUMMARIZATION_MODEL = "anthropic/claude-haiku-4-5";
 var GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "memsearch.config.json");
 async function loadJsonConfig(path) {
@@ -23,12 +26,12 @@ async function loadConfig(projectDir) {
 function getSummarizationModel(config) {
   return process.env.MEMSEARCH_SUMMARIZATION_MODEL || config.summarization_model || DEFAULT_SUMMARIZATION_MODEL;
 }
-function shouldAutoConfigureEmbedding(config) {
-  const envVal = process.env.MEMSEARCH_AUTO_CONFIGURE_EMBEDDING;
+function shouldUseDaemon(config) {
+  const envVal = process.env.MEMSEARCH_USE_DAEMON;
   if (envVal !== undefined) {
     return envVal !== "0" && envVal.toLowerCase() !== "false";
   }
-  return config.auto_configure_embedding !== false;
+  return config.use_daemon !== false;
 }
 function deriveCollectionName(directory) {
   const abs = resolve(directory);
@@ -64,21 +67,98 @@ Rules:
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`;
 var TEMP_DIR = join(tmpdir(), "memsearch-plugin");
+function getDaemonScriptPath() {
+  const thisDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+  return join(thisDir, "..", "scripts", "memsearch-daemon.py");
+}
+function getDaemonSocketPath(memsearchDir) {
+  return join(memsearchDir, "daemon.sock");
+}
+function getDaemonPidPath(memsearchDir) {
+  return join(memsearchDir, "daemon.pid");
+}
+function daemonRequest(socketPath, request, timeoutMs = 30000) {
+  return new Promise((resolve2) => {
+    let responded = false;
+    const chunks = [];
+    const timer = setTimeout(() => {
+      if (!responded) {
+        responded = true;
+        sock.destroy();
+        resolve2(null);
+      }
+    }, timeoutMs);
+    const sock = createConnection({ path: socketPath }, () => {
+      sock.end(JSON.stringify(request));
+    });
+    sock.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    sock.on("end", () => {
+      if (responded)
+        return;
+      responded = true;
+      clearTimeout(timer);
+      try {
+        const data = Buffer.concat(chunks).toString("utf-8");
+        resolve2(JSON.parse(data));
+      } catch {
+        resolve2(null);
+      }
+    });
+    sock.on("error", () => {
+      if (responded)
+        return;
+      responded = true;
+      clearTimeout(timer);
+      resolve2(null);
+    });
+  });
+}
+async function isDaemonAlive(socketPath) {
+  const resp = await daemonRequest(socketPath, { cmd: "ping" }, 5000);
+  return resp?.ok === true;
+}
 var memsearchPlugin = async ({ client, $, directory }) => {
   if (process.env.MEMSEARCH_DISABLE) {
     return {};
   }
   const sessions = new Map;
   let memsearchCmd = null;
+  let memsearchPythonPath = null;
   async function detectMemsearch() {
     try {
       await $`which memsearch`.quiet();
       return ["memsearch"];
     } catch {}
+    return null;
+  }
+  async function detectMemsearchPython() {
+    if (memsearchPythonPath)
+      return memsearchPythonPath;
     try {
-      await $`which uvx`.quiet();
-      return ["uvx", "--from", "memsearch[local]", "memsearch"];
+      const memsearchBin = (await $`which memsearch`.quiet().text()).trim();
+      if (memsearchBin) {
+        const content = await readFile(memsearchBin, "utf-8");
+        const firstLine = content.split(`
+`)[0];
+        if (firstLine.startsWith("#!")) {
+          const shebangPath = firstLine.slice(2).trim();
+          try {
+            await $`${shebangPath} -c "import memsearch"`.quiet();
+            memsearchPythonPath = shebangPath;
+            return shebangPath;
+          } catch {}
+        }
+      }
     } catch {}
+    for (const py of ["python3", "python"]) {
+      try {
+        await $`${py} -c "import memsearch"`.quiet();
+        memsearchPythonPath = py;
+        return py;
+      } catch {}
+    }
     return null;
   }
   async function ensureMemsearch() {
@@ -87,7 +167,7 @@ var memsearchPlugin = async ({ client, $, directory }) => {
     memsearchCmd = await detectMemsearch();
     return memsearchCmd;
   }
-  const MEMSEARCH_NOT_FOUND_ERROR = "memsearch is not installed. Tell the user to install it by running: pip install 'memsearch[local]' — or, if they have uv: uv tool install 'memsearch[local]'. See https://github.com/jdormit/opencode-memsearch for details.";
+  const MEMSEARCH_NOT_FOUND_ERROR = "memsearch is not installed. Tell the user to install it by running: uv tool install 'memsearch[onnx]' — or with pip: pip install 'memsearch[onnx]'. See https://github.com/jdormit/opencode-memsearch for details.";
   async function runMemsearch(args, collectionName) {
     const cmd = memsearchCmd;
     if (!cmd)
@@ -109,17 +189,108 @@ var memsearchPlugin = async ({ client, $, directory }) => {
       return "";
     }
   }
-  async function configureLocalEmbedding() {
-    const cmd = memsearchCmd;
-    if (!cmd)
-      return;
-    const provider = await getMemsearchConfig("embedding.provider");
-    if (provider !== "local") {
-      try {
-        await $`${[...cmd, "config", "set", "embedding.provider", "local"]}`.quiet();
-      } catch {}
+  async function startDaemon(memsearchDir, memoryDir, collectionName) {
+    const socketPath = getDaemonSocketPath(memsearchDir);
+    const pidPath = getDaemonPidPath(memsearchDir);
+    if (await isDaemonAlive(socketPath)) {
+      return true;
+    }
+    await stopDaemon(memsearchDir);
+    const pythonPath = await detectMemsearchPython();
+    if (!pythonPath)
+      return false;
+    const daemonScript = getDaemonScriptPath();
+    try {
+      await access(daemonScript);
+    } catch {
+      return false;
+    }
+    try {
+      const logPath = join(memsearchDir, "daemon.log");
+      const proc = Bun.spawn([
+        pythonPath,
+        daemonScript,
+        "--socket",
+        socketPath,
+        "--collection",
+        collectionName,
+        "--paths",
+        memoryDir,
+        "--pid-file",
+        pidPath
+      ], {
+        stdout: Bun.file(logPath),
+        stderr: Bun.file(logPath),
+        stdin: "ignore"
+      });
+      const startTime = Date.now();
+      const maxWaitMs = 60000;
+      while (Date.now() - startTime < maxWaitMs) {
+        await new Promise((r) => setTimeout(r, 500));
+        if (await isDaemonAlive(socketPath)) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
     }
   }
+  async function stopDaemon(memsearchDir) {
+    const socketPath = getDaemonSocketPath(memsearchDir);
+    const pidPath = getDaemonPidPath(memsearchDir);
+    try {
+      await daemonRequest(socketPath, { cmd: "shutdown" }, 3000);
+    } catch {}
+    try {
+      const pidStr = await readFile(pidPath, "utf-8");
+      const pid = parseInt(pidStr.trim(), 10);
+      if (pid) {
+        try {
+          process.kill(pid);
+        } catch {}
+      }
+    } catch {}
+    try {
+      await unlink(socketPath);
+    } catch {}
+    try {
+      await unlink(pidPath);
+    } catch {}
+  }
+  async function daemonSearch(memsearchDir, collectionName, query, topK) {
+    const socketPath = getDaemonSocketPath(memsearchDir);
+    const resp = await daemonRequest(socketPath, {
+      cmd: "search",
+      query,
+      top_k: topK
+    });
+    if (resp?.ok && Array.isArray(resp.results)) {
+      return JSON.stringify(resp.results, null, 2);
+    }
+    return runMemsearch(["search", query, "--top-k", String(topK), "--json-output"], collectionName);
+  }
+  async function daemonExpand(memsearchDir, collectionName, chunkHash) {
+    const socketPath = getDaemonSocketPath(memsearchDir);
+    const resp = await daemonRequest(socketPath, {
+      cmd: "expand",
+      chunk_hash: chunkHash
+    });
+    if (resp?.ok && resp.result) {
+      return JSON.stringify(resp.result, null, 2);
+    }
+    return runMemsearch(["expand", chunkHash, "--json-output"], collectionName);
+  }
+  async function daemonIndex(memsearchDir, collectionName, memoryDir) {
+    const socketPath = getDaemonSocketPath(memsearchDir);
+    const resp = await daemonRequest(socketPath, {
+      cmd: "index",
+      paths: [memoryDir]
+    });
+    if (resp?.ok)
+      return;
+    runMemsearch(["index", memoryDir], collectionName);
+  }
   async function stopWatch(memsearchDir) {
     const pidFile = join(memsearchDir, ".watch.pid");
     try {
@@ -315,9 +486,7 @@ ${tail}
   await ensureMemsearch();
   const pluginConfig = await loadConfig(directory);
   const summarizationModel = getSummarizationModel(pluginConfig);
-  if (memsearchCmd && shouldAutoConfigureEmbedding(pluginConfig)) {
-    await configureLocalEmbedding();
-  }
+  const useDaemon = shouldUseDaemon(pluginConfig);
   return {
     event: async ({ event }) => {
       if (event.type === "session.created") {
@@ -336,15 +505,32 @@ ${tail}
         sessions.set(sessionID, {
           directory: sessionDir,
           memoryDir,
+          memsearchDir,
           collectionName,
           isSummarizing: false,
           lastSummarizedMessageCount: 0,
-          headingWritten: false
+          headingWritten: false,
+          daemonReady: false
         });
-        await startWatch(memoryDir, memsearchDir, collectionName);
-        const milvusUri = await getMemsearchConfig("milvus.uri");
-        if (!milvusUri.startsWith("http") && !milvusUri.startsWith("tcp")) {
-          runMemsearch(["index", memoryDir], collectionName);
+        if (useDaemon && memsearchCmd) {
+          startDaemon(memsearchDir, memoryDir, collectionName).then((ready) => {
+            const state = sessions.get(sessionID);
+            if (state) {
+              state.daemonReady = ready;
+            }
+          });
+        }
+        if (!useDaemon) {
+          await startWatch(memoryDir, memsearchDir, collectionName);
+        }
+        if (!useDaemon) {
+          const milvusUri = await getMemsearchConfig("milvus.uri");
+          if (!milvusUri.startsWith("http") && !milvusUri.startsWith("tcp")) {
+            runMemsearch(["index", memoryDir], collectionName);
+          }
+        } else {
+          const socketPath = getDaemonSocketPath(memsearchDir);
+          daemonRequest(socketPath, { cmd: "index", paths: [memoryDir] }, 30000).catch(() => {});
         }
         const coldStart = await getRecentMemory(memoryDir);
         if (coldStart) {
@@ -383,10 +569,12 @@ The above is recent memory context from past sessions. Use the memsearch_search
             state = {
               directory: sessionDir,
               memoryDir,
+              memsearchDir,
               collectionName,
               isSummarizing: false,
               lastSummarizedMessageCount: 0,
-              headingWritten: false
+              headingWritten: false,
+              daemonReady: false
             };
             sessions.set(sessionID, state);
           } catch {
@@ -451,7 +639,11 @@ ${summary}
 `;
           await appendFile(memoryFile, entry);
           state.lastSummarizedMessageCount = messages.length;
-          runMemsearch(["index", state.memoryDir], state.collectionName);
+          if (useDaemon) {
+            daemonIndex(state.memsearchDir, state.collectionName, state.memoryDir);
+          } else {
+            runMemsearch(["index", state.memoryDir], state.collectionName);
+          }
         } catch {} finally {
           state.isSummarizing = false;
         }
@@ -470,11 +662,28 @@ ${summary}
             return MEMSEARCH_NOT_FOUND_ERROR;
           }
           const collectionName = deriveCollectionName(context.directory);
+          const memsearchDir = join(context.directory, ".memsearch");
+          const topK = args.top_k ?? 5;
+          if (useDaemon) {
+            const raw2 = await daemonSearch(memsearchDir, collectionName, args.query, topK);
+            if (!raw2.trim()) {
+              return "No results found.";
+            }
+            try {
+              const results = JSON.parse(raw2);
+              if (!Array.isArray(results) || results.length === 0) {
+                return "No results found.";
+              }
+              return JSON.stringify(results, null, 2);
+            } catch {
+              return raw2;
+            }
+          }
           const raw = await runMemsearch([
             "search",
             args.query,
             "--top-k",
-            String(args.top_k ?? 5),
+            String(topK),
             "--json-output"
           ], collectionName);
           if (!raw.trim()) {
@@ -502,7 +711,13 @@ ${summary}
             return MEMSEARCH_NOT_FOUND_ERROR;
           }
           const collectionName = deriveCollectionName(context.directory);
-          const raw = await runMemsearch(["expand", args.chunk_hash, "--json-output"], collectionName);
+          const memsearchDir = join(context.directory, ".memsearch");
+          let raw;
+          if (useDaemon) {
+            raw = await daemonExpand(memsearchDir, collectionName, args.chunk_hash);
+          } else {
+            raw = await runMemsearch(["expand", args.chunk_hash, "--json-output"], collectionName);
+          }
           if (!raw.trim()) {
             return "Chunk not found.";
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memsearch",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Persistent cross-session memory for OpenCode, powered by memsearch",
   "type": "module",
   "main": "dist/index.js",
@@ -11,6 +11,9 @@
       "import": "./dist/index.js"
     }
   },
+  "bin": {
+    "opencode-memsearch-seed": "scripts/seed-memories.ts"
+  },
   "files": [
     "dist",
     "scripts"
@@ -44,7 +47,7 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.3.3",
-    "@types/bun": "latest",
+    "@types/bun": "^1.3.11",
     "typescript": "^5.8.0"
   }
 }

package/scripts/memsearch-daemon.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+memsearch-daemon — long-running process that keeps the embedding model loaded.
+
+Serves search/index/expand requests over a Unix domain socket, avoiding the
+~8-11s Python+PyTorch cold-start penalty on every CLI invocation.
+
+Protocol:
+  Client sends a JSON object (terminated by EOF/shutdown), daemon replies
+  with a JSON object.
+
+Commands:
+  {"cmd": "search", "query": "...", "top_k": 5, "source_prefix": null}
+  {"cmd": "index", "paths": ["..."], "force": false}
+  {"cmd": "expand", "chunk_hash": "..."}
+  {"cmd": "ping"}
+  {"cmd": "shutdown"}
+
+Started by the opencode-memsearch plugin on session creation.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import signal
+import sys
+from pathlib import Path
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [memsearch-daemon] %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("memsearch-daemon")
+
+
+def _extract_section(
+    all_lines: list[str],
+    start_line: int,
+    heading_level: int,
+) -> tuple[str, int, int]:
+    """Extract the full section containing the chunk (mirrors CLI logic)."""
+    section_start = start_line - 1
+    if heading_level > 0:
+        for i in range(start_line - 2, -1, -1):
+            line = all_lines[i]
+            if line.startswith("#"):
+                level = len(line) - len(line.lstrip("#"))
+                if level <= heading_level:
+                    section_start = i
+                    break
+
+    section_end = len(all_lines)
+    if heading_level > 0:
+        for i in range(start_line, len(all_lines)):
+            line = all_lines[i]
+            if line.startswith("#"):
+                level = len(line) - len(line.lstrip("#"))
+                if level <= heading_level:
+                    section_end = i
+                    break
+
+    content = "\n".join(all_lines[section_start:section_end])
+    return content, section_start + 1, section_end
+
+
+async def handle_search(ms, params: dict) -> dict:
+    query = params.get("query", "")
+    top_k = params.get("top_k", 5)
+    source_prefix = params.get("source_prefix")
+    results = await ms.search(query, top_k=top_k, source_prefix=source_prefix)
+    return {"ok": True, "results": results}
+
+
+async def handle_index(ms, params: dict) -> dict:
+    paths = params.get("paths", [])
+    force = params.get("force", False)
+    if paths:
+        ms._paths = [str(p) for p in paths]
+    count = await ms.index(force=force)
+    return {"ok": True, "indexed": count}
+
+
+async def handle_expand(ms, params: dict) -> dict:
+    """Expand a chunk — mirrors the CLI expand command's --json-output."""
+    chunk_hash = params.get("chunk_hash", "")
+    if not chunk_hash:
+        return {"ok": False, "error": "chunk_hash is required"}
+
+    escaped = chunk_hash.replace("\\", "\\\\").replace('"', '\\"')
+    chunks = ms.store.query(filter_expr=f'chunk_hash == "{escaped}"')
+    if not chunks:
+        return {"ok": False, "error": f"Chunk not found: {chunk_hash}"}
+
+    chunk = chunks[0]
+    source = chunk["source"]
+    start_line = chunk["start_line"]
+    heading_level = chunk.get("heading_level", 0)
+    heading = chunk.get("heading", "")
+
+    source_path = Path(source)
+    if not source_path.exists():
+        # Fall back to just returning the stored content
+        return {
+            "ok": True,
+            "result": {
+                "chunk_hash": chunk_hash,
+                "source": source,
+                "heading": heading,
+                "start_line": start_line,
+                "end_line": chunk["end_line"],
+                "content": chunk.get("content", ""),
+            },
+        }
+
+    all_lines = source_path.read_text(encoding="utf-8").splitlines()
+    expanded, expanded_start, expanded_end = _extract_section(
+        all_lines, start_line, heading_level
+    )
+
+    anchor_match = re.search(
+        r"<!--\s*session:(\S+)\s+turn:(\S+)\s+transcript:(\S+)\s*-->",
+        expanded,
+    )
+    result: dict = {
+        "chunk_hash": chunk_hash,
+        "source": source,
+        "heading": heading,
+        "start_line": expanded_start,
+        "end_line": expanded_end,
+        "content": expanded,
+    }
+    if anchor_match:
+        result["anchor"] = {
+            "session": anchor_match.group(1),
+            "turn": anchor_match.group(2),
+            "transcript": anchor_match.group(3),
+        }
+
+    return {"ok": True, "result": result}
+
+
+async def handle_client(reader, writer, ms, shutdown_event):
+    try:
+        data = await reader.read(1_048_576)  # 1MB max request
+        if not data:
+            return
+
+        request = json.loads(data.decode("utf-8"))
+        cmd = request.get("cmd")
+
+        if cmd == "search":
+            response = await handle_search(ms, request)
+        elif cmd == "index":
+            response = await handle_index(ms, request)
+        elif cmd == "expand":
+            response = await handle_expand(ms, request)
+        elif cmd == "ping":
+            response = {"ok": True, "msg": "pong"}
+        elif cmd == "shutdown":
+            response = {"ok": True, "msg": "shutting down"}
+            shutdown_event.set()
+        else:
+            response = {"ok": False, "error": f"Unknown command: {cmd}"}
+
+        writer.write(json.dumps(response, default=str).encode("utf-8"))
+        await writer.drain()
+    except Exception as e:
+        try:
+            writer.write(json.dumps({"ok": False, "error": str(e)}).encode("utf-8"))
+            await writer.drain()
+        except Exception:
+            pass
+    finally:
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except Exception:
+            pass
+
+
+async def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="memsearch daemon")
+    parser.add_argument("--socket", required=True, help="Unix socket path")
+    parser.add_argument("--collection", default=None, help="Milvus collection name")
+    parser.add_argument("--paths", nargs="*", default=[], help="Paths to index")
+    parser.add_argument("--pid-file", default=None, help="Write PID to this file")
+    args = parser.parse_args()
+
+    socket_path = args.socket
+
+    # Import memsearch (this is the slow part — loads PyTorch + model)
+    from memsearch.config import resolve_config
+    from memsearch.core import MemSearch
+
+    cfg = resolve_config()
+
+    kwargs: dict = {
+        "embedding_provider": cfg.embedding.provider,
+        "embedding_model": cfg.embedding.model or None,
+        "embedding_batch_size": cfg.embedding.batch_size,
+        "embedding_base_url": cfg.embedding.base_url or None,
+        "embedding_api_key": cfg.embedding.api_key or None,
+        "milvus_uri": cfg.milvus.uri,
+        "milvus_token": cfg.milvus.token or None,
+        "collection": args.collection or cfg.milvus.collection,
+        "max_chunk_size": cfg.chunking.max_chunk_size,
+        "overlap_lines": cfg.chunking.overlap_lines,
+        "reranker_model": cfg.reranker.model,
+    }
+
+    logger.info("Loading embedding model...")
+    ms = MemSearch(args.paths or None, **kwargs)
+    logger.info("Model loaded.")
+
+    # Clean up stale socket
+    if os.path.exists(socket_path):
+        os.unlink(socket_path)
+
+    # Ensure parent directory exists
+    Path(socket_path).parent.mkdir(parents=True, exist_ok=True)
+
+    shutdown_event = asyncio.Event()
+
+    server = await asyncio.start_unix_server(
+        lambda r, w: handle_client(r, w, ms, shutdown_event),
+        path=socket_path,
+    )
+
+    # Write PID file
+    if args.pid_file:
+        Path(args.pid_file).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.pid_file).write_text(str(os.getpid()))
+
+    logger.info("Listening on %s (PID %d)", socket_path, os.getpid())
+
+    # Handle SIGTERM gracefully
+    loop = asyncio.get_event_loop()
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, shutdown_event.set)
+
+    # Wait for shutdown signal
+    await shutdown_event.wait()
+    logger.info("Shutting down...")
+
+    server.close()
+    await server.wait_closed()
+    ms.close()
+
+    # Cleanup
+    if os.path.exists(socket_path):
+        os.unlink(socket_path)
+    if args.pid_file and os.path.exists(args.pid_file):
+        os.unlink(args.pid_file)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

package/scripts/seed-memories.ts

@@ -3,7 +3,9 @@
  * seed-memories.ts — Seed memsearch memory files from recent OpenCode sessions.
  *
  * Usage:
- *   bun run ~/.config/opencode/scripts/seed-memories.ts [--days 14]
+ *   npx opencode-memsearch-seed [--days 14]
+ *
+ * Requires Bun (https://bun.sh/) to run.
  *
  * This script:
  * 1. Reads session + message data directly from the OpenCode SQLite database
@@ -25,8 +27,8 @@ import { $ } from "bun"
 interface PluginConfig {
   /** Model ID used for summarization (e.g. "anthropic/claude-haiku-4-5") */
   summarization_model?: string
-  /** Whether to auto-configure memsearch to use local embeddings (default: true) */
-  auto_configure_embedding?: boolean
+  /** Whether to use the daemon for faster search/index (default: true) */
+  use_daemon?: boolean
 }
 
 const DEFAULT_SUMMARIZATION_MODEL = "anthropic/claude-haiku-4-5"
@@ -313,11 +315,9 @@ async function detectMemsearch(): Promise<string[]> {
     await $`which memsearch`.quiet()
     return ["memsearch"]
   } catch {}
-  try {
-    await $`which uvx`.quiet()
-    return ["uvx", "--from", "memsearch[local]", "memsearch"]
-  } catch {}
-  throw new Error("memsearch not found. Install it with: pip install 'memsearch[local]' or install uv")
+  throw new Error(
+    "memsearch is not installed. Install it by running: uv tool install 'memsearch[onnx]' — or with pip: pip install 'memsearch[onnx]'. See https://github.com/jdormit/opencode-memsearch for details."
+  )
 }
 
 // Summarize a transcript via `opencode run`