open-memex 0.6.2 → 0.7.0-alpha.2

package/AGENTS.md

@@ -18,7 +18,7 @@ via `prepublishOnly` — Node refuses `--experimental-strip-types` for files und
 
 Tool logic is host-agnostic and lives in `src/tools/ops.ts` (plain functions + shared zod arg shapes + `TOOL_DESCRIPTIONS`). `src/tools/memory.ts` (opencode) and `src/mcp.ts` are thin adapters — when adding or changing a tool, change `ops.ts` once and both hosts pick it up.
 
-**Plugin code must not runtime-import `@opencode-ai/plugin`** (D58): it is a devDependency, and opencode does not resolve it for `file://` plugins loaded from a global npm install — the import fails and opencode silently skips the plugin (no error, no tools). Type-only imports are fine. `src/tools/memory.ts` carries a local stand-in for the SDK's `tool()` (a runtime identity) for exactly this reason.
+**Plugin code must not runtime-import a host SDK package** (D58, extended by D60): `@opencode-ai/plugin` (v1) and `@opencode/plugin` (v2) are devDependencies, and neither host resolves them for plugins loaded from a global npm install — the import fails and the host silently skips the plugin (no error, no tools). Type-only imports are fine. `src/tools/memory.ts` carries a local stand-in for the v1 SDK's `tool()` (a runtime identity), and `src/opencode-v2.ts` duck-types the v2 context, for exactly this reason. The plugin entry is a dual export (`{ id, setup, server }`, D60): v1 ≥1.18.29 calls `server`, opencode 2 calls `setup`; both adapt `src/plugin-core.ts`.
 
 Consequences:
 - Imports **must** use explicit `.ts` extensions (`allowImportingTsExtensions: true`, `moduleResolution: "Bundler"`).
@@ -65,7 +65,8 @@ at init time — npx fallback when no durable bin is on PATH, D17),
 `open-memex config` prints the effective config, `open-memex capture --dry-run "text"`
 previews keyword capture without writing, `open-memex doctor` runs health checks
 (node version, config, scope resolution, storage writability, SQLite locking,
-opencode plugin entry (target exists + no host-SDK runtime imports, D59),
+opencode plugin entries for both host generations (target exists + no
+host-SDK runtime imports, D59/D60),
 VS Code MCP enablement, MCP handshake).
 `open-memex init` with no --client auto-detects and wires every installed editor
 (`--yes` skips, scripts never prompt); `open-memex config set <key> <value>` edits settings after install.
@@ -136,6 +137,15 @@ Every write path (tool, keyword hook, CLI `add`) must:
 3. Check `findDuplicates` (design §3.4): identical content is idempotent (return existing id); near-duplicates (similarity ≥ 0.8) warn but save — suggest `supersede` when the new content replaces the old.
 4. `writeMemoryFile` first, then `readMemoryFile` + `upsertFromFile` to keep FTS in sync.
 
+Capture-time aliases (D61): `memory_add`/`supersede` may carry up to 4
+`aliases` (alternate phrasings) into frontmatter; they index in their own FTS
+column. Only when `cfg.captureAliases` is on (init asks once, default on) —
+when off, passed aliases are dropped. Always pass them through
+`normalizeAliases`; the keyword-capture path (no agent in the loop) never
+invents aliases. Checkpoint-proposal guidance (propose, never auto-draft) is
+copy, not mechanism: keep the rubric wording in sync across the skill, the
+AGENTS.md hygiene footer, the MCP handshake, and the tool descriptions.
+
 ## Lifecycle invariants (design §3.3)
 
 - Statuses: `active → superseded | deprecated | retracted | archived`. Retrieval excludes `retracted`/`archived`, ranks `active` above `deprecated`.

package/CHANGELOG.md

