open-memex 0.4.0 → 0.5.0-alpha.2

package/dist/init.js

@@ -4,6 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
+import { pathToFileURL, fileURLToPath } from "node:url";
 import { DEFAULT_CONFIG, saveConfig } from "./config.js";
 import { projectRoot } from "./paths.js";
 const MARKER = "<!-- open-memex -->";
@@ -100,6 +101,72 @@ function writeMcpJson(root, client, force) {
     const dir = client === "cursor" ? path.join(root, ".cursor") : path.join(root, ".vscode");
     const file = path.join(dir, "mcp.json");
     const sectionKey = client === "cursor" ? "mcpServers" : "servers";
+    const { entry, durable } = stdioServerEntry(client);
+    const written = writeServerEntryFile(file, sectionKey, entry, force, true);
+    if (written)
+        warnNonDurable(durable);
+    return written;
+}
+/**
+ * D45: user-level MCP config path — `init --global` writes here so one init
+ * covers all projects. `platform` and `home` are parameters (default: current)
+ * so tests can cover all OS layouts without mocking.
+ */
+export function userMcpConfigPath(client, platform = process.platform, home = os.homedir()) {
+    if (client === "cursor")
+        return path.join(home, ".cursor", "mcp.json");
+    if (platform === "win32") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        return path.join(appData, "Code", "User", "mcp.json");
+    }
+    if (platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Code", "User", "mcp.json");
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+    return path.join(xdg, "Code", "User", "mcp.json");
+}
+/** The open-memex server entry, same shape init writes at project level. */
+function stdioServerEntry(client) {
+    // D17: resolve the server command at init time — a one-shot npx leaves no bin behind.
+    const mc = resolveMcpCommand();
+    const entry = client === "cursor"
+        ? { command: mc.command, args: mc.args }
+        : {
+            type: "stdio",
+            command: mc.command,
+            args: mc.args,
+            // VS Code substitutes ${workspaceFolder} per window, so the server
+            // starts with the open project as cwd and scope resolution just works.
+            cwd: "${workspaceFolder}",
+        };
+    return { entry, durable: mc.durable };
+}
+/** Warn when init had to fall back to an npx-based server command. */
+function warnNonDurable(durable) {
+    if (durable)
+        return;
+    console.log(`  ! no durable \`open-memex\` on PATH (one-shot npx?) — wrote an npx-based command.`);
+    console.log(`    For faster startup: \`npm i -g ${ALPHA_TAG}\`, then re-run \`open-memex init --force\`.`);
+}
+/**
+ * Pure merge of one server entry into a parsed config doc.
+ * Returns "added" when the entry was written, "kept" when an entry already
+ * existed and force was not set. Mutates `doc`.
+ */
+export function mergeServerEntry(doc, sectionKey, entry, force) {
+    const section = (doc[sectionKey] ??= {});
+    if (section["open-memex"] && !force)
+        return "kept";
+    section["open-memex"] = entry;
+    return "added";
+}
+/**
+ * Read (or create) a JSON config file, merge the open-memex server entry, write
+ * it back. Existing files are merged, never clobbered; invalid JSON is left
+ * untouched. `mkdir` controls whether parent dirs are created (user-level
+ * configs) or expected to exist via the project root.
+ */
+function writeServerEntryFile(file, sectionKey, entry, force, mkdir) {
     let doc = {};
     if (fs.existsSync(file)) {
         try {
@@ -110,29 +177,93 @@ function writeMcpJson(root, client, force) {
             return null;
         }
     }
-    const section = (doc[sectionKey] ??= {});
-    if (section["open-memex"] && !force) {
+    const merged = mergeServerEntry(doc, sectionKey, entry, force);
+    if (merged === "kept") {
         console.log(`  = ${file} already configures open-memex — left as is (use --force to overwrite)`);
         return file;
     }
-    // D17: resolve the server command at init time — a one-shot npx leaves no bin behind.
-    const mc = resolveMcpCommand();
-    section["open-memex"] =
-        client === "cursor"
-            ? { command: mc.command, args: mc.args }
-            : {
-                type: "stdio",
-                command: mc.command,
-                args: mc.args,
-                cwd: "${workspaceFolder}",
-            };
-    fs.mkdirSync(dir, { recursive: true });
+    if (mkdir)
+        fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     console.log(`  + ${file}`);
-    if (!mc.durable) {
-        console.log(`  ! no durable \`open-memex\` on PATH (one-shot npx?) — wrote an npx-based command.`);
-        console.log(`    For faster startup: \`npm i -g ${ALPHA_TAG}\`, then re-run \`open-memex init --force\`.`);
+    return file;
+}
+/** D45: `init --global` — one-time user-level wiring for VS Code / Cursor. */
+function writeGlobalMcpJson(client, force) {
+    const file = userMcpConfigPath(client);
+    const sectionKey = client === "cursor" ? "mcpServers" : "servers";
+    const { entry, durable } = stdioServerEntry(client);
+    const written = writeServerEntryFile(file, sectionKey, entry, force, true);
+    if (written) {
+        warnNonDurable(durable);
+        const projFile = client === "cursor" ? ".cursor/mcp.json" : ".vscode/mcp.json";
+        console.log(`  i user-level config — the open-memex MCP server now starts in every project.`);
+        console.log(`    (a per-project ${projFile} still wins if a project defines its own)`);
+    }
+    return written;
+}
+/** Where this installed copy's opencode native plugin entry point lives. */
+function opencodePluginUrl() {
+    // init.ts sits in <pkg>/src — the plugin entry is <pkg>/src/index.ts.
+    const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    return pathToFileURL(path.join(pkgRoot, "src", "index.ts")).href;
+}
+/**
+ * D46: opencode's user-level config. opencode reads `~/.config/opencode/`
+ * (`$XDG_CONFIG_HOME` when set) on every platform; a `plugin` entry there
+ * loads open-memex in every project with no per-project init.
+ */
+export function opencodeGlobalConfigPath(home = os.homedir()) {
+    return path.join(opencodeConfigDir(home, process.env.XDG_CONFIG_HOME), "opencode.json");
+}
+/**
+ * Pure merge of the open-memex plugin URL into a parsed opencode config doc.
+ * Creates the `plugin` array when missing; never duplicates the URL.
+ * Returns "added" when the doc changed, "kept" when already present.
+ */
+export function mergePluginEntry(doc, url, force) {
+    let plugins = doc["plugin"];
+    if (!Array.isArray(plugins)) {
+        plugins = [];
+        doc["plugin"] = plugins;
     }
+    const list = plugins;
+    if (list.includes(url) && !force)
+        return "kept";
+    if (!list.includes(url))
+        list.push(url);
+    return "added";
+}
+/**
+ * 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;
+ * a file with comments (JSONC) is left untouched with a manual hint instead
+ * of being clobbered.
+ */
+function writeOpencodeGlobalPlugin(force) {
+    const dir = path.dirname(opencodeGlobalConfigPath());
+    const file = ["opencode.jsonc", "opencode.json"]
+        .map((f) => path.join(dir, f))
+        .find((f) => fs.existsSync(f)) ?? path.join(dir, "opencode.json");
+    const url = opencodePluginUrl();
+    let doc = {};
+    if (fs.existsSync(file)) {
+        try {
+            doc = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        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.`);
+            return null;
+        }
+    }
+    if (mergePluginEntry(doc, url, force) === "kept") {
+        console.log(`  = ${file} already loads the open-memex plugin — left as is (use --force to overwrite)`);
+        return file;
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+    console.log(`  + ${file} (native plugin — works in every project, no per-project init needed)`);
     return file;
 }
 /** opencode MCP config: project-level opencode.jsonc, `type: "local"` + command array (v1 format). */
@@ -293,17 +424,133 @@ async function promptInstructionsScope() {
         rl.close();
     }
 }
+/** D45: ask whether the MCP server config should be project-level or user-level. */
+async function promptConfigLevel() {
+    console.log("Where should the MCP server config live?");
+    console.log("  1) this project only — .vscode/mcp.json (or .cursor/mcp.json)");
+    console.log("  2) user-level — all projects, init once (VS Code / Cursor)");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await rl.question("Choice [1]: ")).trim();
+        return ans === "2";
+    }
+    finally {
+        rl.close();
+    }
+}
+function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `name` resolves on PATH (honors .cmd/.exe on Windows). */
+function binOnPath(name, pathEnv, platform) {
+    const names = platform === "win32" ? [`${name}.cmd`, `${name}.exe`, name] : [name];
+    return pathEnv
+        .split(path.delimiter)
+        .filter((d) => d && !d.includes("_npx"))
+        .some((d) => names.some((n) => exists(path.join(d, n))));
+}
+function opencodeConfigDir(home, xdg) {
+    return path.join(xdg || path.join(home, ".config"), "opencode");
+}
+/**
+ * D46: detect which supported editors are installed. Used when `init` runs
+ * without --client — one init wires every detected editor (user-level where
+ * the editor supports it). Visual Studio is included only when the project
+ * has a solution file, since VS config is solution-scoped by design.
+ */
+export function detectInstalledClients(env = {}) {
+    const platform = env.platform ?? process.platform;
+    const pathEnv = env.pathEnv ?? process.env.PATH ?? "";
+    const home = env.home ?? os.homedir();
+    const found = [];
+    // VS Code: bin on PATH, well-known install location, or an existing
+    // user-level MCP config (a previous init counts as installed).
+    const vscodeInstallPaths = platform === "win32"
+        ? [path.join(home, "AppData", "Local", "Programs", "Microsoft VS Code", "Code.exe")]
+        : platform === "darwin"
+            ? ["/Applications/Visual Studio Code.app"]
+            : ["/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code"];
+    if (binOnPath("code", pathEnv, platform) ||
+        vscodeInstallPaths.some(exists) ||
+        exists(userMcpConfigPath("vscode", platform, home))) {
+        found.push("vscode");
+    }
+    // Cursor: bin on PATH or its user config dir exists.
+    if (binOnPath("cursor", pathEnv, platform) || exists(path.join(home, ".cursor"))) {
+        found.push("cursor");
+    }
+    // opencode: bin on PATH or its global config dir exists.
+    const xdg = env.xdgConfigHome ?? process.env.XDG_CONFIG_HOME;
+    if (binOnPath("opencode", pathEnv, platform) || exists(opencodeConfigDir(home, xdg))) {
+        found.push("opencode");
+    }
+    // Visual Studio: solution-scoped — only when the project has a .sln.
+    let hasSln = false;
+    try {
+        hasSln = fs.readdirSync(env.root ?? projectRoot()).some((f) => f.toLowerCase().endsWith(".sln"));
+    }
+    catch {
+        hasSln = false;
+    }
+    if (hasSln)
+        found.push("visualstudio");
+    return found;
+}
 export async function initProject(opts) {
     const interactive = !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
-    let client = normalizeClient(opts.client ?? "");
-    if (client && !INIT_CLIENTS.includes(client)) {
+    const explicit = normalizeClient(opts.client ?? "");
+    if (explicit && !INIT_CLIENTS.includes(explicit)) {
         console.error(`unknown client "${opts.client}" (${INIT_CLIENTS.join("|")})`);
         process.exit(1);
     }
-    if (!client && interactive)
-        client = (await promptClient()) ?? "";
-    if (!client && !interactive)
-        client = "vscode"; // historical default for scripts / one-shot npx
+    // D46: no --client → auto-detect installed editors and wire them all
+    // (user-level where the editor supports it — init once). An explicit
+    // --client keeps the old single-editor behavior.
+    let clients;
+    let autoGlobal = false;
+    if (explicit) {
+        clients = [explicit];
+    }
+    else if (interactive) {
+        const detected = detectInstalledClients();
+        if (detected.length === 0) {
+            console.log("  - no supported editors detected — editor setup skipped");
+            clients = [];
+        }
+        else {
+            console.log(`Detected editors: ${detected.join(", ")}`);
+            const all = await askBool("Wire up open-memex in all of them (one-time, user-level where supported)?", true);
+            if (all) {
+                clients = detected;
+                autoGlobal = true;
+            }
+            else {
+                const one = await promptClient();
+                clients = one ? [one] : [];
+            }
+        }
+    }
+    else {
+        clients = detectInstalledClients();
+        autoGlobal = true;
+        if (clients.length === 0) {
+            console.log("  - no supported editors detected — editor setup skipped");
+        }
+        else {
+            console.log(`Detected editors: ${clients.join(", ")} — wiring all (use --client to pick one)`);
+        }
+    }
+    let global = !!opts.global || autoGlobal;
+    // The project-vs-user-level choice only applies to an explicit single
+    // client; auto mode is user-level by design (init once).
+    if (explicit && !global && interactive && (clients[0] === "vscode" || clients[0] === "cursor")) {
+        global = await promptConfigLevel();
+    }
     let scope = "personal";
     if (opts.instructions) {
         if (opts.instructions !== "personal" && opts.instructions !== "project") {
@@ -332,17 +579,39 @@ export async function initProject(opts) {
     }
     const root = projectRoot();
     console.log(`open-memex init — project root: ${root}`);
-    if (client) {
-        writeMcpJson(root, client, opts.force);
+    for (const client of clients) {
+        if (client === "vscode" || client === "cursor") {
+            if (global)
+                writeGlobalMcpJson(client, opts.force);
+            else
+                writeMcpJson(root, client, opts.force);
+        }
+        else if (client === "opencode") {
+            // D46: the native plugin is the one-time global setup; without --global
+            // (explicit single-client mode) keep the per-project plain-MCP config.
+            if (global)
+                writeOpencodeGlobalPlugin(opts.force);
+            else
+                writeMcpJson(root, client, opts.force);
+        }
+        else if (client === "visualstudio") {
+            if (explicit && global) {
+                console.log(`  - visualstudio: --global not supported — VS uses solution-level .mcp.json by design.`);
+            }
+            else {
+                writeMcpJson(root, client, opts.force);
+            }
+        }
+    }
+    if (clients.length === 0) {
+        console.log("  - editor setup skipped");
+    }
+    else if (clients.some((c) => c !== "opencode")) {
         // copilot-instructions.md is VS Code/Cursor-shaped; opencode as a plain MCP
         // consumer already gets the guidance from the tool descriptions (D16).
         // D22: personal scope (default) writes to the Copilot user-level location
         // so the repo stays clean for teammates without open-memex.
-        if (client !== "opencode")
-            writeInstructions(root, scope, client);
-    }
-    else {
-        console.log("  - editor setup skipped");
+        writeInstructions(root, scope, clients.find((c) => c !== "opencode"));
     }
     console.log(`\nDone. Reload your editor window to start the open-memex MCP server.`);
 }

package/dist/store/v2migrate.js

@@ -83,23 +83,45 @@ export function planConversion(filePath, memoriesRoot) {
     return { fm, body, fromPath: filePath, toPath, changes };
 }
 /**
- * Merge a legacy `my-o-memory` data root into the current `open-memex` root.
- * The old dir is renamed to a dated backup — never deleted. Returns the
- * backup path, or null when no legacy dir exists.
+ * Locate a legacy `my-o-memory` data root next to the current root.
+ * Pure lookup — no disk writes.
  */
-function migrateLegacyDataRoot(dryRun) {
+export function findLegacyDataRoot() {
     const { root } = paths();
     const legacy = path.join(path.dirname(root), "my-o-memory");
     if (!fs.existsSync(legacy) || !fs.statSync(legacy).isDirectory())
         return null;
+    return legacy;
+}
+/** Dated backup path for a legacy data root. Pure — no disk writes. */
+export function legacyBackupPath(legacy) {
     const stamp = new Date().toISOString().slice(0, 10);
-    const backup = `${legacy}.backup-${stamp}`;
-    if (!dryRun) {
-        const legacyMem = path.join(legacy, "memories");
-        if (fs.existsSync(legacyMem)) {
-            for (const entry of fs.readdirSync(legacyMem)) {
-                const src = path.join(legacyMem, entry);
-                const dst = path.join(root, "memories", entry);
+    return `${legacy}.backup-${stamp}`;
+}
+/**
+ * Merge a legacy `my-o-memory` data root into the current `open-memex` root.
+ * The old dir is renamed to a dated backup — never deleted.
+ * Failures throw an actionable Error (no raw syscall dump): on Windows the
+ * backup rename typically fails with EPERM when another program holds the
+ * folder open.
+ */
+function mergeLegacyDataRoot(legacy, backup) {
+    const { memories } = paths();
+    const fail = (where, err) => {
+        const code = err?.code;
+        throw new Error(`could not ${where} (${legacy})` +
+            (code ? ` [${code}]` : "") +
+            `. Another program may be holding the folder open (e.g. a running MCP server, editor, or antivirus). ` +
+            `Your memories are safe — nothing was deleted. Close the program and re-run ` +
+            `\`open-memex migrate --to-v2\`, or rename the folder to ${backup} yourself and re-run.`);
+    };
+    const legacyMem = path.join(legacy, "memories");
+    if (fs.existsSync(legacyMem)) {
+        fs.mkdirSync(memories, { recursive: true });
+        for (const entry of fs.readdirSync(legacyMem)) {
+            const src = path.join(legacyMem, entry);
+            const dst = path.join(memories, entry);
+            try {
                 if (!fs.existsSync(dst)) {
                     fs.renameSync(src, dst);
                 }
@@ -113,46 +135,73 @@ function migrateLegacyDataRoot(dryRun) {
                     }
                 }
             }
+            catch (err) {
+                fail(`move memories from the legacy data dir`, err);
+            }
         }
+    }
+    try {
         fs.renameSync(legacy, backup);
     }
-    return backup;
+    catch (err) {
+        fail(`back up the legacy data dir`, err);
+    }
 }
-export function migrateV2(opts) {
-    const { memories: memoriesRoot } = paths();
-    const result = {
-        scanned: 0,
-        converted: 0,
-        skippedV2: 0,
-        plans: [],
-        legacyBackup: null,
-    };
-    result.legacyBackup = migrateLegacyDataRoot(opts.dryRun);
-    if (!fs.existsSync(memoriesRoot))
-        return result;
-    for (const entry of fs.readdirSync(memoriesRoot, { withFileTypes: true })) {
+/** Plan v1 → v2 conversion for every `.md` file under `dir`. Read-only. */
+function planDir(dir, memoriesRoot, result) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         if (!entry.isDirectory())
             continue;
-        const dir = path.join(memoriesRoot, entry.name);
-        for (const name of fs.readdirSync(dir)) {
+        const sub = path.join(dir, entry.name);
+        for (const name of fs.readdirSync(sub)) {
             if (!name.endsWith(".md"))
                 continue;
-            const filePath = path.join(dir, name);
+            const filePath = path.join(sub, name);
             result.scanned++;
             const plan = planConversion(filePath, memoriesRoot);
             if (!plan) {
                 result.skippedV2++;
                 continue;
             }
-            if (!opts.dryRun) {
-                fs.mkdirSync(path.dirname(plan.toPath), { recursive: true });
-                fs.writeFileSync(plan.toPath, serialize(plan.fm, plan.body), "utf8");
-                if (plan.toPath !== plan.fromPath)
-                    fs.unlinkSync(plan.fromPath);
-            }
             result.converted++;
             result.plans.push(plan);
         }
     }
+}
+/** Apply conversion plans to disk (real run only — never in dry-run). */
+function applyPlans(result) {
+    for (const plan of result.plans) {
+        fs.mkdirSync(path.dirname(plan.toPath), { recursive: true });
+        fs.writeFileSync(plan.toPath, serialize(plan.fm, plan.body), "utf8");
+        if (plan.toPath !== plan.fromPath)
+            fs.unlinkSync(plan.fromPath);
+    }
+}
+export function migrateV2(opts) {
+    const { memories: memoriesRoot } = paths();
+    const result = {
+        scanned: 0,
+        converted: 0,
+        skippedV2: 0,
+        plans: [],
+        legacyBackup: null,
+    };
+    const legacy = findLegacyDataRoot();
+    if (legacy) {
+        result.legacyBackup = legacyBackupPath(legacy);
+        if (opts.dryRun) {
+            // D44: dry-run previews the legacy files in place — nothing is moved,
+            // so the preview actually shows what would convert (issue #7).
+            planDir(path.join(legacy, "memories"), memoriesRoot, result);
+        }
+        else {
+            mergeLegacyDataRoot(legacy, result.legacyBackup);
+        }
+    }
+    planDir(memoriesRoot, memoriesRoot, result);
+    if (!opts.dryRun)
+        applyPlans(result);
     return result;
 }

package/docs/TEST-PLAN.md

@@ -33,6 +33,8 @@
 
 - [ ] Cursor：`open-memex mcp --print-config cursor` → 贴到 Cursor MCP 配置 → 能连上
 - [ ] opencode：`open-memex init --client opencode` → `opencode.jsonc` 生效
+- [ ] `open-memex init --yes`（不带 --client）→ 自动检测已装编辑器并一次全接上
+- [ ] opencode：`open-memex init --client opencode --global` → `~/.config/opencode/opencode.json` 的 `plugin` 数组合并（带注释的 jsonc 不动、只给手动提示）
 - [ ] Claude Code：`open-memex mcp --print-config claude` 给出的 `claude mcp add` 命令能跑通
 
 ## D. 跨机迁移（export/import 真实场景）

package/docs/V2-DESIGN.md

@@ -867,6 +867,39 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   MCP handshake instructions or the `init`-written instruction files — but
   opencode reads AGENTS.md natively, so the distilled snippet teaches the
   checkpoint habit wherever it lands. Approved 2026-09-29.*
+- **D44** — `migrate --to-v2` hotfix (issue #7, 0.4.1): (1) `--dry-run` now
+  previews the legacy `my-o-memory` files in place — per-file conversion plans
+  without moving anything (previously it scanned only the new, still-empty
+  root and always reported "0 files", making the preview useless); (2) dry-run
+  no longer prints the false "legacy data dir merged" line; (3) the Windows
+  EPERM on the legacy-dir backup rename is caught and rethrown as an actionable
+  message (close the program holding the folder — e.g. a running MCP server —
+  and re-run; nothing was deleted), and the CLI prints it as `Error: …` with
+  exit 1 instead of a raw syscall stack; (4) `parseFlags` accepts `--key=value`
+  in addition to `--key value` (the `=` form was silently misparsed before,
+  dropping the flag — which can turn a `--dry-run` into a real run).
+  *Rationale: a preview that shows nothing is worse than no preview — the user
+  cannot confirm what the real run will do; and a destructive-path failure must
+  speak in user terms. Shipped as 0.4.1 hotfix on the stable line. Approved
+  2026-09-29.*
+- **D45** — `init --global` (0.5.0-alpha.1): one-time user-level MCP wiring for
+  VS Code / Cursor. Writes the open-memex server entry to the editor's
+  user-level `mcp.json` (`%APPDATA%\Code\User\mcp.json` on Windows,
+  `~/Library/Application Support/Code/User/mcp.json` on macOS,
+  `~/.config/Code/User/mcp.json` on Linux; `~/.cursor/mcp.json` for Cursor)
+  instead of the project's `.vscode/mcp.json` — init once, the server starts
+  in every project. The entry keeps `cwd: "${workspaceFolder}"` so VS Code
+  substitutes it per window and project-scope resolution keeps working;
+  a per-project config still wins when present. Merge semantics are shared
+  with project-level init (merge, never clobber; `--force` overwrites).
+  Interactive `init` now asks per-project vs user-level for vscode/cursor
+  (default: per-project, preserving old behavior); `--global` skips the
+  question. For opencode, `--global` is a no-op that prints the native-plugin
+  one-liner (already global, and strictly more capable than plain-MCP mode);
+  Visual Studio stays solution-level by design. *Rationale: per-project init
+  is a paper cut that compounds — the data layer already needs zero per-project
+  setup (scope is derived from cwd), so the editor wiring should be able to
+  match. Approved 2026-09-29.*
 - **D41** — The type taxonomy is reconciled to 11 types with one-line definitions
   (§3.1): `fact` `preference` `decision` `constraint` `todo` `knowledge` `howto`
   `gotcha` `lesson` `observation` `reference`. Merged away: `warning`→`gotcha`,
@@ -878,6 +911,25 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   is deliberately broader than `incident`: a postmortem's shape (timeline, root
   cause, actions) is a template concern, not a type. Code
   `MEMORY_TYPE_TAXONOMY` updated to match. Approved 2026-09-28.*
+- **D46** — `init` with no `--client` auto-detects installed editors and wires
+  them all (0.5.0-alpha.2). Detection: VS Code via `code` on `PATH`, well-known
+  install locations, or an existing user-level `mcp.json`; Cursor via `cursor`
+  on `PATH` or `~/.cursor`; opencode via `opencode` on `PATH` or its global
+  config dir; Visual Studio only when the project has a `.sln` (solution-scoped
+  by design). Auto mode always wires user-level where the editor supports it —
+  VS Code / Cursor MCP entry (D45), and for opencode the native plugin entry is
+  now *actually merged* into `~/.config/opencode/opencode.json` (replacing D45's
+  hint-only `--global`), so one init covers every editor and every project.
+  A config file with comments (JSONC) is never rewritten — init prints the
+  manual one-liner instead. Interactive `init` shows the detected editors and
+  confirms wiring all of them (declining falls back to the single-editor
+  prompt); non-interactive (`--yes`) wires all detected with no prompts.
+  An explicit `--client` keeps the old single-editor behavior, including the
+  per-project default for vscode/cursor. *Rationale: Stone's two hats — he
+  writes code in several editors himself, and new users / pilot colleagues
+  should not have to learn `--client` to get started. The help text already
+  promised "default: auto-detect"; D46 makes the code keep that promise.
+  Approved 2026-09-29.*
 
 ## Open Questions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.4.0",
+  "version": "0.5.0-alpha.2",
   "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
   "type": "module",
   "license": "Apache-2.0",