@zilliz/memsearch-opencode 0.3.3 → 0.3.5

package/package.json

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

package/prompts/memory_to_skill.txt

@@ -0,0 +1,59 @@
+You are distilling reusable skills from {{AGENT_NAME}}'s recent memory journals.
+
+Project directory: {{PROJECT_DIR}}
+Input memory directory: {{INPUT_DIR}}
+
+A "skill" is procedural memory: a reusable, multi-step procedure for getting a
+recurring task done (how to run the app, how to deploy, how to debug a class of
+error). It is NOT a fact, a decision, or a preference — those belong in
+PROJECT.md and USER.md.
+
+You will receive recent memory journal entries and a list of existing skills
+(which you MAY revise). Propose or revise skills only when they clearly earn it.
+
+Be conservative. Quality over quantity. Most runs should return an empty list.
+
+A NEW workflow qualifies as a candidate ONLY when ALL of these hold:
+- It is a repeatable multi-step procedure, not a one-off action or a fact.
+- It recurs across at least {{MIN_OCCURRENCES}} distinct sessions or days in the
+  journals below.
+- It generalizes into a reusable capability. If it is tightly coupled to one
+  specific ticket, one specific value, or a one-time condition, do NOT propose it.
+- The recent runs were not immediately corrected, abandoned, or undone (a
+  workflow the user kept fighting is not a good skill).
+- It is not already covered by an existing skill.
+
+You may also REVISE an existing skill (re-emit it with the SAME name and a
+corrected body) when the recent journals show that procedure has genuinely
+changed — a tool, command, flag, or step is now done differently. Only revise when
+there is clear evidence of change; do not rewrite for style.
+
+Rules:
+- Return only a JSON object, with no prose outside JSON.
+- Use {"skills": []} when nothing in the journals qualifies. This is the common case.
+- For each candidate, write a clean, portable SKILL.md body in "body": step-by-step
+  instructions an agent can follow. Do not include YAML frontmatter — only the
+  markdown body. Keep it concise and concrete.
+- "name" must be a short lowercase slug (letters, digits, dashes), e.g. "run-tests".
+  It becomes the skill's command name. Do not reuse an existing skill name.
+- "description" is one line: what the skill does AND when it should trigger.
+  Lead with the verbs a user would actually type ("run", "deploy", "debug").
+- "occurrences" is how many distinct sessions/days you saw this workflow.
+- "sources" lists the journal file names the workflow was observed in.
+- Do not copy raw journal text wholesale into the body; abstract it into a procedure.
+
+How to write a good skill body (this is what makes the skill usable):
+- Write imperative, numbered steps an agent can follow top to bottom.
+- Be concrete: real commands, file paths, and flags — not vague prose.
+- Keep it focused and short. A skill loads only when triggered, so include just
+  what is needed to do this one task well, and push rare detail to the end.
+- State any preconditions, and where useful, when NOT to use the skill.
+- Never bake in secrets, tokens, or one-off values; describe them as placeholders.
+- Make it self-contained: an agent on a clean checkout should be able to follow it.
+- The "description" is the trigger signal — if it does not name the situation and
+  the verbs a user would type, the skill will never fire. Spend care on it.
+
+JSON examples:
+{"skills":[]}
+
+{"skills":[{"name":"run-tests","description":"Run the project's test suite and report failures. Use when asked to run tests, check tests, or verify a change.","body":"## Run the tests\n\n1. ...\n2. ...","occurrences":4,"sources":["2026-06-12.md","2026-06-14.md"],"reason":"Test run procedure recurred across 4 sessions."}]}

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:
@@ -171,7 +387,12 @@ def _load_summarize_prompt(agent_name: str, memsearch_cmd: str | None = None) ->
     )
 
 
-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
@@ -202,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"]
@@ -215,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",
@@ -491,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,
@@ -538,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:
@@ -130,7 +363,7 @@ def ensure_memsearch_importable() -> None:
 def apply_plugin_prompt_defaults(cfg) -> None:
     plugin_dir = Path(__file__).resolve().parent.parent
     prompts_dir = plugin_dir / "prompts"
-    for task in ("project_review", "user_profile"):
+    for task in ("project_review", "user_profile", "memory_to_skill"):
         if getattr(cfg.prompts, task, ""):
             continue
         prompt_file = prompts_dir / f"{task}.txt"