@@ -9,6 +9,28 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## Proactive capture: checkpoint proposals and aliases (D61)
+
+- At task checkpoints the agent now proposes instead of waiting to be asked: when a task wraps up, it offers 1–3 short candidate memories distilled from the session (decisions and their reasons, conventions, gotchas, approaches tried and abandoned) and saves only the ones you approve — approved inferences are marked `source: "inference"`. One memorability rubric and one search discipline (break the question into concepts, try several phrasings, check both scopes) are written into every guidance surface — the bundled skill, the AGENTS.md memory-hygiene footer, the MCP handshake, and the tool descriptions — so behavior is consistent across editors. Nothing is auto-drafted in the background; that posture waits on memory visibility.
+- Memories can carry up to 4 **aliases** — alternate phrasings, synonyms, other-language equivalents — stored in the memory file and indexed with it, so a differently-worded question still matches ("vacation days" finds the holiday policy; "节假日" too). `init` asks once (default on); `open-memex config set captureAliases false` turns it off. Existing memory files are untouched — the index rebuilds itself on first use.
+
+## One plugin, both opencode generations (D60)
+
+- The native plugin now loads on **opencode 2** as well as opencode 1. `open-memex init --client opencode --global` writes both config spellings — the v1 `"plugin"` file entry and the v2 `"plugins"` directory entry — and each host reads its own. Previously an opencode 2 host silently skipped the plugin (a file entry is not a directory it can load), leaving no tools and no explanation.
+- Tools register with code mode off (`options.codemode: false`): on opencode 2 an unflagged plugin tool is only reachable through a JS `execute` meta-tool, and models that call it by name get "Unknown tool" — with the opt-out, the five tools are ordinary function calls on both generations.
+- On the opencode 1 side this raises the minimum host version to **1.18.29**: the dual entrypoint is a plain exported object, and older v1 hosts only invoke function exports.
+- `open-memex doctor` extends the plugin patrol to both config keys: v2 entries are checked for a resolvable entry file and the same no-host-SDK-runtime-import rule, and when the installed opencode major version disagrees with what the config wires, doctor fails and names the fix.
+
+## [0.6.2] - 2026-10-03
+
+## Doctor patrols the plugin entry (D59)
+
+- `open-memex doctor` gains an `opencode plugin` check: it reads the user-level opencode configs, attributes the open-memex plugin entry, and fails when the target file no longer exists (naming the `open-memex init --client opencode --global --force` re-point command) or when the plugin's import closure runtime-imports the host SDK. That second failure is exactly what silently killed the plugin in D58 — it now shows up in a check instead of surfacing as missing tools.
+
+## Notes
+
+- 0.6.1 contained D56–D58 but was published before this check landed; 0.6.2 is the recommended upgrade for everyone on the 0.6.x line.
+
 ## [0.6.1] - 2026-10-03
 
 ## Question-shaped search, host parity said out loud (D56)
@@ -130,7 +152,8 @@ Install: `npm install -g open-memex`
 
 - First public release under the open-memex name (renamed from my-o-memory): local-first memory for AI coding agents — Markdown files as the source of truth, SQLite FTS5 index, opencode plugin + MCP server + CLI.
 
-[Unreleased]: https://github.com/stoneskin/open-memex/compare/v0.6.1...HEAD
+[Unreleased]: https://github.com/stoneskin/open-memex/compare/v0.6.2...HEAD
+[0.6.2]: https://github.com/stoneskin/open-memex/compare/v0.6.1...v0.6.2
 [0.6.1]: https://github.com/stoneskin/open-memex/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/stoneskin/open-memex/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/stoneskin/open-memex/compare/v0.5.0...v0.5.1

package/README.md

@@ -247,6 +247,12 @@ project picks it up, no per-project init. You get the 5 core tools, keyword
 auto-capture, and first-turn context injection. (A config file with comments is
 left untouched — `init` prints the line to add by hand.)
 
