@zilliz/memsearch-opencode 0.3.6 → 0.3.7

package/package.json

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

package/prompts/memory_to_skill.txt

@@ -9,9 +9,12 @@ 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.
+(which you MAY revise). Propose or revise candidate skills when the journals show
+the same user-requested operation repeating enough times to be useful.
 
-Be conservative. Quality over quantity. Most runs should return an empty list.
+Candidates are review drafts, not installed skills. Do not enforce a fixed ratio,
+quota, or expectation that most runs return nothing. The number of candidates
+should follow the evidence in the journals.
 
 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.
@@ -19,9 +22,10 @@ A NEW workflow qualifies as a candidate ONLY when ALL of these hold:
   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.
+- The overall procedure was not abandoned, undone, or contradicted by later
+  evidence. Do not reject a workflow merely because individual runs included
+  failed attempts, retries, or corrected commands.
 
 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
@@ -30,17 +34,21 @@ 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.
+- Use {"skills": []} when no repeated workflow qualifies.
 - 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.
+  It becomes the skill's command name. For new candidates, do not reuse an
+  existing skill name; for revisions, reuse the exact existing 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.
+- If a workflow qualifies but some exact commands, paths, or flags are not
+  confirmed, still create the candidate. Keep those details general and add a
+  short "Before installing" verification step instead of inventing specifics.
 
 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.
@@ -66,6 +74,8 @@ Accuracy — confirm from the original, do not hallucinate:
 - If you cannot read the transcript or confirm a detail, capture only what the
   summary clearly states; keep the step general or omit it — a plausible-but-wrong
   command is worse than none. Never invent specifics.
+- Do not drop the whole candidate only because a few low-level details remain
+  unconfirmed; make the uncertainty visible for human review before installation.
 - Prefer fewer, verified steps over a complete-looking but partly-guessed procedure.
 
 JSON examples:

package/scripts/capture-daemon.py