@@ -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 += [
@@ -155,7 +388,9 @@ def run_native_provider(ctx, prompt: str) -> str:
         return run_command(cmd, env=env, cwd=ctx.project_dir, timeout=120)
 
     if ctx.platform == "codex":
-        with tempfile.NamedTemporaryFile(prefix="memsearch-codex-maintenance-", suffix=".txt", delete=False) as output_file:
+        with tempfile.NamedTemporaryFile(
+            prefix="memsearch-codex-maintenance-", suffix=".txt", delete=False
+        ) as output_file:
             output_path = Path(output_file.name)
         cmd = [
             "codex",
@@ -193,11 +428,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)
@@ -239,6 +478,20 @@ def main() -> int:
             force=args.force,
             llm_runner=llm_runner,
         )
+
+        # Distill recurring workflows into candidate skills (procedural memory).
+        # Same session-end trigger, due-state, and llm_runner as the tasks above;
+        # this only ever touches the candidate store, never an agent's skills dir.
+        from memsearch.skills import distill as distill_skills
+
+        skill_result = distill_skills(
+            platform=args.platform,
+            project_dir=project_dir,
+            memsearch_dir=args.memsearch_dir,
+            cfg=cfg,
+            force=args.force,
+            llm_runner=llm_runner,
+        )
     except (KeyError, RuntimeError, ValueError, subprocess.SubprocessError) as exc:
         sys.stderr.write(f"Maintenance error: {exc}\n")
         return 1
@@ -247,12 +500,15 @@ def main() -> int:
             os.chdir(old_cwd)
 
     payload = [result.__dict__ for result in results]