+Both opencode generations are supported from the same install: `init` writes
+the opencode 1 spelling (`"plugin"`) and the opencode 2 spelling (`"plugins"`)
+— each host reads its own key. Opencode 1 needs version **1.18.29 or newer**
+for this. `open-memex doctor` tells you if the wiring and the installed host
+version don't match.
+
 **opencode** (as a plain MCP consumer):
 
 ```sh
@@ -333,7 +339,8 @@ Everything `init` writes, in one place:
   macOS/Linux — your memory files and the search index. Nothing here is ever
   modified by `uninstall`.
 - **Editor wiring** (removed by `open-memex uninstall`):
-  - opencode: a `"plugin"` entry merged into
+  - opencode: a `"plugin"` entry (opencode 1) and a `"plugins"` entry
+    (opencode 2) merged into
     `~/.config/opencode/opencode.json` (or `.jsonc`). Stale `my-o-memory`
     entries from before the rename are removed at the same time.
   - VS Code / Cursor: an `open-memex` server entry in the user-level or
@@ -366,7 +373,19 @@ Three ways memories get in:
   (or it saves on its own when you state a fact worth keeping) — it calls
   `memory_add`. The routing above is a heuristic; you can always say "save this
   to my personal memory" or use the CLI with `--scope` to be explicit.
-- **The CLI**: `open-memex add "…"` with optional `--scope` / `--tags` / `--type`.
+- **Checkpoint proposals**: when a task wraps up, the agent proposes 1–3 short
+  candidate memories distilled from the session — decisions and their reasons,
+  conventions, gotchas, approaches tried and abandoned — and saves only the
+  ones you approve. Nothing is written silently: no draft is created behind
+  your back.
+- **The CLI**: `open-memex add "…"` with optional `--scope` / `--tags` / `--type`
+  / `--aliases`.
+
+**Aliases.** Each saved memory can carry up to 4 alternate phrasings
+(synonyms, another language's equivalent) that are indexed with it, so a
+question worded differently still finds the memory — "vacation days" finds the
+holiday policy. `init` asks once whether to enable this (default on); turn it
+off any time with `open-memex config set captureAliases false`.
 
 **Redaction.** Wrap anything sensitive in `<private>…</private>` and it is
 stripped before saving. Recognized secrets (API keys, tokens, high-entropy

package/README.zh-CN.md

@@ -180,6 +180,8 @@ open-memex init --client opencode --global --yes
 
 把原生插件并入你的用户级 `~/.config/opencode/opencode.json`（如果你已有的是 `opencode.jsonc`，就并进那个）——一次设置，每个项目都生效，不用逐项目 init。你会得到 5 个核心工具、关键词自动捕获和第一轮上下文注入。（配置文件里有注释时它不会动，`init` 会打印要手动加的那一行。）
 
+同一套安装同时支持两个 opencode 世代：`init` 会同时写入 opencode 1 的写法（`"plugin"`）和 opencode 2 的写法（`"plugins"`），每个宿主只读自己的那把。opencode 1 要求 **1.18.29 或更新版本**。接线和已装宿主版本对不上，`open-memex doctor` 会报出来。
+
 **opencode**（作为普通 MCP 消费者）：
 
 ```sh
@@ -238,7 +240,7 @@ open-memex uninstall --yes
 
 - **记忆数据**（首次使用时创建，不是 `init` 本身写的）：Windows 上是 `%APPDATA%\open-memex\`，macOS/Linux 上是 `~/.local/share/open-memex/`——你的记忆文件和搜索索引。`uninstall` 永不修改这里的任何东西。
 - **编辑器接线**（由 `open-memex uninstall` 移除）：
-  - opencode：一条 `"plugin"` 条目，并入 `~/.config/opencode/opencode.json`（或 `.jsonc`）。改名之前遗留的 `my-o-memory` 旧条目会同时被清掉。
+  - opencode：一条 `"plugin"` 条目（opencode 1）和一条 `"plugins"` 条目（opencode 2），并入 `~/.config/opencode/opencode.json`（或 `.jsonc`）。改名之前遗留的 `my-o-memory` 旧条目会同时被清掉。
   - VS Code / Cursor：用户级或项目级 MCP 配置里的一条 `open-memex` 服务器条目，外加 Copilot 指令文件里的一段 open-memex 内容（默认是用户级 `~/.copilot/copilot-instructions.md`；`--instructions project` 改为写进仓库的 `.github/copilot-instructions.md`，适合团队全员都用 open-memex 的情况）。
   - Visual Studio：solution 旁边的 `.mcp.json`。
   - Agent Skill：VS Code（`~/.copilot/skills/`）、Cursor（`~/.cursor/skills/`）或 per-project MCP 模式下的 opencode（`~/.config/opencode/skills/`）各自一个 `skills/open-memex/` 文件夹。
@@ -252,7 +254,10 @@ open-memex uninstall --yes
 
 - **关键词触发**（仅 opencode 原生插件）：说 `remember …`、`note that …`、`don't forget …`、`TIL …`、`save this …`——中文 `记住…` / `记一下` / `记录一下` / `别忘了…`——这句话就被存下来，不需要任何工具调用。捕获默认进当前 **project**；`remember for me …`、`记住我…`、`替我记…`、`我觉得…`、`我喜欢…` 这类"这是关于我"的信号会改为进 **personal**；`我们决定…`、`帮我们记住…` 等团队语境仍留在项目里。
 - **助手主动保存**：在任何编辑器里，你让助手记住某件事（或者你陈述了一个值得记的事实、它自己判断该保存），它会调用 `memory_add`。上面的路由是启发式规则；你可以明说"存到我的个人记忆"，或用 CLI 加 `--scope` 明确指定。
