@zilliz/memsearch-opencode 0.3.5 → 0.3.6

package/package.json

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

package/prompts/memory_to_skill.txt

@@ -53,6 +53,21 @@ How to write a good skill body (this is what makes the skill usable):
 - 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.
 
+Accuracy — confirm from the original, do not hallucinate:
+- The journal entries are LOSSY SUMMARIES; they drop the exact commands, flags,
+  and paths. Do not reconstruct those from the summary alone.
+- Before writing a step's exact command, confirm it from the original transcript.
+  Each journal entry has an anchor comment naming the original conversation; the
+  key differs by agent — `transcript:<file>` (Claude Code), `rollout:<file>`
+  (Codex), or `db:`/a `session:` id (OpenCode). For a file-based transcript, run
+  `memsearch transcript <file>` (optionally `--turn <id>`) to read the original
+  turns WITH their tool calls — that is where the real commands and output live.
+  For a session/db anchor (OpenCode), use that platform's transcript script.
+- 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.
+- Prefer fewer, verified steps over a complete-looking but partly-guessed procedure.
+
 JSON examples:
 {"skills":[]}
 

package/scripts/maintenance-runner.py

@@ -376,7 +376,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", "--tools", "", "--no-session-persistence", "--no-chrome"]
+        cmd = ["claude", "-p", "--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.
+        if getattr(ctx, "task", "") == "memory_to_skill":
+            cmd += ["--tools", "Bash", "--allowed-tools", "Bash(memsearch transcript:*) Bash(memsearch expand:*)"]
+        else:
+            cmd += ["--tools", ""]
         if model:
             cmd += ["--model", model]
         cmd += [

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

@@ -25,7 +25,9 @@ Candidates are never installed automatically; installing is always a human step.
 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:
+and paths, no secrets, self-contained.
+
+**Be exact — do not guess.** You have the live session for what you just did, so use the real commands, paths, and output, not approximations. If a detail is uncertain, verify it (re-read the relevant files or the transcript) or keep that step general — a wrong command is worse than a vague one. Then persist it as a candidate:
 
 ```bash
 printf '%s' "## <title>\n\n1. ...\n2. ..." | memsearch skills add \
@@ -45,6 +47,8 @@ recurring workflows get captured automatically going forward) — do not force i
 memsearch skills list            # add -j for sources / installed paths
 ```
 
+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.
+
 Pick one, resolve where to install (ask if unset), then install:
 
 ```bash
@@ -65,8 +69,9 @@ reusable one and persist it with `memsearch skills add` (one call per skill), th
 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.
+**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.
 
 ## D. Configure