@@ -459,6 +459,28 @@ def summarize_with_llm(
     return None
 
 
+def wake_maintenance(project_dir: str) -> None:
+    """Start maintenance in a hook-disabled child environment."""
+    runner = Path(__file__).resolve().parent / "maintenance-runner.py"
+    subprocess.Popen(
+        [
+            "python3",
+            str(runner),
+            "--platform",
+            "opencode",
+            "--project-dir",
+            project_dir,
+            "--memsearch-dir",
+            os.path.join(project_dir, ".memsearch"),
+        ],
+        env={**os.environ, "MEMSEARCH_NO_WATCH": "1", "MEMSEARCH_DISABLE": "1"},
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+
+
 def get_session_ids(conn: sqlite3.Connection, project_dir: str) -> list[str]:
     """Find OpenCode sessions that belong to the given project directory."""
     sessions = conn.execute(
@@ -790,16 +812,8 @@ def main() -> None:
                 )
 
             if any_new:
-                os.system(
-                    f"{args.memsearch_cmd} index '{memory_dir}' "
-                    f"--collection {args.collection_name} &"
-                )
-                os.system(
-                    f"python3 {shlex.quote(str(Path(__file__).resolve().parent / 'maintenance-runner.py'))} "
-                    f"--platform opencode "
-                    f"--project-dir {shlex.quote(args.project_dir)} "
-                    f"--memsearch-dir {shlex.quote(os.path.join(args.project_dir, '.memsearch'))} &"
-                )
+                os.system(f"{args.memsearch_cmd} index '{memory_dir}' --collection {args.collection_name} &")
+                wake_maintenance(args.project_dir)
         except Exception:
             pass
         finally:

package/scripts/maintenance-runner.py

@@ -13,6 +13,7 @@ import contextlib
 import json
 import os
 import re
+import shlex
 import shutil
 import subprocess
 import sys
@@ -264,7 +265,50 @@ def run_command(cmd: list[str], *, env: dict[str, str], cwd: Path, timeout: int)
         timeout=timeout,
         check=False,
     )
-    return (result.stdout or result.stderr or "").strip()
+    stdout = (result.stdout or "").strip()
+    stderr = (result.stderr or "").strip()
+    if result.returncode != 0:
+        detail = "\n".join(part for part in (stdout, stderr) if part)
+        if len(detail) > 2000:
+            detail = detail[:1975] + "... [truncated]"
+        command = " ".join(shlex.quote(_describe_arg(part)) for part in cmd)
+        if len(command) > 300:
+            command = command[:275] + "... [truncated]"
+        message = f"Command failed ({result.returncode}): {command}"
+        if detail:
+            message = f"{message}\n{detail}"
+        raise RuntimeError(message)
+    return stdout or stderr
+
+
+def _describe_arg(arg: str, limit: int = 120) -> str:
+    if len(arg) <= limit:
+        return arg
+    return f"<arg:{len(arg)} chars>"
+
+
+_CLAUDE_SAFE_MODE_ARGS: list[str] | None = None
+
+
+def claude_safe_mode_args() -> list[str]:
+    """Return Claude args that suppress hooks when supported."""
+    global _CLAUDE_SAFE_MODE_ARGS
+    if _CLAUDE_SAFE_MODE_ARGS is not None:
+        return _CLAUDE_SAFE_MODE_ARGS
+    try:
+        result = subprocess.run(
+            ["claude", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        _CLAUDE_SAFE_MODE_ARGS = []
+    else:
+        help_text = f"{result.stdout}\n{result.stderr}"
+        _CLAUDE_SAFE_MODE_ARGS = ["--safe-mode"] if "--safe-mode" in help_text else []
+    return _CLAUDE_SAFE_MODE_ARGS
 
 
 def extract_task_json_output(output: str) -> str:
@@ -376,7 +420,14 @@ 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",
+            *claude_safe_mode_args(),
+            "--strict-mcp-config",
+            "--no-session-persistence",
+            "--no-chrome",
+        ]
         # Skill distillation needs to read original transcripts for exact commands.
         # Open a narrow hole — Bash limited to the two read-only memsearch drill
         # commands — only for that task; other maintenance keeps all tools off.
@@ -392,6 +443,7 @@ def run_native_provider(ctx, prompt: str) -> str:
             prompt,
         ]
         env["CLAUDECODE"] = ""
+        env["MEMSEARCH_DISABLE"] = "1"
         return run_command(cmd, env=env, cwd=ctx.project_dir, timeout=120)
 
     if ctx.platform == "codex":

package/skills/memory-config/SKILL.md

@@ -189,6 +189,10 @@ Model guidance:
 
 Advanced maintenance runs after the plugin wakes it, only when enabled, journal input changed, and `min_interval_hours` elapsed. `PROJECT.md` and `USER.md` are maintenance artifacts by default and are not automatically indexed.
 
+If advanced maintenance or `memory_to_skill` seems silent, check
+`.memsearch/.maintenance-state.json` for `<plugin>.<task>.last_error` and
+`last_failed_at`; background hook errors may not surface in the chat.
+
 Before enabling advanced maintenance, ask which provider to use, whether the default 24-hour interval is acceptable, and whether `.memsearch/PROJECT.md` / `.memsearch/USER.md` are acceptable output files.
 
 Prompt overrides:

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

@@ -11,6 +11,8 @@ 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.
+User requests may stop at candidate creation/review, or continue to installation
+in the same turn after explicit approval; match the requested stage.
 
 ## Intent routing
 
@@ -37,24 +39,35 @@ printf '%s' "## <title>\n\n1. ...\n2. ..." | memsearch skills add \
 ```
 
 `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.
+LLM is involved. Then show it to the user; install it only if the user asked for
+that or explicitly approves (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
+git -C .memsearch/skill-candidates log --oneline -5 2>/dev/null || true
 ```
 
 Before recommending or installing, skim the candidate's body: if a step looks uncertain or loosely summarized, re-check it against the source (open the transcript if needed) or flag it to the user and let them decide — installing copies the candidate as-is, so this is the last chance to catch a wrong step.
+When showing candidates, mention the store's recent git history when it helps
+explain whether a candidate is new, evolved, removed, or re-created.
 
-Pick one, resolve where to install (ask if unset), then install:
+Treat installation as an interactive checkpoint. Show the candidate, apply any
+requested tweaks before installing, and confirm the install destination with the
+user. Resolve install targets from config first: if `paths` is a non-empty
+list, present those paths as the proposed destinations and pass each entry as a
+`--path` after confirmation. If it is empty, ask the user where to install; do
+not silently fall back to a default path.
 
 ```bash
 memsearch config get plugins.opencode.memory_to_skill.paths 2>/dev/null || echo "[]"
-memsearch skills install <name> --path .agents/skills
+memsearch skills install <name> --path <configured-or-user-approved-path>
 ```
+After installation, remind the user to start a fresh agent session or reopen the
+conversation so the newly installed skill is loaded.
 
 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
@@ -71,7 +84,7 @@ generalize, not one-offs from a single day.
 
 **Drill into the original before drafting.** The journal bullets are a lossy summary; the exact commands, flags, and paths live in the original conversation. OpenCode stores transcripts in its session database (not a file), and the journal anchor carries a `session:` id (and `turn:` when present). Run `python3 __INSTALL_DIR__/scripts/parse-transcript.py <session_id>` (add `--turn <id>` when the anchor has one) to read the original turns with their tool calls — that is where the executed commands and output live. Write the skill from that. If the shown excerpt feels incomplete, skim nearby turns in the same original source before committing to exact commands or paths. If you cannot read it or confirm a detail, keep the step general or omit it — never fabricate.
 
-The background pass mines automatically when enabled, but it can only see the summaries; doing it here on demand lets you read the original transcripts, so the result is more accurate.
+The background pass mines automatically when enabled, starting from the summaries; doing it here on demand lets you inspect the original transcripts more deliberately, so the result can be more accurate.
 
 ## D. Configure