-- **CLI**：`open-memex add "…"`，可选 `--scope` / `--tags` / `--type`。
+- **检查点提议**：一个任务收尾时，助手会提议 1–3 条从这轮工作里提炼的候选记忆——决定及其理由、约定、踩过的坑、走过又放弃的路——只有你点头的那几条才存。不会有任何东西在你不知情时被写下来。
+- **CLI**：`open-memex add "…"`，可选 `--scope` / `--tags` / `--type` / `--aliases`。
+
+**别名。** 每条记忆可以带最多 4 个换一种说法（同义词、另一种语言的对应词），和记忆一起进索引，这样问法不同也能找到——比如搜 "vacation days" 能找到假期政策那条。`init` 时会问一次是否开启（默认开）；随时可用 `open-memex config set captureAliases false` 关掉。
 
 **脱敏。** 把敏感内容包在 `<private>…</private>` 里，它在保存前会被整段剥离。识别出的密钥（API key、token、高熵凭证）会被就地掩码——保留前 4 个字符（让你能认出是哪个 key），其余替换——记忆仍会保存。随时安全地预览一句话会被捕获成什么样：
 

package/dist/cli.js

@@ -10,7 +10,7 @@ import { proposeMemories, promoteMemory, listConflicts, resolveConflict, formatR
 import { getSyncStatus, formatSyncStatus, submitMemories } from "./submit.js";
 import { getPrStatus, formatPrStatus, applyPrStatus } from "./github.js";
 import { search, list, hitStateLabel } from "./retrieve/search.js";
-import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, } from "./store/markdown.js";
+import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, normalizeAliases, } from "./store/markdown.js";
 import { loadConfig } from "./config.js";
 import { paths, projectRoot } from "./paths.js";
 import { redact } from "./redact.js";
@@ -54,18 +54,25 @@ Example:
   open-memex search "deploy checklist" --scope both`,
     add: `Save a fact, preference, decision, or note to local memory.
 
-Usage: open-memex add "content" [--scope project|personal] [--type T] [--tag t1,t2]
+Usage: open-memex add "content" [--scope project|personal] [--type T] [--tag t1,t2] [--aliases "a;b"]
 
 Flags:
-  --scope   project (default) or personal (personal never leaves this machine)
-  --type    memory type (default: fact)
-  --tag     comma-separated tags
+  --scope    project (default) or personal (personal never leaves this machine)
+  --type     memory type (default: fact)
+  --tag      comma-separated tags
+  --aliases  alternate phrasings of this fact (up to 4), indexed with the
+             memory so differently-worded searches still match; separate
+             with ; (commas also accepted — use ; when an alias itself
+             contains one). Stored only when capture aliases are enabled
+             (init default)
 
 Example:
   open-memex add "We deploy on Fridays" --scope project --tag process`,
     supersede: `Replace a memory with a newer version. The old one is kept as history.
 
-Usage: open-memex supersede <id> "new content" [--type T] [--tag t1,t2]
+Usage: open-memex supersede <id> "new content" [--type T] [--tag t1,t2] [--aliases "a;b"]
+
+Without --aliases, the old memory's aliases carry over.
 
 Example:
   open-memex supersede 01ABC "We deploy on Thursdays now"`,
@@ -849,6 +856,18 @@ async function main() {
                     .map((t) => t.trim())
                     .filter(Boolean)
                 : [],
+            // D61: --aliases "phrase one; phrase two" (comma also accepted; use
+            // ; when an alias itself contains a comma). A bare --aliases with no
+            // value makes parseFlags yield "true" — treat that as absent. Stored
+            // only when the install enables capture aliases, redacted like content.
+            ...(typeof flags.aliases === "string" && flags.aliases !== "true" && cfg.captureAliases
+                ? {
+                    aliases: normalizeAliases(flags.aliases
+                        .split(/[;,]/)
+                        .map((a) => redact(a.trim(), cfg.redactPatterns).content)
+                        .filter(Boolean)),
+                }
+                : {}),
             source: "cli",
             created_at: rfc,
             updated_at: rfc,
@@ -888,6 +907,12 @@ async function main() {
                 tags: flags.tag
                     ? flags.tag.split(",").map((t) => t.trim()).filter(Boolean)
                     : undefined,
+                aliases: typeof flags.aliases === "string" && flags.aliases !== "true" && cfg.captureAliases
+                    ? normalizeAliases(flags.aliases
+                        .split(/[;,]/)
+                        .map((a) => redact(a.trim(), cfg.redactPatterns).content)
+                        .filter(Boolean))
+                    : undefined,
                 source: "cli",
             });
             upsertFromFile(oldMf);

package/dist/config.js

@@ -6,6 +6,7 @@ export const DEFAULT_CONFIG = {
     maxProfileItems: 5,
     injectOnFirstTurn: true,
     keywordCaptureEnabled: true,
+    captureAliases: true,
     keywordPatterns: [
         "^\\s*remember(?!\\s+for\\s+me)(?:\\s+that)?[:,]?\\s+(.+)$",
         "^\\s*(?:please\\s+)?(?:note|don'?t\\s+forget)(?:\\s+that)?[:,]?\\s+(.+)$",
@@ -79,6 +80,7 @@ export const SETTABLE_KEYS = {
     maxProfileItems: toNonNegInt,
     injectOnFirstTurn: toBool,
     keywordCaptureEnabled: toBool,
+    captureAliases: toBool,
     memoryDir: toRelativeDir,
     "sync.autoPull": toBool,
     logLevel: (v) => {

package/dist/distill-agents.js

@@ -57,7 +57,7 @@ export function distillAgentsMarkdown(opts) {
     // (D53: the checkpoint mechanism is gone).
     lines.push(`### Memory hygiene (open-memex)`);
     lines.push(``);
