@zilliz/memsearch-opencode 0.3.6 → 0.3.10

package/index.ts

@@ -70,10 +70,43 @@ function deriveCollectionName(projectDir: string): string {
 
 /**
  * Summarize the N most recent daily .md files for cold-start context.
- * Extracts headings (## Session, ### turns) and bullet content from each
- * file so the agent sees the structure of past days (what sessions existed,
- * what topics came up), not just the tail of whichever file is newest.
+ * Extracts recent non-empty session sections so empty SessionStart headings
+ * do not crowd out useful context.
  */
+function recentMemoryPreviewLines(content: string, maxLines: number): string[] {
+  const sections: string[][] = [];
+  let current: string[] = [];
+  let hasBody = false;
+
+  const flush = () => {
+    if (current.length > 0 && hasBody) {
+      sections.push(current);
+    }
+    current = [];
+    hasBody = false;
+  };
+
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trimEnd();
+    if (/^##\s/.test(line)) {
+      flush();
+      current = [line];
+      continue;
+    }
+    if (/^#{3,4}\s/.test(line)) {
+      current.push(line);
+      continue;
+    }
+    if (line.startsWith("- ") || line.startsWith("[User]") || line.startsWith("[Assistant]")) {
+      current.push(line);
+      hasBody = true;
+    }
+  }
+
+  flush();
+  return sections.flat().slice(-maxLines);
+}
+
 function getRecentMemories(
   memDir: string,
   count = 2,
@@ -92,9 +125,7 @@ function getRecentMemories(
   for (const file of files) {
     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("[User]") || l.startsWith("[Assistant]"))
-        .slice(0, maxLinesPerFile);
+      const lines = recentMemoryPreviewLines(content, maxLinesPerFile);
       if (lines.length > 0) {
         summary.push(`[${file}]`, ...lines);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zilliz/memsearch-opencode",
-  "version": "0.3.6",
+  "version": "0.3.10",
   "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

@@ -15,7 +15,7 @@ When this skill is triggered, inspect the user's request text. If there is no co
 
 - Empty request or "check": diagnose current MemSearch setup.
 - "Show/get setting": read the requested resolved/global/project value.
-- "Set/enable/disable/change": make a safe project-scoped change after confirming ambiguous choices.
+- "Set/enable/disable/change": choose global vs project scope explicitly; use global config for trusted plugin automation/provider/prompt/endpoint settings and project config only for allowlisted local indexing knobs.
 - "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.
@@ -114,14 +114,33 @@ Config is resolved from built-in defaults, global config, project config, env re
 
 Use `memsearch config list --resolved` for effective behavior, `--global` for global overrides, and `--project` for repository-specific overrides.
 
+Since v0.4.11, project-local `.memsearch.toml` is restricted before it is merged.
+Only these low-risk local indexing keys are honored from project config:
+
+- `milvus.collection`
+- `embedding.batch_size`
+- `chunking.max_chunk_size`
+- `chunking.overlap_lines`
+- `watch.debounce_ms`
+
+Trusted settings are ignored or rejected in project config. Put these in global
+config (`~/.memsearch/config.toml`) or pass explicit CLI flags instead:
+
+- provider/model/API endpoint/API key settings
+- `[llm]` and `[llm.providers.*]`
+- `[prompts]`
+- plugin automation such as `plugins.opencode.project_review.enabled`,
+  `plugins.opencode.user_profile.enabled`, and
+  `plugins.opencode.memory_to_skill.enabled`
+
 Default recommendation:
 
 - Put reusable defaults in global config so users do not repeat setup in every project.
-- Put only project-specific overrides in project config.
-- Use global config for named LLM providers, common model choices, normal input/output defaults, and shared prompt defaults.
-- Use project config for one repo's enable/disable switches, unusual output files, special intervals, or repo-specific providers.
+- Put only allowlisted local indexing overrides in project config.
+- Use global config for named LLM providers, common model choices, plugin enable/disable switches, task intervals, install paths, and shared prompt defaults.
+- If the user wants advanced maintenance enabled for all projects, set the plugin keys globally. The default relative `input_dir` / `output_file` values still resolve inside each current project.
 
-Maintenance `input_dir` and `output_file` may be relative even when configured globally. They are resolved from the current project directory at runtime. For custom prompt paths, prefer absolute paths in global config and relative paths in project config.
+Maintenance `input_dir` and `output_file` may be relative even when configured globally. They are resolved from the current project directory at runtime, so a global `output_file = ".memsearch/PROJECT.md"` writes to each project's own `.memsearch/PROJECT.md`. For custom prompt paths, prefer absolute paths in global config; project prompt paths are not trusted.
 
 OpenCode plugin keys:
 
@@ -189,7 +208,11 @@ 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.
 
-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.
+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, whether `.memsearch/PROJECT.md` / `.memsearch/USER.md` are acceptable output files, and whether the user wants the enablement global. Do not write plugin automation keys with `--project`; v0.4.11+ project config ignores or rejects them.
 
 Prompt overrides:
 
@@ -203,8 +226,8 @@ 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.
 
-Use `memsearch config set` for changes. After changing anything, show the command, the resolved value, and whether a new session is needed.
+Use `memsearch config set` for changes. For trusted keys such as `plugins.*`, `[llm.providers.*]`, `[prompts]`, `embedding.provider`, or `milvus.uri`, set global config by omitting `--project`. Use `--project` only for allowlisted local indexing keys. 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. 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.
+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 allowlisted project indexing setup, and `memsearch config set/get/list` for direct CLI changes.

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,20 +84,25 @@ 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
 
 ```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
+# enable the background pass globally (do not enable silently)
+memsearch config set plugins.opencode.memory_to_skill.enabled true
 # how eagerly history-mining distils (default 3; lower = more eager)
-memsearch config set plugins.opencode.memory_to_skill.min_occurrences 3 --project
+memsearch config set plugins.opencode.memory_to_skill.min_occurrences 3
 # pre-set install targets (otherwise you are asked at install time)
-memsearch config set plugins.opencode.memory_to_skill.paths '[".agents/skills"]' --project
+memsearch config set plugins.opencode.memory_to_skill.paths '[".agents/skills"]'
 ```
 
+Since v0.4.11, project-local `.memsearch.toml` accepts only allowlisted local
+indexing keys. Do not use `--project` for `plugins.*` settings such as
+`memory_to_skill.enabled`, `min_occurrences`, or `paths`; put them in global
+config instead.
+
 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.