+    payload.append({"task": "memory_to_skill", **skill_result.__dict__})
     if args.json_output:
         sys.stdout.write(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
     else:
         for result in results:
             detail = f": {result.reason}" if result.reason else ""
             sys.stdout.write(f"{result.task}: {result.action}{detail}\n")
+        skill_detail = f": {skill_result.reason}" if skill_result.reason else ""
+        sys.stdout.write(f"memory_to_skill: {skill_result.action}{skill_detail}\n")
     return 0
 
 

package/skills/memory-config/SKILL.md

@@ -19,6 +19,7 @@ When this skill is triggered, inspect the user's request text. If there is no co
 - "Not capturing/search empty/no memory": troubleshoot files, config, and index health.
 - "Use OpenAI/Gemini/Anthropic/native/model": configure provider routing.
 - "PROJECT.md/USER.md/profile/review": configure advanced maintenance.
+- "skill/distill/extract a skill/memory-to-skill": procedural-memory distillation — enable or tune it here, or use the dedicated `/memory-to-skill` skill to review and install candidates.
 - "Prompt": explain or configure prompt overrides.
 
 Ask the user before enabling external or paid providers, changing output paths, re-indexing, deleting state, or broadening what gets indexed.
@@ -145,6 +146,11 @@ model = ""
 min_interval_hours = 24
 input_dir = ".memsearch/memory"
 output_file = ".memsearch/USER.md"
+
+[plugins.opencode.memory_to_skill]
+enabled = false
+min_occurrences = 3   # how many times a workflow must recur before it is distilled
+paths = []            # where installed skills are copied; empty = ask the user
 ```
 
 Provider rules:
@@ -192,6 +198,7 @@ Prompt overrides:
 summarize = ""
 project_review = ""
 user_profile = ""
+memory_to_skill = ""
 ```
 
 Empty prompt paths mean use the built-in MemSearch prompts. Custom prompt files may use `{{AGENT_NAME}}`, `{{TASK_NAME}}`, `{{PROJECT_DIR}}`, `{{INPUT_DIR}}`, and `{{OUTPUT_FILE}}`; the runner appends existing output, recent journals, and digest automatically.

package/skills/memory-to-skill/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: memory-to-skill
+description: "Turn workflows from your MemSearch memory into reusable skills. Use when the user asks to make/create/extract/distill a skill from what they just did or from past work, review skill candidates, install a distilled skill, or 'turn this into a skill'. Manages MemSearch procedural-memory candidates under .memsearch/skill-candidates/, not OpenCode's own skills system."
+---
+
+You manage MemSearch's **procedural memory**: skills distilled from the work you
+repeat — a third layer beside the daily journals (episodic) and PROJECT.md /
+USER.md (semantic). State once that this is MemSearch skill distillation, not
+OpenCode's built-in skills system.
+
+Stages: **0** memory journals → **1** candidate (`.memsearch/skill-candidates/`,
+a git-tracked store that keeps evolving) → **2** installed (an agent skill dir).
+Candidates are never installed automatically; installing is always a human step.
+
+## Intent routing
+
+- "make/turn this into a skill", "from what we just did" → **A. Capture now**.
+- "what skills / review candidates / install X" → **B. Review & install**.
+- "mine my history / find recurring workflows" → **C. Distill from history**.
+- "enable / configure / how eager" → **D. Configure**.
+- Unclear or empty → run **B**'s `list`; if empty, offer A or C.
+
+## A. Capture what you just did (0→1→2)
+
+You already have the context, so **draft the skill yourself** — do not call the
+background distiller for this. Write a SKILL.md **body** (markdown, no
+frontmatter): imperative numbered steps for the recurring task, concrete commands
+and paths, no secrets, self-contained. Then persist it as a candidate:
+
+```bash
+printf '%s' "## <title>\n\n1. ...\n2. ..." | memsearch skills add \
+  --name "<short-slug>" \
+  --description "<what it does AND when it should trigger — lead with the verbs a user types>" \
+  --body-file -
+```
+
+`add` handles slugging, standard frontmatter, meta.json, and the git commit — no
+LLM is involved. Then show it to the user and install it (see **B**). Finally,
+check whether background distillation is on; if not, offer to enable it (so
+recurring workflows get captured automatically going forward) — do not force it.
+
+## B. Review & install candidates (1→2)
+
+```bash
+memsearch skills list            # add -j for sources / installed paths
+```
+
+Pick one, resolve where to install (ask if unset), then install:
+
+```bash
+memsearch config get plugins.opencode.memory_to_skill.paths 2>/dev/null || echo "[]"
+memsearch skills install <name> --path .agents/skills
+```
+
+If the list is **empty**, background distillation is likely off or has not run.
+Offer the user a choice: capture from recent work now (**A**), distill from
+history (**C**), or enable the background pass (**D**).
+
+## C. Mine history for recurring workflows (0→1)
+
+To pull skills out of past work (not just the current session), read the recent
+journals yourself — they live in `.memsearch/memory/*.md` — and look for
+multi-step procedures that recur across several sessions. Draft each genuinely
+reusable one and persist it with `memsearch skills add` (one call per skill), the
+same way as **A**. Use your own judgment: only propose procedures that recur and
+generalize, not one-offs from a single day.
+
+The background pass does this automatically when enabled; doing it here on demand
+uses your own reasoning and needs no provider configuration.
+
+## D. Configure
+
+```bash
+memsearch config get plugins.opencode.memory_to_skill.enabled 2>/dev/null || echo "false"
+# enable the background pass (do not enable silently)
+memsearch config set plugins.opencode.memory_to_skill.enabled true --project
+# how eagerly history-mining distils (default 3; lower = more eager)
+memsearch config set plugins.opencode.memory_to_skill.min_occurrences 3 --project
+# pre-set install targets (otherwise you are asked at install time)
+memsearch config set plugins.opencode.memory_to_skill.paths '[".agents/skills"]' --project
+```
+
+Note: `enabled` only gates the **background** (session-end) pass. The explicit
+commands above (`skills add`, `skills install`) always work, and you can mine history (C) directly.
+
+## Install paths
+
+- `.agents/skills` — **project-local (recommended)**: a skill from this project's
+  memory is usually most relevant here.
+- `~/.agents/skills` — global: available across all your projects.
+- a custom path, or several (one skill can be installed to multiple dirs).
+
+Each agent reads skills from its own directory: Claude Code `.claude/skills/`;
+Codex and OpenCode `.agents/skills/` (the shared standard, also read by Cursor
+etc.); OpenClaw `.openclaw/skills/`. Claude Code does **not** read `.agents/skills/`.
+Install to multiple paths to cover several agents.
+
+## Guardrails
+
+- Never enable the feature, change install paths, or install a candidate without
+  the user's go-ahead.
+- Do not hand-edit the store; create candidates with `memsearch skills add` and let
+  the git-tracked store at `.memsearch/skill-candidates/` keep history.