-    lines.push(`- When you finish a task the user would describe in one sentence, distill`, `  the session: propose 1–3 short memories capturing the useful`, `  conclusion — what was learned or decided, how an issue was resolved, what`, `  to avoid, where the authoritative doc lives — not the raw transcript.`, `  Save nothing without user approval.`, `- If the knowledge already lives in project docs, save a \`reference\` memory`, `  pointing at the doc instead of copying it.`);
+    lines.push(`- When you finish a task the user would describe in one sentence, distill`, `  the session: propose 1–3 short memories capturing the useful`, `  conclusion — what was learned or decided, how an issue was resolved, what`, `  to avoid, where the authoritative doc lives — not the raw transcript.`, `  Save nothing without user approval.`, `  Worth keeping: decisions and their reasons, preferences, conventions,`, `  gotchas, approaches tried and abandoned. Not worth keeping: one-off task`, `  details or anything re-derivable from the code.`, `- If the knowledge already lives in project docs, save a \`reference\` memory`, `  pointing at the doc instead of copying it.`, `- When saving via \`memory_add\`, attach 2–4 aliases (alternate phrasings,`, `  synonyms, equivalents in the user's other language) when the install has`, `  capture aliases enabled — they make reworded questions find the memory.`);
     lines.push(``);
     return lines.join("\n");
 }

package/dist/doctor.js

