open-memex 0.6.2-alpha.1 → 0.7.0-alpha.1

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.

package/CHANGELOG.md

@@ -9,6 +9,23 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## 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 +147,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

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/` 文件夹。

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 };

package/dist/init.js

@@ -271,6 +271,15 @@ function opencodePluginUrl() {
     const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
     return pathToFileURL(path.join(pkgRoot, "src", "index.ts")).href;
 }
+/**
+ * D60: the same plugin directory, in the form OpenCode 2 wants. v2 rejects
+ * file entries in `plugins` ("configured plugin path must be a directory")
+ * and loads `<dir>/index.ts` instead.
+ */
+function opencodePluginDir() {
+    const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    return path.join(pkgRoot, "src");
+}
 /**
  * D46: opencode's user-level config. opencode reads `~/.config/opencode/`
  * (`$XDG_CONFIG_HOME` when set) on every platform; a `plugin` entry there
@@ -297,6 +306,63 @@ export function mergePluginEntry(doc, url, force) {
         list.push(url);
     return "added";
 }
+/** The package path an OpenCode 2 `plugins` entry refers to, if any. */
+function 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;
+}
+/**
+ * D60: pure merge of the open-memex directory into the `plugins` array
+ * (the OpenCode 2 spelling). An existing open-memex entry (any form)
+ * counts as present; with force, stale open-memex entries are replaced
+ * by `dir`. Same "added"/"kept" contract as mergePluginEntry.
+ */
+export function mergeV2PluginEntry(doc, dir, force) {
+    let plugins = doc["plugins"];
+    if (!Array.isArray(plugins)) {
+        plugins = [];
+        doc["plugins"] = plugins;
+    }
+    const list = plugins;
+    const ours = (e) => (v2EntryPackage(e) ?? "").includes("open-memex");
+    if (!force && list.some(ours))
+        return "kept";
+    for (let i = list.length - 1; i >= 0; i--) {
+        const p = v2EntryPackage(list[i]);
+        if (p === dir) {
+            if (!force)
+                return "kept";
+            list.splice(i, 1);
+        }
+        else if (force && ours(list[i])) {
+            list.splice(i, 1);
+        }
+    }
+    list.push(dir);
+    return "added";
+}
+/**
+ * Pure removal of open-memex entries from the `plugins` array (OpenCode 2
+ * spelling — strings and `{package}` objects). Drops the key when empty.
+ */
+export function removeV2PluginEntry(doc, match) {
+    const plugins = doc["plugins"];
+    if (!Array.isArray(plugins))
+        return "absent";
+    const kept = plugins.filter((p) => !(v2EntryPackage(p) ?? "").includes(match));
+    if (kept.length === plugins.length)
+        return "absent";
+    if (kept.length === 0)
+        delete doc["plugins"];
+    else
+        doc["plugins"] = kept;
+    return "removed";
+}
 /**
  * D46: wire the native plugin at the opencode user level — the one-time
  * global setup. Merges into the existing config when it parses as JSON;
@@ -309,6 +375,7 @@ function writeOpencodeGlobalPlugin(force) {
         .map((f) => path.join(dir, f))
         .find((f) => fs.existsSync(f)) ?? path.join(dir, "opencode.json");
     const url = opencodePluginUrl();
+    const pluginDir = opencodePluginDir();
     let doc = {};
     if (fs.existsSync(file)) {
         try {
@@ -316,7 +383,8 @@ function writeOpencodeGlobalPlugin(force) {
         }
         catch {
             console.log(`  ! ${file} has comments or invalid JSON — left untouched, fix it manually.`);
-            console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] to it.`);
+            console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] (opencode 1)`);
+            console.log(`    and "plugins": ["${pluginDir}"] (opencode 2) to it.`);
             console.log(`    Also remove any "${LEGACY_PACKAGE_NAME}" entries from "plugin" (stale — package renamed).`);
             return null;
         }
@@ -325,8 +393,12 @@ function writeOpencodeGlobalPlugin(force) {
     // alongside the new one — it writes to the OLD data dir, silently splitting
     // memories in two. Drop it wherever init touches the plugin list.
     const staleRemoved = removePluginEntry(doc, LEGACY_PACKAGE_NAME) === "removed";
+    removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
     const merged = mergePluginEntry(doc, url, force);
-    if (merged === "kept" && !staleRemoved) {
+    // D60: write both key generations — opencode 1 reads `plugin`, opencode 2
+    // reads `plugins`; each host ignores the other's key.
+    const mergedV2 = mergeV2PluginEntry(doc, pluginDir, force);
+    if (merged === "kept" && mergedV2 === "kept" && !staleRemoved) {
         console.log(`  = ${file} already loads the open-memex plugin — left as is (use --force to overwrite)`);
         return file;
     }
@@ -334,7 +406,7 @@ function writeOpencodeGlobalPlugin(force) {
     fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     if (staleRemoved)
         console.log(`  - ${file} (stale my-o-memory plugin entry removed — package renamed to open-memex)`);
-    if (merged === "added")
+    if (merged === "added" || mergedV2 === "added")
         console.log(`  + ${file} (native plugin — works in every project, no per-project init needed)`);
     return file;
 }
@@ -882,13 +954,16 @@ function removeOpencodePluginFile(file) {
     const doc = parseJsonConfig(fs.readFileSync(file, "utf8"));
     if (doc === null) {
         console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
-        console.error(`    Delete the open-memex URL from the "plugin" array.`);
+        console.error(`    Delete the open-memex URL from the "plugin" array and the open-memex path from "plugins".`);
         return null;
     }
     const res = removePluginEntry(doc, "open-memex");
+    // D60: the v2 `plugins` entry goes too (strings and {package} objects).
+    const resV2 = removeV2PluginEntry(doc, "open-memex");
     // F30: also sweep the pre-rename leftover — see removeServerEntryFile.
     const stale = removePluginEntry(doc, LEGACY_PACKAGE_NAME);
-    if (res === "removed" || stale === "removed") {
+    removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
+    if (res === "removed" || resV2 === "removed" || stale === "removed") {
         fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
         console.log(`  - ${file} (memory-plugin entries removed)`);
         return "removed";