opencode-memsearch 0.1.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
@@ -57,7 +64,7 @@ OpenCode will install the npm package automatically on startup.
 When the agent finishes responding (session goes idle), the plugin:
 
 1. Extracts the last conversation turn (user message + agent response)
-2. Summarizes it into 2-6 bullet points using Claude Haiku via `opencode run`
+2. Summarizes it into 2-6 bullet points using an LLM (Claude Haiku by default, [configurable](#summarization-model)) via `opencode run`
 3. Appends the summary to `.memsearch/memory/YYYY-MM-DD.md`
 4. Re-indexes the memory directory into the vector database
 
@@ -92,33 +99,138 @@ 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 with Claude Haiku, and writes the results to `.memsearch/memory/`.
+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
 
-The plugin auto-configures memsearch to use local embeddings. If you want to use a remote Milvus instance instead of the default local database, configure it via the memsearch CLI:
+The plugin can be configured via a JSON config file and/or environment variables. Environment variables take precedence over config file values, and project-level config takes precedence over global config.
+
+### Config file
+
+The plugin looks for config in two locations (highest precedence first):
+
+1. **Project config**: `.memsearch/config.json` in your project root
+2. **Global config**: `~/.config/opencode/memsearch.config.json`
+
+Both files use the same schema. Values from the project config override the global config.
+
+**Example:**
+
+```json
+{
+  "summarization_model": "anthropic/claude-sonnet-4-5",
+  "use_daemon": true
+}
+```
+
+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 |
+| `use_daemon` | `boolean` | `true` | Whether to use a background daemon for faster search/index operations |
+
+### Summarization model
+
+Each conversation turn is summarized by an LLM before being stored. By default, the plugin uses `anthropic/claude-haiku-4-5` — a fast, cheap model that produces good summaries.
+
+To use a different model, set it in your config file:
+
+```json
+{
+  "summarization_model": "anthropic/claude-sonnet-4-5"
+}
+```
+
+Or override it with an environment variable:
+
+```bash
+export MEMSEARCH_SUMMARIZATION_MODEL="openai/gpt-4.1-mini"
+```
+
+The model must be available in your OpenCode configuration (i.e., you must have the provider configured and authenticated). Any model ID that works with `opencode run --model <id>` will work here.
+
+### Milvus storage
+
+The plugin uses [Milvus](https://milvus.io/) (via memsearch) as its vector database. There are two modes:
+
+#### Local mode (default)
+
+By default, memsearch uses **Milvus Lite**, which stores data in a local `.db` file (typically `~/.memsearch/milvus.db`). This requires no server setup — it just works.
+
+In local mode, the plugin re-indexes the memory directory on session start (to pick up any memories written since the last session) and again after each new summary is appended. File locking prevents concurrent access issues, so no background watcher is needed.
+
+#### Remote mode
+
+For concurrent access from multiple sessions or machines, you can point memsearch at a remote Milvus server:
 
 ```bash
 memsearch config set milvus.uri http://localhost:19530
 ```
 
-In remote mode, the plugin starts a file watcher process that automatically re-indexes memory files when they change.
+In remote mode, the plugin starts a **file watcher** process that continuously re-indexes memory files whenever they change. The watcher runs as a background process with its PID stored in `.memsearch/.watch.pid`.
+
+To switch back to local mode:
+
+```bash
+memsearch config set milvus.uri "~/.memsearch/milvus.db"
+```
+
+### Daemon mode
+
+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.
+
+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 disable the daemon and use the CLI for all operations:
+
+```json
+{
+  "use_daemon": false
+}
+```
+
+Or via environment variable:
 
-## Environment variables
+```bash
+export MEMSEARCH_USE_DAEMON=false
+```
+
+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_DISABLE` | Set to any value to disable the plugin (used internally to prevent recursion during summarization) |
+| `MEMSEARCH_SUMMARIZATION_MODEL` | Override the model used for summarization (takes precedence over config file) |
+| `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
+
+Configuration values are resolved in this order (highest precedence first):
+
+1. Environment variables
+2. Project config (`.memsearch/config.json`)
+3. Global config (`~/.config/opencode/memsearch.config.json`)
+4. Built-in defaults
 
 ## License
 

package/dist/index.js

@@ -1,9 +1,38 @@
 // 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 { tmpdir } from "os";
+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) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function loadConfig(projectDir) {
+  const projectPath = join(projectDir, ".memsearch", "config.json");
+  const globalConfig = await loadJsonConfig(GLOBAL_CONFIG_PATH);
+  const projectConfig = await loadJsonConfig(projectPath);
+  return { ...globalConfig, ...projectConfig };
+}
+function getSummarizationModel(config) {
+  return process.env.MEMSEARCH_SUMMARIZATION_MODEL || config.summarization_model || DEFAULT_SUMMARIZATION_MODEL;
+}
+function shouldUseDaemon(config) {
+  const envVal = process.env.MEMSEARCH_USE_DAEMON;
+  if (envVal !== undefined) {
+    return envVal !== "0" && envVal.toLowerCase() !== "false";
+  }
+  return config.use_daemon !== false;
+}
 function deriveCollectionName(directory) {
   const abs = resolve(directory);
   const sanitized = basename(abs).toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 40);
@@ -37,23 +66,99 @@ Rules:
 - Do NOT continue the conversation after the bullet points
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`;
-var HAIKU_MODEL = "anthropic/claude-haiku-4-5";
 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() {
@@ -62,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)
@@ -84,16 +189,107 @@ 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");
@@ -202,12 +398,12 @@ ${tail}
     return lines.join(`
 `);
   }
-  async function summarizeTranscript(transcript, sessionID, turnIdx) {
+  async function summarizeTranscript(transcript, sessionID, turnIdx, model) {
     const tempFile = join(TEMP_DIR, `turn-${sessionID}-${turnIdx}.txt`);
     await mkdir(TEMP_DIR, { recursive: true });
     await writeFile(tempFile, transcript);
     try {
-      const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} --format json ${SUMMARIZE_PROMPT}`.env({ ...process.env, MEMSEARCH_DISABLE: "1" }).nothrow().quiet().text();
+      const rawOutput = await $`opencode run -f ${tempFile} --model ${model} --format json ${SUMMARIZE_PROMPT}`.env({ ...process.env, MEMSEARCH_DISABLE: "1" }).nothrow().quiet().text();
       let summarizationSessionID;
       const textParts = [];
       for (const line of rawOutput.split(`
@@ -288,9 +484,9 @@ ${tail}
 `);
   }
   await ensureMemsearch();
-  if (memsearchCmd) {
-    await configureLocalEmbedding();
-  }
+  const pluginConfig = await loadConfig(directory);
+  const summarizationModel = getSummarizationModel(pluginConfig);
+  const useDaemon = shouldUseDaemon(pluginConfig);
   return {
     event: async ({ event }) => {
       if (event.type === "session.created") {
@@ -309,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) {
@@ -356,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 {
@@ -398,7 +613,7 @@ The above is recent memory context from past sessions. Use the memsearch_search
             return;
           let summary;
           try {
-            summary = await summarizeTranscript(transcript, sessionID, state.lastSummarizedMessageCount);
+            summary = await summarizeTranscript(transcript, sessionID, state.lastSummarizedMessageCount, summarizationModel);
           } catch {
             summary = "";
           }
@@ -424,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;
         }
@@ -443,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()) {
@@ -475,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.1.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,23 +3,61 @@
  * 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
  * 2. For each session, formats each conversation turn as a transcript
- * 3. Summarizes each turn via `opencode run` with claude-haiku (one process per turn)
+ * 3. Summarizes each turn via `opencode run` (model is configurable, see README)
  * 4. Writes summaries to .memsearch/memory/YYYY-MM-DD.md files per project
  * 5. Indexes all memory files with memsearch
  */
 
 import { Database } from "bun:sqlite"
 import { createHash } from "crypto"
-import { appendFile, mkdir, writeFile, unlink } from "fs/promises"
+import { appendFile, mkdir, readFile, writeFile, unlink } from "fs/promises"
 import { join, basename, resolve } from "path"
 import { homedir, tmpdir } from "os"
 import { $ } from "bun"
 
+// --- Configuration ---
+
+interface PluginConfig {
+  /** Model ID used for summarization (e.g. "anthropic/claude-haiku-4-5") */
+  summarization_model?: string
+  /** Whether to use the daemon for faster search/index (default: true) */
+  use_daemon?: boolean
+}
+
+const DEFAULT_SUMMARIZATION_MODEL = "anthropic/claude-haiku-4-5"
+const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "memsearch.config.json")
+
+async function loadJsonConfig(path: string): Promise<Partial<PluginConfig>> {
+  try {
+    const content = await readFile(path, "utf-8")
+    return JSON.parse(content)
+  } catch {
+    return {}
+  }
+}
+
+async function loadConfig(projectDir: string): Promise<PluginConfig> {
+  const projectPath = join(projectDir, ".memsearch", "config.json")
+  const globalConfig = await loadJsonConfig(GLOBAL_CONFIG_PATH)
+  const projectConfig = await loadJsonConfig(projectPath)
+  return { ...globalConfig, ...projectConfig }
+}
+
+function getSummarizationModel(config: PluginConfig): string {
+  return (
+    process.env.MEMSEARCH_SUMMARIZATION_MODEL ||
+    config.summarization_model ||
+    DEFAULT_SUMMARIZATION_MODEL
+  )
+}
+
 // --- Config ---
 
 const SUMMARIZE_PROMPT = `You are a third-person note-taker. The attached file contains a transcript of ONE conversation turn between a human and an AI coding agent. Tool calls are labeled [Tool Call] and their results [Tool Result] or [Tool Error].
@@ -39,8 +77,6 @@ Rules:
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`
 
-const HAIKU_MODEL = "anthropic/claude-haiku-4-5"
-
 const DB_PATH = join(homedir(), ".local", "share", "opencode", "opencode.db")
 const TEMP_DIR = join(tmpdir(), "memsearch-seed")
 
@@ -279,22 +315,20 @@ 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`
-async function summarizeWithOpencode(transcript: string, tempFile: string): Promise<string> {
+async function summarizeWithOpencode(transcript: string, tempFile: string, model: string): Promise<string> {
   // Write transcript to temp file
   await writeFile(tempFile, transcript)
 
   try {
     // Disable all plugins during summarization to avoid memsearch plugin
     // interfering with the LLM output (e.g. injecting "[memsearch] Memory available")
-    const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} ${SUMMARIZE_PROMPT}`
+    const rawOutput = await $`opencode run -f ${tempFile} --model ${model} ${SUMMARIZE_PROMPT}`
       .env({ ...process.env, OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: [] }) })
       .nothrow()
       .quiet()
@@ -331,6 +365,11 @@ async function main() {
   const memsearchCmd = await detectMemsearch()
   console.log(`Using memsearch: ${memsearchCmd.join(" ")}`)
 
+  // Load config from cwd (the project root the seed script is run from)
+  const config = await loadConfig(process.cwd())
+  const summarizationModel = getSummarizationModel(config)
+  console.log(`Summarization model: ${summarizationModel}`)
+
   await mkdir(TEMP_DIR, { recursive: true })
 
   // Open database (read-only)
@@ -426,7 +465,7 @@ async function main() {
         const tempFile = join(TEMP_DIR, `turn-${sessionNum}-${turnIdx}.txt`)
         let summary = ""
         try {
-          summary = await summarizeWithOpencode(transcript, tempFile)
+          summary = await summarizeWithOpencode(transcript, tempFile, summarizationModel)
           if (summary) totalSummarized++
         } catch {
           // LLM failed