@@ -82,14 +82,17 @@ function lockingCheck() {
     }
 }
 /**
- * D59: patrol the opencode native-plugin entry. The D58 field failure was
- * silent — the entry was configured, the host never loaded it, and nothing
- * anywhere said why. Two death modes to catch:
- *   1. the entry's target file does not exist (package moved, nvm rolled
- *      to a new version dir, checkout deleted);
- *   2. the plugin's import closure runtime-imports @opencode-ai/plugin
- *      (or another host-only module the package does not depend on),
- *      which is unresolvable from a global install (D58 regression).
+ * D59/D60: patrol the opencode native-plugin entries. The D58 field failure
+ * was silent — the entry was configured, the host never loaded it, and
+ * nothing anywhere said why. Death modes to catch:
+ *   1. the entry's target does not exist (package moved, nvm rolled to a
+ *      new version dir, checkout deleted);
+ *   2. the plugin's import closure runtime-imports a host SDK package
+ *      (@opencode-ai/plugin on v1, @opencode/plugin on v2) — unresolvable
+ *      from a global install, the host silently skips the plugin (D58);
+ *   3. (D60) the config wires only the other host generation: an
+ *      opencode 2 host never reads the v1 `plugin` file entry (it demands
+ *      a directory under `plugins`), and opencode 1 cannot read `plugins`.
  * Read-only; only inspects the user-level opencode configs.
  */
 function opencodePluginCheck() {
@@ -97,8 +100,18 @@ function opencodePluginCheck() {
     try {
         const jsonPath = opencodeGlobalConfigPath();
         const candidates = [jsonPath, jsonPath.replace(/\.json$/, ".jsonc")];
-        const entries = [];
+        const v1Entries = [];
+        const v2Entries = [];
         let sawConfig = false;
+        const v2EntryPackage = (entry) => {
+            if (typeof entry === "string")
+                return entry;
+            if (entry !== null && typeof entry === "object" && "package" in entry) {
+                const p = entry.package;
+                return typeof p === "string" ? p : null;
+            }
+            return null;
+        };
         for (const f of candidates) {
             if (!fs.existsSync(f))
                 continue;
@@ -106,17 +119,24 @@ function opencodePluginCheck() {
             const text = fs.readFileSync(f, "utf8");
             try {
                 const doc = JSON.parse(text);
-                const list = Array.isArray(doc.plugin) ? doc.plugin : [];
-                for (const e of list) {
-                    if (typeof e === "string")
-                        entries.push(e);
+                if (Array.isArray(doc.plugin)) {
+                    for (const e of doc.plugin)
+                        if (typeof e === "string")
+                            v1Entries.push(e);
+                }
+                if (Array.isArray(doc.plugins)) {
+                    for (const e of doc.plugins) {
+                        const p = v2EntryPackage(e);
+                        if (p !== null)
+                            v2Entries.push(p);
+                    }
                 }
             }
             catch {
                 // JSONC (comments/trailing commas): fall back to scanning quoted
                 // strings for plugin entries.
                 for (const m of text.matchAll(/"(file:[^"]+|[^"]+\.(?:ts|js|mts|mjs))"/g)) {
-                    entries.push(m[1]);
+                    v1Entries.push(m[1]);
                 }
             }
         }
@@ -124,24 +144,71 @@ function opencodePluginCheck() {
             return { name, ok: true, detail: "no global opencode config found (skipped)" };
         }
         const problems = [];
-        const RUNTIME_SDK_IMPORT = /^\s*import\s+(?!type\b)[^;]*?["']@opencode-ai\/plugin(?:\/[^"']*)?["']/m;
-        const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode-ai\/plugin(?:\/[^"']*)?["']\s*\)/;
+        // Host SDK packages per generation; a runtime import of either from a
+        // globally installed plugin cannot resolve (D58).
+        const RUNTIME_SDK_IMPORT = /^\s*import\s+(?!type\b)[^;]*?["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']/m;
+        const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']\s*\)/;
+        const toPath = (entry) => {
+            try {
+                return entry.startsWith("file:") ? fileURLToPath(entry) : entry;
+            }
+            catch {
+                return null;
+            }
+        };
         // An entry is ours when its path names the package, or when the target
         // file carries the plugin's "[open-memex]" log marker (source checkouts
         // can live at any path).
-        const isOurEntry = (entry) => {
-            if (entry.includes("open-memex"))
-                return true;
+        const fileHasMarker = (target) => {
             try {
-                const target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-                if (!fs.existsSync(target))
-                    return false;
                 return fs.readFileSync(target, "utf8").slice(0, 65536).includes("[open-memex]");
             }
             catch {
                 return false;
             }
         };
+        /** Resolve an OpenCode 2 directory entry to its entry file, if any. */
+        const resolveV2EntryFile = (target) => {
+            try {
+                if (!fs.existsSync(target))
+                    return null;
+                if (fs.statSync(target).isFile())
+                    return target;
+                for (const idx of ["index.ts", "index.js", "index.mts", "index.mjs"]) {
+                    const p = path.join(target, idx);
+                    if (fs.existsSync(p))
+                        return p;
+                }
+                const pkgJson = path.join(target, "package.json");
+                if (fs.existsSync(pkgJson)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+                    if (typeof pkg.main === "string") {
+                        const main = path.join(target, pkg.main);
+                        if (fs.existsSync(main))
+                            return main;
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        };
+        const isOursV1 = (entry) => {
+            if (entry.includes("open-memex"))
+                return true;
+            const target = toPath(entry);
+            return target !== null && fs.existsSync(target) && fileHasMarker(target);
+        };
+        const isOursV2 = (entry) => {
+            if (entry.includes("open-memex"))
+                return true;
+            const target = toPath(entry);
+            if (target === null)
+                return false;
+            const file = resolveV2EntryFile(target);
+            return file !== null && fileHasMarker(file);
+        };
         const scanSdkImports = (entryFile) => {
             // Walk the entry's relative-import closure looking for host-SDK
             // runtime imports (type-only imports are erased and fine).
@@ -176,16 +243,14 @@ function opencodePluginCheck() {
             }
             return offenders;
         };
-        const ours = entries.filter(isOurEntry);
-        if (ours.length === 0) {
+        const oursV1 = v1Entries.filter(isOursV1);
+        const oursV2 = v2Entries.filter(isOursV2);
+        if (oursV1.length === 0 && oursV2.length === 0) {
             return { name, ok: true, detail: "no global plugin entry (per-project or MCP wiring is not checked)" };
         }
-        for (const entry of ours) {
-            let target;
-            try {
-                target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-            }
-            catch {
+        for (const entry of oursV1) {
+            const target = toPath(entry);
+            if (target === null) {
                 problems.push(`entry "${entry}" is not a parseable file URL`);
                 continue;
             }
@@ -194,16 +259,62 @@ function opencodePluginCheck() {
                 continue;
             }
             for (const f of scanSdkImports(target)) {
-                problems.push(`${f} runtime-imports @opencode-ai/plugin — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
+                problems.push(`${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
+            }
+        }
+        for (const entry of oursV2) {
+            // A bare package name ("open-memex" via `opencode plugin add`) is
+            // resolved by the host's plugin manager; there is no local path to
+            // verify.
+            const isPackageName = !entry.startsWith("file:") &&
+                !entry.startsWith(".") &&
+                !path.isAbsolute(entry) &&
+                !/^[a-zA-Z]:[\\/]/.test(entry);
+            if (isPackageName)
+                continue;
+            const target = toPath(entry);
+            if (target === null || !fs.existsSync(target)) {
+                problems.push(`opencode 2 entry "${entry}" does not resolve to an existing path — run \`open-memex init --client opencode --global --force\` to re-point it`);
+                continue;
+            }
+            const entryFile = resolveV2EntryFile(target);
+            if (entryFile === null) {
+                problems.push(`opencode 2 entry "${entry}" has no loadable plugin file (looked for index.ts/index.js and package.json main)`);
+                continue;
+            }
+            for (const f of scanSdkImports(entryFile)) {
+                problems.push(`${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
             }
         }
+        // D60: generation mismatch — the config wires only the generation the
+        // installed host cannot read. Best-effort: no binary, no opinion.
+        let hostMajor = null;
+        try {
+            const out = execFileSync("opencode", ["--version"], {
+                timeout: 3000,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            const m = out.match(/(\d+)\.(\d+)\.(\d+)/);
+            if (m)
+                hostMajor = Number(m[1]);
+        }
+        catch {
+            hostMajor = null;
+        }
+        if (hostMajor !== null && hostMajor >= 2 && oursV1.length > 0 && oursV2.length === 0) {
+            problems.push(`the installed opencode is v${hostMajor} but the config only has the opencode 1 "plugin" entry — v2 loads directories from "plugins" and will silently skip this plugin; run \`open-memex init --client opencode --global --force\` to add the v2 entry`);
+        }
+        else if (hostMajor === 1 && oursV2.length > 0 && oursV1.length === 0) {
+            problems.push(`the installed opencode is v1 but the config only has the opencode 2 "plugins" entry — v1 reads the "plugin" key and will not load this plugin; run \`open-memex init --client opencode --global --force\` to add the v1 entry`);
+        }
         if (problems.length > 0) {
             return { name, ok: false, detail: problems.join("; ") };
         }
         return {
             name,
             ok: true,
-            detail: `${ours.length} plugin ${ours.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
+            detail: `${oursV1.length + oursV2.length} plugin ${oursV1.length + oursV2.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
         };
     }
     catch (err) {

package/dist/index.js

@@ -1,127 +1,35 @@
-import { loadConfig } from "./config.js";
-import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "./scope.js";
-import { db } from "./store/db.js";
-import { syncScope, upsertFromFile } from "./store/sync.js";
-import { scopeHasFiles } from "./store/migrate.js";
-import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, } from "./store/markdown.js";
-import { buildContextBlock } from "./retrieve/inject.js";
-import { detectKeywords } from "./capture/keywords.js";
-import { findDuplicates } from "./store/lifecycle.js";
-import { redact } from "./redact.js";
+import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
 import { makeTools } from "./tools/memory.js";
-const plugin = async ({ worktree, directory }) => {
-    const cfg = loadConfig();
+import { v2Plugin } from "./opencode-v2.js";
+/**
+ * One entrypoint, both opencode generations (D60):
+ * - OpenCode 2 structurally decodes the default export as `{ id, setup }`
+ *   and ignores `server` (see src/opencode-v2.ts).
+ * - OpenCode 1 (≥1.18.29) reads `server` off the same default export and
+ *   ignores `setup` — the function below is the v1 plugin exactly as it
+ *   behaved before dual support.
+ * Neither host runtime-imports an SDK package from this file: v1's SDK is
+ * type-only (D58), and v2's decode is structural.
+ */
+const server = async ({ worktree, directory }) => {
     const roots = worktree || directory || process.cwd();
-    const scope = resolveProjectScope(roots);
-    // Init DB and one-shot sync of markdown -> index on plugin load.
-    try {
-        db();
-        syncScope(scope.key);
-        syncScope(PERSONAL_SCOPE.key);
-        if (cfg.logLevel === "debug") {
-            console.log(`[open-memex] loaded. scope=${scope.key}`);
-        }
-        // If a git remote was added *after* memories were first captured, the
-        // scope key changes (cwd-hash -> origin-hash). Detect the legacy dir on
-        // disk and tell the user how to migrate. We do NOT auto-migrate: two
-        // different repos at the same cwd would collide.
-        const cwdScope = resolveCwdScope(roots);
-        if (cwdScope.key !== scope.key && scopeHasFiles(cwdScope.key)) {
-            console.warn(`[open-memex] found memories under legacy scope key "${cwdScope.key}". ` +
-                `Current project scope is "${scope.key}". ` +
-                `To move them: npm run cli -- migrate --from ${cwdScope.key}`);
-        }
-    }
-    catch (err) {
-        console.error("[open-memex] init failed:", err);
-    }
-    const tools = makeTools(() => scope, cfg);
-    const injectedSessions = new Set();
+    const state = bootstrapPlugin(roots);
+    const tools = makeTools(() => state.scope, state.cfg);
     return {
         tool: tools,
         async "chat.message"(_input, output) {
-            if (!cfg.keywordCaptureEnabled)
-                return;
             const parts = (output.parts ?? []);
             const text = parts
                 .map((p) => (p?.type === "text" ? p.text ?? "" : ""))
                 .filter(Boolean)
                 .join("\n");
-            if (!text)
-                return;
-            const hits = detectKeywords(text, cfg);
-            for (const h of hits) {
-                const { content, hadSecret, matchedPattern } = redact(h.content, cfg.redactPatterns);
-                // Secrets are masked (first 4 chars kept) and the capture proceeds;
-                // skip only when nothing usable remains.
-                if (content.length === 0)
-                    continue;
-                if (hadSecret && cfg.logLevel === "debug") {
-                    console.log(`[open-memex] keyword capture masked secret (${matchedPattern})`);
-                }
-                // Personal patterns ("remember for me" / "记住（个人）") force the personal scope.
-                const target = h.personal ? PERSONAL_SCOPE : scope;
-                // Dedup (§3.4): skip exact duplicates captured before.
-                if (findDuplicates(target.key, content).exact)
-                    continue;
-                const now = Date.now();
-                const rfc = msToRfc3339(now);
-                const fm = {
-                    id: ulid(),
-                    schema_version: 2,
-                    scope_key: target.key,
-                    scope: target.kind === "project" ? "project" : "personal",
-                    visibility: target.kind === "project" ? "internal" : "private",
-                    project_name: target.projectName,
-                    type: "fact",
-                    role: "knowledge",
-                    importance: "normal",
-                    status: "active",
-                    tags: ["keyword"],
-                    source: "keyword",
-                    created_at: rfc,
-                    updated_at: rfc,
-                    supersedes: null,
-                    superseded_by: null,
-                    review_state: "draft",
-                    proposed_by: null,
-                    approved_by: null,
-                    derived_from: null,
-                    review_note: null,
-                    review_history: [],
-                };
-                try {
-                    const { filePath } = writeMemoryFile(fm, content);
-                    const mf = readMemoryFile(filePath);
-                    if (mf)
-                        upsertFromFile(mf);
-                    // Capture feedback: always visible (not debug-only) — the user said
-                    // "记住…", they should see that it landed. The opencode plugin API
-                    // offers no toast channel, so the plugin log is the feedback surface.
-                    const preview = content.length > 60 ? content.slice(0, 60) + "…" : content;
-                    console.log(`[open-memex] remembered → ${target.kind} scope: "${preview}"`);
-                }
-                catch (err) {
-                    console.error("[open-memex] keyword capture failed:", err);
-                }
-            }
+            captureFromText(text, state);
         },
         async "experimental.chat.system.transform"(input, output) {
-            if (!cfg.injectOnFirstTurn)
-                return;
-            const sid = input.sessionID ?? "";
-            if (injectedSessions.has(sid))
-                return;
-            injectedSessions.add(sid);
-            try {
-                const block = buildContextBlock(scope, cfg);
-                if (block)
-                    output.system.push(block);
-            }
-            catch (err) {
-                console.error("[open-memex] context injection failed:", err);
-            }
+            injectOnce(input.sessionID ?? "", state, (block) => {
+                output.system.push(block);
+            });
         },
     };
 };
-export default plugin;
+export default { id: PLUGIN_ID, setup: v2Plugin.setup, server };