@zilliz/memsearch-opencode 0.1.0

package/README.md

@@ -0,0 +1,137 @@
+# memsearch OpenCode Plugin
+
+Semantic memory search for [OpenCode](https://github.com/anomalyco/opencode) — gives your AI assistant persistent memory across sessions with zero user intervention.
+
+## Features
+
+- **Auto-capture**: Summarizes each conversation turn and saves to daily `.md` files
+- **Semantic search**: Hybrid search (BM25 + dense vectors + RRF) via Milvus
+- **Three-layer recall**: Search → Expand → Transcript (progressive detail)
+- **Cold-start context**: Injects recent memories into new sessions automatically
+- **Per-project isolation**: Each project gets its own Milvus collection
+- **ONNX embeddings**: CPU-only bge-m3 model, no API key required
+
+## Quick Start
+
+### Prerequisites
+
+```bash
+# Install memsearch with ONNX embeddings
+uv tool install 'memsearch[onnx]'
+# or: pip install 'memsearch[onnx]'
+```
+
+### Install
+
+```bash
+# Clone the repo (if you haven't already)
+git clone https://github.com/zc277584121/memsearch.git
+cd memsearch
+
+# Run the installer
+bash plugins/opencode/install.sh
+```
+
+### Manual Install
+
+```bash
+# 1. Symlink the plugin
+mkdir -p ~/.config/opencode/plugins
+ln -sf /path/to/memsearch/plugins/opencode/index.ts ~/.config/opencode/plugins/memsearch.ts
+
+# 2. Symlink the skill (optional, for !memory-recall)
+mkdir -p ~/.agents/skills
+ln -sf /path/to/memsearch/plugins/opencode/skills/memory-recall ~/.agents/skills/memory-recall
+```
+
+### npm Install (coming soon)
+
+```json
+// In ~/.config/opencode/opencode.json
+{
+  "plugin": ["memsearch-opencode"]
+}
+```
+
+## Architecture
+
+```
+OpenCode Session
+    ├── chat.message hook ──→ Detect turn completion
+    │                              │
+    │                              ├── Extract last turn from SQLite
+    │                              ├── Summarize via LLM (third-person notes)
+    │                              └── Append to .memsearch/memory/YYYY-MM-DD.md
+    │                                     │
+    │                                     └── memsearch index (background)
+    │
+    ├── system.transform hook ──→ Inject recent memories
+    │
+    └── Tools
+        ├── memory_search ──→ memsearch search (hybrid BM25+dense)
+        ├── memory_get    ──→ memsearch expand (full context)
+        └── memory_transcript ──→ parse-transcript.py (SQLite reader)
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `memory_search` | Semantic search over past memories. Returns ranked chunks. |
+| `memory_get` | Expand a chunk hash to see the full markdown section. |
+| `memory_transcript` | Read original conversation from OpenCode SQLite DB. |
+
+## Memory Files
+
+Memory is stored as markdown in `<project>/.memsearch/memory/`:
+
+```
+.memsearch/
+└── memory/
+    ├── 2026-03-25.md
+    └── 2026-03-26.md
+```
+
+Each file contains timestamped entries with bullet-point summaries:
+
+```markdown
+# 2026-03-26
+
+## Session 14:30
+
+### 14:30
+<!-- session:ses_abc123 source:opencode-sqlite -->
+- User asked about the authentication flow.
+- Assistant explained the OAuth2 implementation in auth.ts.
+- Assistant modified the token refresh logic in refresh.ts.
+```
+
+## Configuration
+
+The plugin uses ONNX embeddings by default (no API key needed). To use a different provider:
+
+```bash
+memsearch config set embedding.provider openai
+# Set the API key in your environment
+export OPENAI_API_KEY=sk-...
+```
+
+## How It Works
+
+1. **Capture**: After each conversation turn, the plugin extracts the user+assistant exchange, summarizes it via LLM, and appends to a daily markdown file.
+
+2. **Index**: The markdown files are indexed by memsearch into a Milvus collection (Milvus Lite by default, runs in-process).
+
+3. **Recall**: When the assistant needs historical context, it calls `memory_search` to find relevant chunks. Results can be expanded with `memory_get` or drilled into with `memory_transcript`.
+
+4. **Cold-start**: At session start, recent memory bullets are injected into the system prompt so the assistant has immediate context.
+
+## Differences from Other Plugins
+
+| Feature | Claude Code | OpenCode | OpenClaw |
+|---------|-------------|----------|----------|
+| Session storage | JSONL | SQLite | JSONL |
+| Hook system | Shell scripts | TypeScript hooks | JS API |
+| Summarizer | claude -p --model haiku | opencode prompt | openclaw agent |
+| Context injection | SessionStart hook | system.transform | before_agent_start |
+| Skill context | context: fork | N/A (no fork) | N/A |

package/index.ts

@@ -0,0 +1,327 @@
+/**
+ * memsearch OpenCode plugin — semantic memory search across sessions.
+ *
+ * Registers:
+ * - memory_search tool: semantic search over past memories
+ * - memory_get tool: expand a chunk to full context
+ * - memory_transcript tool: parse original conversation from OpenCode SQLite
+ * - experimental.chat.system.transform hook: inject recent memories as context
+ *
+ * Auto-capture is handled by a background Python daemon (capture-daemon.py)
+ * that polls the OpenCode SQLite database for completed turns.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { execSync, exec, spawnSync } from "node:child_process";
+import {
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect the memsearch CLI command.
+ * Checks: PATH -> ~/.local/bin/uvx -> uvx in PATH.
+ */
+function detectMemsearchCmd(): string {
+  const home = process.env.HOME || "";
+
+  try {
+    const r = spawnSync("which", ["memsearch"], { stdio: "pipe" });
+    if (r.status === 0) return "memsearch";
+  } catch { /* ignore */ }
+
+  const uvxPath = join(home, ".local", "bin", "uvx");
+  if (existsSync(uvxPath)) {
+    return `${uvxPath} --from 'memsearch[onnx]' memsearch`;
+  }
+
+  try {
+    const r = spawnSync("which", ["uvx"], { stdio: "pipe" });
+    if (r.status === 0) return "uvx --from 'memsearch[onnx]' memsearch";
+  } catch { /* ignore */ }
+
+  return "memsearch";
+}
+
+/** Derive a per-project Milvus collection name via the shared script. */
+function deriveCollectionName(projectDir: string): string {
+  const script = join(PLUGIN_DIR, "scripts", "derive-collection.sh");
+  try {
+    return execSync(`bash "${script}" "${projectDir}"`, {
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return "ms_opencode_default";
+  }
+}
+
+/**
+ * Read the tail of the N most recent daily .md files for cold-start context.
+ */
+function getRecentMemories(
+  memDir: string,
+  count = 2,
+  tailLines = 15
+): string {
+  if (!existsSync(memDir)) return "";
+
+  const files = readdirSync(memDir)
+    .filter((f) => f.endsWith(".md"))
+    .sort()
+    .slice(-count);
+
+  if (files.length === 0) return "";
+
+  const bullets: string[] = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(memDir, file), "utf-8");
+      const lines = content.split("\n").slice(-tailLines);
+      const fileBullets = lines.filter((l) => l.startsWith("- ") || l.startsWith("[Human]") || l.startsWith("[Assistant]"));
+      if (fileBullets.length > 0) {
+        bullets.push(`[${file}]`, ...fileBullets);
+      }
+    } catch { /* skip */ }
+  }
+
+  if (bullets.length === 0) {
+    return `You have ${files.length} past memory file(s). Use the memory_search tool when the user's question could benefit from historical context.`;
+  }
+
+  return `Recent memories (use memory_search for full search):\n${bullets.join("\n")}`;
+}
+
+/** Shell-escape a string for safe use inside single quotes. */
+function shellEscape(s: string): string {
+  return s.replace(/'/g, "'\\''");
+}
+
+/**
+ * Start the capture daemon as a background process.
+ * The daemon polls OpenCode's SQLite for completed turns and writes to daily .md files.
+ */
+function startCaptureDaemon(
+  projectDir: string,
+  collectionName: string,
+  memsearchCmd: string
+): void {
+  const pidFile = join(projectDir, ".memsearch", ".capture.pid");
+  const daemonScript = join(PLUGIN_DIR, "scripts", "capture-daemon.py");
+
+  // Check if daemon is already running
+  if (existsSync(pidFile)) {
+    try {
+      const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+      if (pid > 0) {
+        // Check if process is still alive
+        try {
+          process.kill(pid, 0);
+          return; // Already running
+        } catch {
+          // Process is dead, clean up stale PID file
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Start daemon in background
+  exec(
+    `python3 "${daemonScript}" "${projectDir}" "${collectionName}" ` +
+      `--memsearch-cmd "${shellEscape(memsearchCmd)}" --poll-interval 10 &`,
+    {
+      timeout: 5000,
+      env: { ...process.env, MEMSEARCH_NO_WATCH: "1" },
+    },
+    () => { /* ignore */ }
+  );
+}
+
+/**
+ * Stop the capture daemon.
+ */
+function stopCaptureDaemon(projectDir: string): void {
+  const pidFile = join(projectDir, ".memsearch", ".capture.pid");
+  if (existsSync(pidFile)) {
+    try {
+      const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+      if (pid > 0) {
+        try { process.kill(pid, "SIGTERM"); } catch { /* ignore */ }
+      }
+    } catch { /* ignore */ }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Plugin entry
+// ---------------------------------------------------------------------------
+
+const MemsearchPlugin: Plugin = async ({ project, directory, worktree }) => {
+  // worktree can be "/" for global projects — use directory instead
+  const projectDir = (worktree && worktree !== "/") ? worktree : (directory || process.cwd());
+  const memsearchCmd = detectMemsearchCmd();
+  const collectionName = deriveCollectionName(projectDir);
+  const memsearchDir = join(projectDir, ".memsearch");
+  const memoryDir = join(memsearchDir, "memory");
+  const home = process.env.HOME || "~";
+
+  // Skip capture/recall in child processes to prevent recursion
+  const isChildProcess = !!process.env.MEMSEARCH_NO_WATCH;
+  const autoCapture = !isChildProcess;
+  const autoRecall = !isChildProcess;
+
+  // Ensure default config (onnx provider) at startup
+  try {
+    const configFile = join(home, ".memsearch", "config.toml");
+    const localConfig = join(projectDir, ".memsearch.toml");
+    if (!existsSync(configFile) && !existsSync(localConfig)) {
+      try {
+        execSync(`${memsearchCmd} config set embedding.provider onnx`, {
+          timeout: 5000,
+          stdio: "ignore",
+        });
+      } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+
+  // Run initial index in background
+  if (existsSync(memoryDir)) {
+    exec(
+      `${memsearchCmd} index '${shellEscape(memoryDir)}' ` +
+        `--collection ${collectionName}`,
+      { timeout: 120000 },
+      () => { /* ignore */ }
+    );
+  }
+
+  // Start capture daemon for auto-capture
+  if (autoCapture) {
+    startCaptureDaemon(projectDir, collectionName, memsearchCmd);
+  }
+
+  return {
+    // ----- Tools -----
+    tool: {
+      memory_search: tool({
+        description:
+          "Search past conversation memories using memsearch semantic search. " +
+          "Returns relevant chunks from past sessions, including dates, " +
+          "topics discussed, and code referenced. Powered by Milvus hybrid " +
+          "search (BM25 + dense vectors + RRF reranking).",
+        args: {
+          query: tool.schema.string().describe("Search query — describe what you want to find"),
+          top_k: tool.schema.number().optional().describe("Number of results to return (default: 5)"),
+        },
+        async execute(args, context) {
+          // Use context.directory for the actual session directory (may differ from init)
+          const dir = context?.directory || projectDir;
+          const col = dir !== projectDir ? deriveCollectionName(dir) : collectionName;
+          const memDir = join(dir, ".memsearch", "memory");
+          // Ensure daemon is running for current directory
+          if (autoCapture) startCaptureDaemon(dir, col, memsearchCmd);
+          const topK = args.top_k || 5;
+          try {
+            const result = spawnSync(
+              "bash",
+              [
+                "-c",
+                `${memsearchCmd} search '${shellEscape(args.query)}' ` +
+                  `--top-k ${topK} --json-output --collection ${col}`,
+              ],
+              { encoding: "utf-8", timeout: 30000 }
+            );
+            return result.stdout || result.stderr || "No results found.";
+          } catch (e: any) {
+            return `Search failed: ${e.message}`;
+          }
+        },
+      }),
+
+      memory_get: tool({
+        description:
+          "Expand a memory chunk to see the full markdown section with " +
+          "surrounding context. Use after memory_search to get details " +
+          "about a specific result.",
+        args: {
+          chunk_hash: tool.schema.string().describe("The chunk_hash from a search result to expand"),
+        },
+        async execute(args, context) {
+          const dir = context?.directory || projectDir;
+          const col = dir !== projectDir ? deriveCollectionName(dir) : collectionName;
+          if (autoCapture) startCaptureDaemon(dir, col, memsearchCmd);
+          try {
+            const result = spawnSync(
+              "bash",
+              [
+                "-c",
+                `${memsearchCmd} expand '${shellEscape(args.chunk_hash)}' ` +
+                  `--collection ${col}`,
+              ],
+              { encoding: "utf-8", timeout: 15000 }
+            );
+            return result.stdout || result.stderr || "No content found.";
+          } catch (e: any) {
+            return `Expand failed: ${e.message}`;
+          }
+        },
+      }),
+
+      memory_transcript: tool({
+        description:
+          "Retrieve the original conversation from a past OpenCode session. " +
+          "Use after memory_get when the expanded result contains a session anchor " +
+          "(<!-- session:ID source:opencode-sqlite -->). Returns the formatted " +
+          "dialogue with [Human] and [Assistant] labels.",
+        args: {
+          session_id: tool.schema.string().describe("The session ID from the anchor comment"),
+          limit: tool.schema.number().optional().describe("Max number of messages to return (default: 20)"),
+        },
+        async execute(args, context) {
+          const dir = context?.directory || projectDir;
+          const col = dir !== projectDir ? deriveCollectionName(dir) : collectionName;
+          if (autoCapture) startCaptureDaemon(dir, col, memsearchCmd);
+          try {
+            const scriptPath = join(PLUGIN_DIR, "scripts", "parse-transcript.py");
+            const result = spawnSync(
+              "python3",
+              [scriptPath, args.session_id, ...(args.limit ? ["--limit", String(args.limit)] : [])],
+              { encoding: "utf-8", timeout: 15000 }
+            );
+            return result.stdout?.trim() || result.stderr || "No transcript content found.";
+          } catch (e: any) {
+            return `Transcript parse failed: ${e.message}`;
+          }
+        },
+      }),
+    },
+
+    // ----- Hook: system prompt transform — inject recent memories -----
+    ...(autoRecall
+      ? {
+          "experimental.chat.system.transform": async (_input: any, output: any) => {
+            try {
+              const context = getRecentMemories(memoryDir);
+              if (context) {
+                output.system.push(
+                  `[memsearch] Memory available. You have access to memory_search, memory_get, and memory_transcript tools for recalling past sessions.\n\n${context}`
+                );
+              }
+            } catch { /* ignore */ }
+          },
+        }
+      : {}),
+  };
+};
+
+export default MemsearchPlugin;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@zilliz/memsearch-opencode",
+  "version": "0.1.0",
+  "description": "memsearch plugin for OpenCode — semantic memory search across sessions",
+  "type": "module",
+  "main": "index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "scripts/",
+    "skills/",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "memsearch",
+    "memory",
+    "semantic-search",
+    "milvus"
+  ],
+  "author": "memsearch contributors",
+  "license": "MIT",
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zilliztech/memsearch",
+    "directory": "plugins/opencode"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.3.2"
+  }
+}

package/scripts/capture-daemon.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""Background daemon that watches OpenCode SQLite for completed turns and captures them.
+
+Usage:
+  capture-daemon.py <project_dir> <collection_name> [--memsearch-cmd CMD]
+
+The daemon polls the OpenCode SQLite database for new completed messages,
+extracts the last turn, summarizes it as bullet points, and writes to
+<project_dir>/.memsearch/memory/YYYY-MM-DD.md.
+
+It also triggers memsearch indexing after writing.
+"""
+
+import sqlite3
+import json
+import sys
+import os
+import time
+import shutil
+import subprocess
+import argparse
+import signal
+from datetime import datetime
+from pathlib import Path
+
+
+def get_small_model():
+    """Read small_model from opencode.json config (fallback to model, then empty)."""
+    config_paths = [
+        os.path.expanduser("~/.config/opencode/opencode.json"),
+        "opencode.json",
+    ]
+    for p in config_paths:
+        if os.path.exists(p):
+            try:
+                with open(p) as f:
+                    cfg = json.load(f)
+                return cfg.get("small_model", cfg.get("model", ""))
+            except Exception:
+                pass
+    return ""
+
+
+def ensure_isolated_config():
+    """Create isolated config dir without plugins/ to prevent recursion."""
+    isolated = "/tmp/opencode-memsearch-summarize/opencode"
+    os.makedirs(isolated, exist_ok=True)
+    # Copy opencode.json (provider config) but NOT plugins/
+    src = os.path.expanduser("~/.config/opencode/opencode.json")
+    dst = os.path.join(isolated, "opencode.json")
+    if os.path.exists(src) and not os.path.exists(dst):
+        shutil.copy2(src, dst)
+    return os.path.dirname(isolated)  # /tmp/opencode-memsearch-summarize
+
+
+def summarize_with_llm(turn_text, small_model):
+    """Summarize using opencode run in isolated env (no plugins -> no recursion)."""
+    # Keep the instruction short and put it AFTER the transcript to avoid
+    # the LLM treating the instruction itself as the conversation content.
+    # Clear delimiters (===) separate the transcript from the task.
+    full_prompt = (
+        f"===TRANSCRIPT START===\n"
+        f"{turn_text}\n"
+        f"===TRANSCRIPT END===\n\n"
+        f"Summarize the transcript above as 2-6 third-person bullet points (each starting with '- '). "
+        f"Write 'User asked/did...' and 'OpenCode replied/did...'. "
+        f"Be specific (file names, tools, outcomes). "
+        f"Same language as the human. "
+        f"Output ONLY bullet points, nothing else."
+    )
+    isolated_dir = ensure_isolated_config()
+
+    cmd = ["opencode", "run"]
+    if small_model:
+        cmd += ["-m", small_model]
+    cmd.append(full_prompt)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            env={
+                **os.environ,
+                "XDG_CONFIG_HOME": isolated_dir,
+                "XDG_DATA_HOME": os.path.join(isolated_dir, "data"),
+                "MEMSEARCH_NO_WATCH": "1",
+            },
+            capture_output=True, text=True, timeout=30,
+        )
+        output = result.stdout.strip()
+        # Extract bullet points (skip any opencode run header lines)
+        lines = output.split("\n")
+        bullets = [l for l in lines if l.strip().startswith("- ")]
+        if bullets:
+            return "\n".join(bullets)
+    except Exception:
+        pass
+
+    return None  # fallback to raw text
+
+
+def get_db_path():
+    """Find the OpenCode SQLite database."""
+    default = os.path.expanduser("~/.local/share/opencode/opencode.db")
+    if os.path.exists(default):
+        return default
+    xdg_data = os.environ.get("XDG_DATA_HOME", "")
+    if xdg_data:
+        alt = os.path.join(xdg_data, "opencode", "opencode.db")
+        if os.path.exists(alt):
+            return alt
+    return default
+
+
+def get_new_completed_turns(conn, project_dir, last_msg_time):
+    """Get new user+assistant pairs from sessions in the project directory.
+
+    Returns a list of (session_id, turn_text, max_msg_time) tuples for
+    turns whose messages are newer than last_msg_time.
+    """
+    # Find all sessions for this project directory
+    sessions = conn.execute(
+        """
+        SELECT s.id FROM session s
+        WHERE s.directory = ?
+        ORDER BY s.time_updated DESC
+        LIMIT 5
+        """,
+        (project_dir,),
+    ).fetchall()
+
+    if not sessions:
+        # Fallback: match by basename
+        sessions = conn.execute(
+            """
+            SELECT s.id FROM session s
+            WHERE s.directory LIKE ?
+            ORDER BY s.time_updated DESC
+            LIMIT 5
+            """,
+            (f"%{os.path.basename(project_dir)}%",),
+        ).fetchall()
+
+    results = []
+    for (session_id,) in sessions:
+        # Get messages newer than last_msg_time, in pairs (user + assistant)
+        messages = conn.execute(
+            """
+            SELECT m.id, m.data, m.time_created
+            FROM message m
+            WHERE m.session_id = ? AND m.time_created > ?
+            ORDER BY m.time_created ASC
+            """,
+            (session_id, last_msg_time),
+        ).fetchall()
+
+        # Group into user+assistant pairs
+        i = 0
+        while i < len(messages):
+            msg_data = json.loads(messages[i][1])
+            role = msg_data.get("role", "")
+            msg_time = messages[i][2]
+
+            if role == "user":
+                user_text = _extract_msg_text(conn, messages[i][0], messages[i][1])
+                assistant_text = ""
+                # Look for following assistant message
+                if i + 1 < len(messages):
+                    next_data = json.loads(messages[i + 1][1])
+                    if next_data.get("role") == "assistant":
+                        assistant_text = _extract_msg_text(conn, messages[i + 1][0], messages[i + 1][1])
+                        msg_time = messages[i + 1][2]
+                        i += 1
+
+                if user_text and len(user_text) > 5:
+                    turn = f"[Human]: {user_text[:2000]}"
+                    if assistant_text:
+                        turn += f"\n\n[Assistant]: {assistant_text[:2000]}"
+                    results.append((session_id, turn, msg_time))
+            i += 1
+
+    return results
+
+
+def _extract_msg_text(conn, msg_id, msg_json):
+    """Extract readable text from a message's parts."""
+    parts = conn.execute(
+        "SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC",
+        (msg_id,),
+    ).fetchall()
+
+    text_parts = []
+    for (part_json,) in parts:
+        part_data = json.loads(part_json)
+        if part_data.get("type") == "text" and part_data.get("text"):
+            if not part_data.get("synthetic"):
+                text_parts.append(part_data["text"].strip())
+        elif part_data.get("type") == "tool" and part_data.get("state", {}).get("status") == "completed":
+            tool_name = part_data.get("tool", "unknown")
+            tool_input = part_data.get("state", {}).get("input", {})
+            hint = ""
+            if isinstance(tool_input, dict):
+                if "command" in tool_input:
+                    hint = f" `{tool_input['command'][:80]}`"
+                elif "path" in tool_input:
+                    hint = f" {tool_input['path']}"
+            text_parts.append(f"[Tool: {tool_name}{hint}]")
+
+    return "\n".join(text_parts)
+
+
+def write_capture(memory_dir, turn_text, session_id):
+    """Write a captured turn to the daily memory file."""
+    os.makedirs(memory_dir, exist_ok=True)
+
+    today = datetime.now().strftime("%Y-%m-%d")
+    now = datetime.now().strftime("%H:%M")
+    memory_file = os.path.join(memory_dir, f"{today}.md")
+
+    if not os.path.exists(memory_file):
+        with open(memory_file, "w") as f:
+            f.write(f"# {today}\n\n## Session {now}\n\n")
+
+    anchor = f"<!-- session:{session_id} source:opencode-sqlite -->\n" if session_id else ""
+    entry = f"### {now}\n{anchor}{turn_text}\n\n"
+
+    with open(memory_file, "a") as f:
+        f.write(entry)
+
+    return memory_file
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Capture daemon for OpenCode sessions")
+    parser.add_argument("project_dir", help="Project directory")
+    parser.add_argument("collection_name", help="Milvus collection name")
+    parser.add_argument("--memsearch-cmd", default="memsearch", help="memsearch command")
+    parser.add_argument("--poll-interval", type=int, default=10, help="Poll interval in seconds")
+    args = parser.parse_args()
+
+    db_path = get_db_path()
+    if not os.path.exists(db_path):
+        print(f"OpenCode database not found at {db_path}", file=sys.stderr)
+        sys.exit(1)
+
+    memory_dir = os.path.join(args.project_dir, ".memsearch", "memory")
+    pid_file = os.path.join(args.project_dir, ".memsearch", ".capture.pid")
+
+    # Write PID file
+    os.makedirs(os.path.dirname(pid_file), exist_ok=True)
+    with open(pid_file, "w") as f:
+        f.write(str(os.getpid()))
+
+    # Clean up on exit
+    def cleanup(signum=None, frame=None):
+        try:
+            os.remove(pid_file)
+        except OSError:
+            pass
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, cleanup)
+    signal.signal(signal.SIGINT, cleanup)
+
+    small_model = get_small_model()
+    # Track by message time — persisted to disk so daemon restarts don't re-capture
+    state_file = os.path.join(args.project_dir, ".memsearch", ".last_msg_time")
+    last_msg_time = 0
+    if os.path.exists(state_file):
+        try:
+            last_msg_time = int(open(state_file).read().strip())
+        except (ValueError, OSError):
+            pass
+
+    while True:
+        try:
+            conn = sqlite3.connect(db_path, timeout=5)
+
+            new_turns = get_new_completed_turns(conn, args.project_dir, last_msg_time)
+            for session_id, turn_text, msg_time in new_turns:
+                if turn_text and len(turn_text) > 10:
+                    # Summarize with LLM, fallback to raw text
+                    summary = summarize_with_llm(turn_text, small_model)
+                    write_capture(memory_dir, summary if summary else turn_text, session_id)
+                    if msg_time > last_msg_time:
+                        last_msg_time = msg_time
+                        try:
+                            with open(state_file, "w") as sf:
+                                sf.write(str(last_msg_time))
+                        except OSError:
+                            pass
+
+            if new_turns:
+                # Index in background after batch capture
+                os.system(
+                    f"{args.memsearch_cmd} index '{memory_dir}' "
+                    f"--collection {args.collection_name} &"
+                )
+
+            conn.close()
+        except Exception:
+            pass
+
+        time.sleep(args.poll_interval)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/derive-collection.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Derive a unique Milvus collection name from a project directory path.
+# Used by hooks (via common.sh) and skill (via SKILL.md ! syntax).
+#
+# Usage: derive-collection.sh [project_dir]
+#   If no argument given, uses pwd.
+#
+# Output: ms_<sanitized_basename>_<8char_sha256>
+#   e.g. /home/user/my-app → ms_my_app_a1b2c3d4
+
+set -euo pipefail
+
+PROJECT_DIR="${1:-$(pwd)}"
+
+# Resolve to absolute path (realpath preferred, cd fallback, raw last resort)
+if realpath -m "$PROJECT_DIR" &>/dev/null 2>&1; then
+  PROJECT_DIR="$(realpath -m "$PROJECT_DIR")"
+elif [ -d "$PROJECT_DIR" ]; then
+  PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd)"
+else
+  # If directory doesn't exist and no realpath, ensure it starts with /
+  case "$PROJECT_DIR" in
+    /*) ;; # already absolute
+    *)  PROJECT_DIR="$(pwd)/$PROJECT_DIR" ;;
+  esac
+fi
+
+# Extract basename and sanitize:
+# - lowercase
+# - replace non-alphanumeric with underscore
+# - collapse consecutive underscores
+# - trim leading/trailing underscores
+# - truncate to 40 chars
+sanitized=$(basename "$PROJECT_DIR" \
+  | tr '[:upper:]' '[:lower:]' \
+  | sed 's/[^a-z0-9]/_/g' \
+  | sed 's/__*/_/g' \
+  | sed 's/^_//;s/_$//' \
+  | cut -c1-40)
+
+# Compute 8-char SHA-256 hash of the full absolute path
+if command -v sha256sum &>/dev/null; then
+  hash=$(printf '%s' "$PROJECT_DIR" | sha256sum | cut -c1-8)
+elif command -v shasum &>/dev/null; then
+  hash=$(printf '%s' "$PROJECT_DIR" | shasum -a 256 | cut -c1-8)
+else
+  hash=$(python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:8])" "$PROJECT_DIR")
+fi
+
+echo "ms_${sanitized}_${hash}"

package/scripts/parse-transcript.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Parse OpenCode SQLite transcript for a given session.
+
+Usage:
+  parse-transcript.py <session_id> [--limit N] [--last-turn]
+
+Options:
+  --limit N       Max number of messages to return (default: 20)
+  --last-turn     Only return the last user+assistant turn (for capture)
+
+The script reads from the OpenCode SQLite database at:
+  ~/.local/share/opencode/opencode.db
+"""
+
+import sqlite3
+import json
+import sys
+import os
+import argparse
+
+
+def get_db_path():
+    """Find the OpenCode SQLite database."""
+    # Default path
+    default = os.path.expanduser("~/.local/share/opencode/opencode.db")
+    if os.path.exists(default):
+        return default
+
+    # Check XDG_DATA_HOME
+    xdg_data = os.environ.get("XDG_DATA_HOME", "")
+    if xdg_data:
+        alt = os.path.join(xdg_data, "opencode", "opencode.db")
+        if os.path.exists(alt):
+            return alt
+
+    return default
+
+
+def parse_session(session_id, limit=20, last_turn=False):
+    """Parse messages and parts for a session, formatted as [Human]/[Assistant]."""
+    db_path = get_db_path()
+    if not os.path.exists(db_path):
+        print(f"Error: OpenCode database not found at {db_path}", file=sys.stderr)
+        sys.exit(1)
+
+    conn = sqlite3.connect(db_path, timeout=5)
+    conn.row_factory = sqlite3.Row
+
+    try:
+        # Get messages for the session, ordered by creation time
+        messages = conn.execute(
+            """
+            SELECT id, data, time_created
+            FROM message
+            WHERE session_id = ?
+            ORDER BY time_created ASC
+            """,
+            (session_id,),
+        ).fetchall()
+
+        if not messages:
+            print(f"No messages found for session {session_id}")
+            return
+
+        # Build structured turns
+        turns = []
+        for msg in messages:
+            msg_data = json.loads(msg["data"])
+            role = msg_data.get("role", "unknown")
+            msg_id = msg["id"]
+
+            # Get parts for this message
+            parts = conn.execute(
+                """
+                SELECT id, data, time_created
+                FROM part
+                WHERE message_id = ?
+                ORDER BY time_created ASC
+                """,
+                (msg_id,),
+            ).fetchall()
+
+            text_parts = []
+            tool_parts = []
+
+            for part in parts:
+                part_data = json.loads(part["data"])
+                part_type = part_data.get("type", "")
+
+                if part_type == "text" and part_data.get("text"):
+                    text = part_data["text"].strip()
+                    # Skip synthetic parts (e.g. "The following tool was executed by the user")
+                    if part_data.get("synthetic"):
+                        continue
+                    if text:
+                        text_parts.append(text)
+
+                elif part_type == "tool" and part_data.get("state"):
+                    state = part_data["state"]
+                    tool_name = part_data.get("tool", "unknown")
+                    status = state.get("status", "unknown")
+
+                    if status == "completed":
+                        tool_input = state.get("input", {})
+                        tool_output = state.get("output", "")
+                        # Truncate long output
+                        if isinstance(tool_output, str) and len(tool_output) > 300:
+                            tool_output = tool_output[:300] + "..."
+
+                        input_summary = ""
+                        if isinstance(tool_input, dict):
+                            # Summarize common tool inputs
+                            if "command" in tool_input:
+                                input_summary = f" `{tool_input['command']}`"
+                            elif "path" in tool_input:
+                                input_summary = f" {tool_input['path']}"
+                            elif "query" in tool_input:
+                                input_summary = f" '{tool_input['query']}'"
+
+                        tool_parts.append(
+                            f"[Tool: {tool_name}{input_summary}] {tool_output}"
+                        )
+                    elif status == "error":
+                        error = state.get("error", "unknown error")
+                        tool_parts.append(f"[Tool: {tool_name}] Error: {error}")
+
+            # Combine text and tool parts
+            combined = "\n".join(text_parts)
+            if tool_parts:
+                combined += "\n" + "\n".join(tool_parts)
+
+            if combined.strip():
+                turns.append({"role": role, "text": combined.strip()})
+
+        if not turns:
+            print(f"No meaningful content found for session {session_id}")
+            return
+
+        # If --last-turn, extract only the last user+assistant exchange
+        if last_turn:
+            turns = extract_last_turn(turns)
+
+        # Apply limit
+        if limit and not last_turn:
+            turns = turns[-limit:]
+
+        # Format output
+        for turn in turns:
+            role_label = "[Human]" if turn["role"] == "user" else "[Assistant]"
+            text = turn["text"]
+            # Truncate very long turns
+            if len(text) > 3000:
+                text = text[:3000] + "\n..."
+            print(f"{role_label}: {text}\n")
+
+    finally:
+        conn.close()
+
+
+def extract_last_turn(turns):
+    """Extract the last user+assistant pair from turns."""
+    if not turns:
+        return []
+
+    # Find the last user message (threshold 5 chars to support CJK)
+    last_user_idx = -1
+    for i in range(len(turns) - 1, -1, -1):
+        if turns[i]["role"] == "user" and len(turns[i]["text"]) > 5:
+            last_user_idx = i
+            break
+
+    if last_user_idx == -1:
+        return []
+
+    return turns[last_user_idx:]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Parse OpenCode session transcript")
+    parser.add_argument("session_id", help="Session ID to parse")
+    parser.add_argument("--limit", type=int, default=20, help="Max messages to return")
+    parser.add_argument(
+        "--last-turn",
+        action="store_true",
+        help="Only return the last user+assistant turn",
+    )
+    args = parser.parse_args()
+
+    parse_session(args.session_id, limit=args.limit, last_turn=args.last_turn)
+
+
+if __name__ == "__main__":
+    main()

package/skills/memory-recall/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: memory-recall
+description: "Search and recall relevant memories from past sessions. Use when the user's question could benefit from historical context, past decisions, debugging notes, previous conversations, or project knowledge."
+allowed-tools: Bash
+---
+
+You are a memory retrieval agent for memsearch. Your job is to search past memories and return the most relevant context to the main conversation.
+
+## Project Collection
+
+Collection: !`bash __INSTALL_DIR__/scripts/derive-collection.sh`
+
+## Your Task
+
+Search for memories relevant to: $ARGUMENTS
+
+## Steps
+
+1. **Search**: Run `memsearch search "<query>" --top-k 5 --json-output --collection <collection name above>` to find relevant chunks.
+   - If `memsearch` is not found, try `uvx memsearch` instead.
+   - Choose a search query that captures the core intent of the user's question.
+
+2. **Evaluate**: Look at the search results. Skip chunks that are clearly irrelevant or too generic.
+
+3. **Expand**: For each relevant result, run `memsearch expand <chunk_hash> --collection <collection name above>` to get the full markdown section with surrounding context.
+
+4. **Deep drill (optional)**: If an expanded chunk contains a session anchor (`<!-- session:ID source:opencode-sqlite -->`), and the original conversation seems critical, run:
+   ```
+   python3 __INSTALL_DIR__/scripts/parse-transcript.py <session_id> --limit 10
+   ```
+   to retrieve the original conversation turns from the OpenCode SQLite database.
+
+5. **Return results**: Output a curated summary of the most relevant memories. Be concise — only include information that is genuinely useful for the user's current question.
+
+## Output Format
+
+Organize by relevance. For each memory include:
+- The key information (decisions, patterns, solutions, context)
+- Source reference (file name, date) for traceability
+
+If nothing relevant is found, simply say "No relevant memories found."