@zilliz/memsearch-opencode 0.3.2 → 0.3.4

package/index.ts

@@ -93,7 +93,7 @@ function getRecentMemories(
     try {
       const content = readFileSync(join(memDir, file), "utf-8");
       const lines = content.split("\n")
-        .filter((l) => /^#{2,4}\s/.test(l) || l.startsWith("- ") || l.startsWith("[Human]") || l.startsWith("[Assistant]"))
+        .filter((l) => /^#{2,4}\s/.test(l) || l.startsWith("- ") || l.startsWith("[User]") || l.startsWith("[Assistant]"))
         .slice(0, maxLinesPerFile);
       if (lines.length > 0) {
         summary.push(`[${file}]`, ...lines);
@@ -301,7 +301,7 @@ const MemsearchPlugin: Plugin = async ({ project, directory, worktree }) => {
           "Retrieve the original conversation from a past OpenCode session. " +
           "Use after memory_get when the expanded result contains a session anchor " +
           "(<!-- session:ID turn:ID db:PATH -->). Returns the formatted " +
-          "dialogue with [Human] and [Assistant] labels. When turn_id is present, " +
+          "dialogue with [User] and [Assistant] labels. When turn_id is present, " +
           "the tool returns the target turn plus surrounding context.",
         args: {
           session_id: tool.schema.string().describe("The session ID from the anchor comment"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zilliz/memsearch-opencode",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "memsearch plugin for OpenCode — semantic memory search across sessions",
   "type": "module",
   "main": "index.ts",

package/prompts/summarize.txt

@@ -1,14 +1,15 @@
-You are a third-person note-taker. You will receive a transcript of ONE conversation turn between a human and {{AGENT_NAME}}.
+You are a third-person note-taker. You will receive a transcript of ONE conversation turn between User and {{AGENT_NAME}}.
 
-Your job is to record what happened as factual third-person notes. You are an EXTERNAL OBSERVER — you are NOT {{AGENT_NAME}}, NOT an assistant. Do NOT answer the human's question, do NOT give suggestions, do NOT offer help. ONLY record what occurred.
+Your job is to record what happened as factual third-person notes. You are an EXTERNAL OBSERVER — you are NOT {{AGENT_NAME}}, NOT an assistant. Do NOT answer User's question, do NOT give suggestions, do NOT offer help. ONLY record what occurred.
 
-Output 2-6 bullet points, each starting with '- '. NOTHING else.
+Output 2-10 bullet points, each starting with '- '. NOTHING else.
+Mandatory language rule: write every bullet in the same primary language as the [User] text. If User mixes languages, use the dominant user-facing language.
 
 Rules:
-- Write in third person: 'User asked...', '{{AGENT_NAME}} read file X', '{{AGENT_NAME}} ran command Y'
-- First bullet: what the user asked or wanted (one sentence)
-- Remaining bullets: what was done — tools called, files read/edited, commands run, key findings
-- Be specific: mention file names, function names, tool names, and concrete outcomes
-- Do NOT answer the human's question yourself — just note what was discussed
+- Write in third person and call the user 'User'
+- First bullet: what User asked or wanted (one sentence)
+- Remaining bullets: what was done, found, changed, configured, tested, explained, decided, or could not be completed
+- Be specific when useful: mention important files read or edited, searches or research performed, refactors, commands or tests run, key findings, and concrete outcomes
+- Prefer the final user-visible outcome over low-level transcript mechanics
+- Do NOT answer User's question yourself — just note what was discussed
 - Do NOT add any text before or after the bullet points
-- Write in the same language as the human's message in the transcript

package/scripts/capture-daemon.py

@@ -21,7 +21,6 @@ import json
 import os
 import re
 import shlex
-import shutil
 import signal
 import sqlite3
 import subprocess
@@ -57,21 +56,238 @@ def split_memsearch_cmd(memsearch_cmd: str) -> list[str]:
     return shlex.split(memsearch_cmd)
 
 
-def get_small_model() -> str:
-    """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, encoding="utf-8") as f:
-                    cfg = json.load(f)
-                return cfg.get("small_model", cfg.get("model", ""))
-            except Exception:
-                pass
-    return ""
+def _strip_jsonc(text: str) -> str:
+    """Remove JSONC comments and trailing commas while preserving string contents."""
+    out: list[str] = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+    while i < len(text):
+        char = text[i]
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+        if in_string:
+            out.append(char)
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == string_quote:
+                in_string = False
+            i += 1
+            continue
+        if char in {'"', "'"}:
+            in_string = True
+            string_quote = char
+            out.append(char)
+            i += 1
+            continue
+        if char == "/" and nxt == "/":
+            i += 2
+            while i < len(text) and text[i] not in "\r\n":
+                i += 1
+            continue
+        if char == "/" and nxt == "*":
+            i += 2
+            while i + 1 < len(text) and not (text[i] == "*" and text[i + 1] == "/"):
+                i += 1
+            i += 2
+            continue
+        out.append(char)
+        i += 1
+
+    without_comments = "".join(out)
+    out = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+    while i < len(without_comments):
+        char = without_comments[i]
+        if in_string:
+            out.append(char)
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == string_quote:
+                in_string = False
+            i += 1
+            continue
+        if char in {'"', "'"}:
+            in_string = True
+            string_quote = char
+            out.append(char)
+            i += 1
+            continue
+        if char == ",":
+            j = i + 1
+            while j < len(without_comments) and without_comments[j].isspace():
+                j += 1
+            if j < len(without_comments) and without_comments[j] in "]}":
+                i += 1
+                continue
+        out.append(char)
+        i += 1
+    return "".join(out)
+
+
+def _read_jsonc_config(path: Path) -> dict:
+    try:
+        data = json.loads(_strip_jsonc(path.read_text(encoding="utf-8")))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _deep_merge_config(base: dict, override: dict) -> dict:
+    result = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(result.get(key), dict):
+            result[key] = _deep_merge_config(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _rewrite_relative_file_refs(value, config_dir: Path):
+    if isinstance(value, dict):
+        return {key: _rewrite_relative_file_refs(item, config_dir) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_rewrite_relative_file_refs(item, config_dir) for item in value]
+    if not isinstance(value, str):
+        return value
+
+    def replace(match: re.Match[str]) -> str:
+        file_ref = match.group(1)
+        if file_ref.startswith("~/") or os.path.isabs(file_ref):
+            return match.group(0)
+        return "{file:" + str((config_dir / file_ref).resolve()) + "}"
+
+    return re.sub(r"\{file:([^}]+)\}", replace, value)
+
+
+def _load_opencode_config_file(path: Path) -> dict:
+    cfg = _read_jsonc_config(path)
+    if not cfg:
+        return {}
+    return _rewrite_relative_file_refs(cfg, path.parent)
+
+
+def _opencode_global_config_dir() -> Path:
+    xdg_config = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        return Path(xdg_config).expanduser() / "opencode"
+    return Path.home() / ".config" / "opencode"
+
+
+def _env_flag_enabled(name: str) -> bool:
+    return os.environ.get(name, "").strip().lower() in {"1", "true", "yes"}
+
+
+def _opencode_project_config_files(project_dir: Path) -> list[Path]:
+    found: list[Path] = []
+    current = project_dir.resolve()
+    while True:
+        for filename in ("opencode.jsonc", "opencode.json"):
+            candidate = current / filename
+            if candidate.is_file():
+                found.append(candidate)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return list(reversed(found))
+
+
+def _opencode_directory_config_files(project_dir: Path) -> list[Path]:
+    dirs: list[Path] = []
+    if not _env_flag_enabled("OPENCODE_DISABLE_PROJECT_CONFIG"):
+        current = project_dir.resolve()
+        while True:
+            local = current / ".opencode"
+            if local.is_dir() and local not in dirs:
+                dirs.append(local)
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+    home_local = Path.home() / ".opencode"
+    if home_local.is_dir() and home_local not in dirs:
+        dirs.append(home_local)
+
+    env_dir = os.environ.get("OPENCODE_CONFIG_DIR", "").strip()
+    if env_dir:
+        config_dir = Path(env_dir).expanduser()
+        if config_dir not in dirs:
+            dirs.append(config_dir)
+
+    files: list[Path] = []
+    for directory in dirs:
+        for filename in ("opencode.json", "opencode.jsonc"):
+            candidate = directory / filename
+            if candidate.is_file():
+                files.append(candidate)
+    return files
+
+
+def _iter_opencode_config_files(project_dir: str | os.PathLike[str] | None = None) -> list[Path]:
+    project = Path(project_dir or os.getcwd()).expanduser().resolve()
+    files: list[Path] = []
+
+    global_dir = _opencode_global_config_dir()
+    for filename in ("config.json", "opencode.json", "opencode.jsonc"):
+        candidate = global_dir / filename
+        if candidate.is_file():
+            files.append(candidate)
+
+    env_config = os.environ.get("OPENCODE_CONFIG", "").strip()
+    if env_config:
+        candidate = Path(env_config).expanduser()
+        if candidate.is_file():
+            files.append(candidate)
+
+    if not _env_flag_enabled("OPENCODE_DISABLE_PROJECT_CONFIG"):
+        files.extend(_opencode_project_config_files(project))
+
+    files.extend(_opencode_directory_config_files(project))
+    return files
+
+
+def load_opencode_config(project_dir: str | os.PathLike[str] | None = None) -> dict:
+    """Load local OpenCode config sources in OpenCode-compatible precedence order."""
+    merged: dict = {}
+    for path in _iter_opencode_config_files(project_dir):
+        merged = _deep_merge_config(merged, _load_opencode_config_file(path))
+
+    content = os.environ.get("OPENCODE_CONFIG_CONTENT")
+    if content:
+        content_dir = Path(project_dir or os.getcwd()).expanduser().resolve()
+        cfg = _rewrite_relative_file_refs(_read_jsonc_config_from_text(content), content_dir)
+        merged = _deep_merge_config(merged, cfg)
+    return merged
+
+
+def _read_jsonc_config_from_text(text: str) -> dict:
+    try:
+        data = json.loads(_strip_jsonc(text))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _sanitize_opencode_config(cfg: dict) -> dict:
+    sanitized = dict(cfg)
+    for key in ("plugin", "plugins", "plugin_origins"):
+        sanitized.pop(key, None)
+    return sanitized
+
+
+def get_small_model(project_dir: str | os.PathLike[str] | None = None) -> str:
+    """Read small_model from OpenCode config, falling back to model."""
+    cfg = load_opencode_config(project_dir)
+    return str(cfg.get("small_model", cfg.get("model", "")) or "")
 
 
 def get_plugin_summarize_model(memsearch_cmd: str | None = None) -> str:
@@ -122,19 +338,19 @@ def get_plugin_summarize_enabled(memsearch_cmd: str | None = None) -> bool:
         return True
 
 
-def ensure_isolated_config() -> str:
+def ensure_isolated_config(project_dir: str | os.PathLike[str] | None = None) -> str:
     """Create isolated config dir without plugins/ to prevent recursion."""
-    isolated = os.path.expanduser("~/.codex/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.islink(dst) or (os.path.lexists(dst) and not os.path.isfile(dst)):
-        with contextlib.suppress(OSError):
-            os.remove(dst)
-    if os.path.exists(src) and not os.path.exists(dst):
-        shutil.copy2(src, dst)
-    return os.path.dirname(isolated)
+    root = Path.home() / ".codex" / "tmp" / "opencode-memsearch-summarize"
+    isolated = root / "opencode"
+    isolated.mkdir(parents=True, exist_ok=True)
+    for filename in ("config.json", "opencode.json", "opencode.jsonc"):
+        stale = isolated / filename
+        if stale.is_symlink() or stale.is_file():
+            stale.unlink(missing_ok=True)
+    cfg = _sanitize_opencode_config(load_opencode_config(project_dir))
+    if cfg:
+        (isolated / "opencode.json").write_text(json.dumps(cfg, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    return str(root)
 
 
 def _load_summarize_prompt(agent_name: str, memsearch_cmd: str | None = None) -> str:
@@ -164,11 +380,19 @@ def _load_summarize_prompt(agent_name: str, memsearch_cmd: str | None = None) ->
     # Inline fallback
     return (
         "You are a third-person note-taker. Summarize the transcript as "
-        "2-6 bullet points. Write in third person. Output ONLY bullet points."
+        "2-10 bullet points. Write in third person. Do NOT answer User's question. "
+        "Mandatory language rule: write every bullet in the same primary language as the [User] text. "
+        "If User mixes languages, use the dominant user-facing language. "
+        "Output ONLY bullet points."
     )
 
 
-def summarize_with_llm(turn_text: str, small_model: str, memsearch_cmd: str | None = None) -> str | None:
+def summarize_with_llm(
+    turn_text: str,
+    small_model: str,
+    memsearch_cmd: str | None = None,
+    project_dir: str | os.PathLike[str] | None = None,
+) -> str | None:
     """Summarize using configured provider routing."""
     if not get_plugin_summarize_enabled(memsearch_cmd):
         return None
@@ -199,7 +423,7 @@ def summarize_with_llm(turn_text: str, small_model: str, memsearch_cmd: str | No
         return None
 
     # Native path: summarize using opencode run in isolated env (no plugins -> no recursion).
-    isolated_dir = ensure_isolated_config()
+    isolated_dir = ensure_isolated_config(project_dir)
 
     summarize_model = get_plugin_summarize_model(memsearch_cmd) or small_model
     cmd = ["opencode", "run"]
@@ -212,6 +436,10 @@ def summarize_with_llm(turn_text: str, small_model: str, memsearch_cmd: str | No
             cmd,
             env={
                 **os.environ,
+                "OPENCODE_CONFIG": "",
+                "OPENCODE_CONFIG_DIR": "",
+                "OPENCODE_CONFIG_CONTENT": "",
+                "OPENCODE_DISABLE_PROJECT_CONFIG": "true",
                 "XDG_CONFIG_HOME": isolated_dir,
                 "XDG_DATA_HOME": os.path.join(isolated_dir, "data"),
                 "MEMSEARCH_NO_WATCH": "1",
@@ -488,7 +716,8 @@ def capture_session_turns(
         if not capture_exists(memory_dir, session_id, turn.turn_id):
             if not get_plugin_summarize_enabled(memsearch_cmd):
                 continue
-            summary = summarize_with_llm(turn_text, small_model, memsearch_cmd)
+            project_dir = Path(memory_dir).resolve().parent.parent
+            summary = summarize_with_llm(turn_text, small_model, memsearch_cmd, project_dir)
             write_capture(
                 memory_dir,
                 summary if summary else turn_text,
@@ -535,7 +764,7 @@ def main() -> None:
     signal.signal(signal.SIGTERM, cleanup)
     signal.signal(signal.SIGINT, cleanup)
 
-    small_model = get_small_model()
+    small_model = get_small_model(args.project_dir)
     turn_db = open_turn_db(args.project_dir)
     tail_turn_cache: dict[str, TailTurnObservation] = {}
 

package/scripts/maintenance-runner.py

@@ -12,6 +12,7 @@ import argparse
 import contextlib
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -26,6 +27,233 @@ DEFAULT_NATIVE_MODELS = {
 }
 
 
+def _strip_jsonc(text: str) -> str:
+    """Remove JSONC comments and trailing commas while preserving string contents."""
+    out: list[str] = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+    while i < len(text):
+        char = text[i]
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+        if in_string:
+            out.append(char)
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == string_quote:
+                in_string = False
+            i += 1
+            continue
+        if char in {'"', "'"}:
+            in_string = True
+            string_quote = char
+            out.append(char)
+            i += 1
+            continue
+        if char == "/" and nxt == "/":
+            i += 2
+            while i < len(text) and text[i] not in "\r\n":
+                i += 1
+            continue
+        if char == "/" and nxt == "*":
+            i += 2
+            while i + 1 < len(text) and not (text[i] == "*" and text[i + 1] == "/"):
+                i += 1
+            i += 2
+            continue
+        out.append(char)
+        i += 1
+
+    without_comments = "".join(out)
+    out = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+    while i < len(without_comments):
+        char = without_comments[i]
+        if in_string:
+            out.append(char)
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == string_quote:
+                in_string = False
+            i += 1
+            continue
+        if char in {'"', "'"}:
+            in_string = True
+            string_quote = char
+            out.append(char)
+            i += 1
+            continue
+        if char == ",":
+            j = i + 1
+            while j < len(without_comments) and without_comments[j].isspace():
+                j += 1
+            if j < len(without_comments) and without_comments[j] in "]}":
+                i += 1
+                continue
+        out.append(char)
+        i += 1
+    return "".join(out)
+
+
+def _read_jsonc_config_from_text(text: str) -> dict:
+    try:
+        data = json.loads(_strip_jsonc(text))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _read_jsonc_config(path: Path) -> dict:
+    try:
+        return _read_jsonc_config_from_text(path.read_text(encoding="utf-8"))
+    except OSError:
+        return {}
+
+
+def _deep_merge_config(base: dict, override: dict) -> dict:
+    result = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(result.get(key), dict):
+            result[key] = _deep_merge_config(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _rewrite_relative_file_refs(value, config_dir: Path):
+    if isinstance(value, dict):
+        return {key: _rewrite_relative_file_refs(item, config_dir) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_rewrite_relative_file_refs(item, config_dir) for item in value]
+    if not isinstance(value, str):
+        return value
+
+    def replace(match: re.Match[str]) -> str:
+        file_ref = match.group(1)
+        if file_ref.startswith("~/") or os.path.isabs(file_ref):
+            return match.group(0)
+        return "{file:" + str((config_dir / file_ref).resolve()) + "}"
+
+    return re.sub(r"\{file:([^}]+)\}", replace, value)
+
+
+def _load_opencode_config_file(path: Path) -> dict:
+    cfg = _read_jsonc_config(path)
+    if not cfg:
+        return {}
+    return _rewrite_relative_file_refs(cfg, path.parent)
+
+
+def _opencode_global_config_dir() -> Path:
+    xdg_config = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        return Path(xdg_config).expanduser() / "opencode"
+    return Path.home() / ".config" / "opencode"
+
+
+def _env_flag_enabled(name: str) -> bool:
+    return os.environ.get(name, "").strip().lower() in {"1", "true", "yes"}
+
+
+def _opencode_project_config_files(project_dir: Path) -> list[Path]:
+    found: list[Path] = []
+    current = project_dir.resolve()
+    while True:
+        for filename in ("opencode.jsonc", "opencode.json"):
+            candidate = current / filename
+            if candidate.is_file():
+                found.append(candidate)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return list(reversed(found))
+
+
+def _opencode_directory_config_files(project_dir: Path) -> list[Path]:
+    dirs: list[Path] = []
+    if not _env_flag_enabled("OPENCODE_DISABLE_PROJECT_CONFIG"):
+        current = project_dir.resolve()
+        while True:
+            local = current / ".opencode"
+            if local.is_dir() and local not in dirs:
+                dirs.append(local)
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+    home_local = Path.home() / ".opencode"
+    if home_local.is_dir() and home_local not in dirs:
+        dirs.append(home_local)
+
+    env_dir = os.environ.get("OPENCODE_CONFIG_DIR", "").strip()
+    if env_dir:
+        config_dir = Path(env_dir).expanduser()
+        if config_dir not in dirs:
+            dirs.append(config_dir)
+
+    files: list[Path] = []
+    for directory in dirs:
+        for filename in ("opencode.json", "opencode.jsonc"):
+            candidate = directory / filename
+            if candidate.is_file():
+                files.append(candidate)
+    return files
+
+
+def _iter_opencode_config_files(project_dir: str | os.PathLike[str] | None = None) -> list[Path]:
+    project = Path(project_dir or os.getcwd()).expanduser().resolve()
+    files: list[Path] = []
+
+    global_dir = _opencode_global_config_dir()
+    for filename in ("config.json", "opencode.json", "opencode.jsonc"):
+        candidate = global_dir / filename
+        if candidate.is_file():
+            files.append(candidate)
+
+    env_config = os.environ.get("OPENCODE_CONFIG", "").strip()
+    if env_config:
+        candidate = Path(env_config).expanduser()
+        if candidate.is_file():
+            files.append(candidate)
+
+    if not _env_flag_enabled("OPENCODE_DISABLE_PROJECT_CONFIG"):
+        files.extend(_opencode_project_config_files(project))
+
+    files.extend(_opencode_directory_config_files(project))
+    return files
+
+
+def load_opencode_config(project_dir: str | os.PathLike[str] | None = None) -> dict:
+    """Load local OpenCode config sources in OpenCode-compatible precedence order."""
+    merged: dict = {}
+    for path in _iter_opencode_config_files(project_dir):
+        merged = _deep_merge_config(merged, _load_opencode_config_file(path))
+
+    content = os.environ.get("OPENCODE_CONFIG_CONTENT")
+    if content:
+        content_dir = Path(project_dir or os.getcwd()).expanduser().resolve()
+        cfg = _rewrite_relative_file_refs(_read_jsonc_config_from_text(content), content_dir)
+        merged = _deep_merge_config(merged, cfg)
+    return merged
+
+
+def _sanitize_opencode_config(cfg: dict) -> dict:
+    sanitized = dict(cfg)
+    for key in ("plugin", "plugins", "plugin_origins"):
+        sanitized.pop(key, None)
+    return sanitized
+
+
 def run_command(cmd: list[str], *, env: dict[str, str], cwd: Path, timeout: int) -> str:
     result = subprocess.run(
         cmd,
@@ -54,14 +282,19 @@ def extract_task_json_output(output: str) -> str:
     return output
 
 
-def ensure_opencode_isolated_config() -> Path:
+def ensure_opencode_isolated_config(project_dir: str | os.PathLike[str] | None = None) -> Path:
     home = Path.home()
-    isolated = home / ".codex" / "tmp" / "opencode-memsearch-maintenance" / "opencode"
+    root = home / ".codex" / "tmp" / "opencode-memsearch-maintenance"
+    isolated = root / "opencode"
     isolated.mkdir(parents=True, exist_ok=True)
-    src = home / ".config" / "opencode" / "opencode.json"
-    if src.is_file():
-        shutil.copy2(src, isolated / "opencode.json")
-    return isolated
+    for filename in ("config.json", "opencode.json", "opencode.jsonc"):
+        stale = isolated / filename
+        if stale.is_symlink() or stale.is_file():
+            stale.unlink(missing_ok=True)
+    cfg = _sanitize_opencode_config(load_opencode_config(project_dir))
+    if cfg:
+        (isolated / "opencode.json").write_text(json.dumps(cfg, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    return root
 
 
 def ensure_memsearch_importable() -> None:
@@ -143,7 +376,7 @@ def run_native_provider(ctx, prompt: str) -> str:
     env = {**os.environ, "MEMSEARCH_NO_WATCH": "1"}
 
     if ctx.platform == "claude-code":
-        cmd = ["claude", "-p", "--strict-mcp-config", "--no-session-persistence", "--no-chrome"]
+        cmd = ["claude", "-p", "--strict-mcp-config", "--tools", "", "--no-session-persistence", "--no-chrome"]
         if model:
             cmd += ["--model", model]
         cmd += [
@@ -193,11 +426,15 @@ def run_native_provider(ctx, prompt: str) -> str:
         return extract_task_json_output(run_command(cmd, env=env, cwd=ctx.project_dir, timeout=120))
 
     if ctx.platform == "opencode":
-        isolated = ensure_opencode_isolated_config()
+        isolated = ensure_opencode_isolated_config(ctx.project_dir)
         cmd = ["opencode", "run"]
         if model:
             cmd += ["-m", model]
         cmd.append(prompt)
+        env["OPENCODE_CONFIG"] = ""
+        env["OPENCODE_CONFIG_DIR"] = ""
+        env["OPENCODE_CONFIG_CONTENT"] = ""
+        env["OPENCODE_DISABLE_PROJECT_CONFIG"] = "true"
         env["XDG_CONFIG_HOME"] = str(isolated)
         env["XDG_DATA_HOME"] = str(isolated / "data")
         return run_command(cmd, env=env, cwd=ctx.project_dir, timeout=120)

package/scripts/opencode_turns.py

@@ -17,6 +17,13 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 
+def _tail_truncate(text: str, max_chars: int) -> str:
+    """Keep the end of long text, where final conclusions usually appear."""
+    if len(text) <= max_chars:
+        return text
+    return "...(truncated to tail)\n" + text[-max_chars:]
+
+
 @dataclass
 class OpenCodeMessage:
     """A single meaningful OpenCode message with rendered text."""
@@ -51,10 +58,9 @@ class OpenCodeTurn:
             f"=== Turn {self.turn_index} ({self.turn_id}) ===",
         ]
         for message in self.messages:
-            label = "[Human]" if message.role == "user" else "[Assistant]"
+            label = "[User]" if message.role == "user" else "[Assistant]"
             text = message.text.strip()
-            if len(text) > max_chars:
-                text = text[:max_chars] + "\n..."
+            text = _tail_truncate(text, max_chars)
             lines.append(f"{label}: {text}")
             lines.append("")
         return "\n".join(lines).strip()
@@ -283,7 +289,6 @@ def extract_message_text(conn: sqlite3.Connection, message_id: str) -> str:
     ).fetchall()
 
     text_parts: list[str] = []
-    tool_parts: list[str] = []
 
     for part in parts:
         try:
@@ -298,36 +303,9 @@ def extract_message_text(conn: sqlite3.Connection, message_id: str) -> str:
             text = str(part_data["text"]).strip()
             if text:
                 text_parts.append(text)
-        elif part_type == "tool" and part_data.get("state"):
-            state = part_data.get("state", {})
-            status = state.get("status", "unknown")
-            tool_name = part_data.get("tool", "unknown")
-
-            if status == "completed":
-                tool_input = state.get("input", {})
-                tool_output = state.get("output", "")
-                if isinstance(tool_output, str) and len(tool_output) > 300:
-                    tool_output = tool_output[:300] + "..."
-
-                input_summary = ""
-                if isinstance(tool_input, dict):
-                    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}")
+        # Skip tool parts; summaries use the readable User/Assistant text.
 
     combined = "\n".join(text_parts).strip()
-    if tool_parts:
-        combined = "\n".join([combined, "\n".join(tool_parts)]).strip()
     return combined
 
 

package/skills/memory-config/SKILL.md

@@ -5,9 +5,9 @@ description: "Diagnose and configure MemSearch memory behavior for the OpenCode
 
 You are a MemSearch configuration assistant for the OpenCode plugin. This skill manages MemSearch settings only. It is not OpenCode's built-in memory configuration.
 
-Start every user-facing answer with:
-
-> This is MemSearch memory config, not OpenCode's own memory config.
+In diagnostic summaries or final answers, state once that this is MemSearch
+memory configuration, not OpenCode's own memory/config system. Do not prepend
+that sentence to every progress update or every paragraph.
 
 When this skill is triggered, inspect the user's request text. If there is no concrete request, run a diagnostic. If they ask for a specific setting or change, route the request using the flows below.
 
@@ -31,8 +31,54 @@ memsearch config list --global
 memsearch config list --project
 ```
 
+Check CLI and plugin versions before calling the setup healthy:
+
+```bash
+memsearch --version
+uv tool list --show-paths | rg -n 'memsearch|Package|Installed|path'
+curl -fsSL https://pypi.org/pypi/memsearch/json \
+  | python3 -c 'import json,sys; print(json.load(sys.stdin)["info"]["version"])'
+```
+
 If `memsearch` is unavailable, try `uvx --from memsearch[onnx] memsearch --version`.
 
+MemSearch has one shared Python CLI and platform plugins that may be installed
+from different channels:
+
+- CLI latest version comes from PyPI package `memsearch`. Update with
+  `uv tool install -U "memsearch[onnx]"` or `uv tool upgrade memsearch`.
+- Codex plugin has no independent package/version file. Inspect
+  `${CODEX_HOME:-$HOME/.codex}/hooks.json` to find the hook source path, then
+  compare that repository with the latest `zilliztech/memsearch` GitHub release:
+  `git -C <memsearch-repo> describe --tags --always --dirty` and
+  `gh release view --repo zilliztech/memsearch --json tagName,publishedAt,url`.
+  Update source installs with `git pull` plus
+  `bash plugins/codex/scripts/install.sh`.
+- Claude Code plugin latest marketplace/source version is in
+  `plugins/claude-code/.claude-plugin/plugin.json` and
+  `.claude-plugin/marketplace.json` in the `zilliztech/memsearch` repo. Check
+  the latest source manifest with
+  `curl -fsSL https://raw.githubusercontent.com/zilliztech/memsearch/main/plugins/claude-code/.claude-plugin/plugin.json`.
+  For marketplace installs, use `claude plugin marketplace update memsearch-plugins`
+  then `claude plugin update memsearch`, and restart Claude Code.
+- OpenClaw plugin latest published version comes from
+  `clawhub package inspect memsearch`; the source version is
+  `plugins/openclaw/package.json`. Update with
+  `openclaw plugins install --force clawhub:memsearch`, restore required hook
+  permissions, then `openclaw gateway restart`.
+- OpenCode plugin latest published version comes from
+  `npm view @zilliz/memsearch-opencode version dist-tags --json`; the source
+  version is `plugins/opencode/package.json`. If `~/.config/opencode/opencode.json`
+  pins a version, update the pin; otherwise restart OpenCode after package
+  refresh.
+
+For more detail, fetch the update sections from the public documentation:
+
+- Codex: https://zilliztech.github.io/memsearch/platforms/codex/installation/
+- Claude Code: https://zilliztech.github.io/memsearch/platforms/claude-code/installation/
+- OpenClaw: https://zilliztech.github.io/memsearch/platforms/openclaw/installation/
+- OpenCode: https://zilliztech.github.io/memsearch/platforms/opencode/installation/
+
 Check memory files:
 
 ```bash
@@ -152,6 +198,6 @@ Empty prompt paths mean use the built-in MemSearch prompts. Custom prompt files
 
 Use `memsearch config set` for changes. After changing anything, show the command, the resolved value, and whether a new session is needed.
 
-MemSearch TOML changes are read lazily by the CLI, capture daemon, and maintenance runner, so values such as `plugins.opencode.summarize.*`, `plugins.opencode.project_review.*`, `plugins.opencode.user_profile.*`, `[llm.providers.*]`, `[prompts]`, `milvus.*`, and `embedding.*` usually apply on the next capture, recall, index, or maintenance invocation. Restart OpenCode after `opencode.json` or plugin package changes; if capture behavior still looks stale after TOML edits, restart OpenCode or the capture daemon. After any answer, make clear that this is MemSearch memory configuration, not OpenCode's own memory/config system.
+MemSearch TOML changes are read lazily by the CLI, capture daemon, and maintenance runner, so values such as `plugins.opencode.summarize.*`, `plugins.opencode.project_review.*`, `plugins.opencode.user_profile.*`, `[llm.providers.*]`, `[prompts]`, `milvus.*`, and `embedding.*` usually apply on the next capture, recall, index, or maintenance invocation. Restart OpenCode after `opencode.json` or plugin package changes; if capture behavior still looks stale after TOML edits, restart OpenCode or the capture daemon. In final diagnostic/change summaries, make clear that this is MemSearch memory configuration, not OpenCode's own memory/config system.
 
 When useful, remind the user that they can either continue using this `memory-config` skill for guided configuration, or manually run `memsearch config init` for global interactive setup, `memsearch config init --project` for project interactive setup, and `memsearch config set/get/list` for direct CLI changes.