open-memex 0.4.1 → 0.5.0-alpha.4

package/AGENTS.md

@@ -49,16 +49,21 @@ node --experimental-strip-types scripts\smoke-mcp.ts    # MCP handshake + tool r
 After `npm i -g open-memex` (or `npm link` from source), the `open-memex` bin is on
 PATH: `open-memex mcp` starts the MCP server, `open-memex mcp --print-config <client>`
 prints a client config snippet (client: vscode|cursor|claude|opencode|visualstudio),
-`open-memex init [--client vscode|cursor|opencode|visualstudio] [--instructions personal|project] [--force] [--yes]`
+`open-memex init [--client vscode|cursor|opencode|visualstudio] [--instructions personal|project] [--global] [--force] [--yes]`
 one-command project setup (editor MCP config + Copilot memory instructions;
+no --client → auto-detects installed editors and wires them all, user-level
+where supported — init once, every editor, every project (D46);
 instructions default to user-level ~/.copilot/copilot-instructions.md so the repo
-stays clean for teammates without open-memex — D22; resolves the server command
+stays clean for teammates without open-memex — D22; `--global` writes the MCP
+server entry to the editor's user-level config instead (VS Code / Cursor; D45)
+or the opencode native plugin entry into ~/.config/opencode/opencode.json (D46);
+resolves the server command
 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, MCP handshake).
-`open-memex init` asks editor + two settings on a TTY (`--yes` skips, scripts never
-prompt); `open-memex config set <key> <value>` edits settings after install.
+`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.
 The published `open-memex` bin points at `dist/cli.js` (compiled at publish time).
 From a source checkout, `npm run cli` / `npm run mcp` still run `src/` directly
 with type-stripping — no build step needed for development.
@@ -126,9 +131,10 @@ build roadmap; the design doc tracks the *why*.
 
 ## Branch workflow
 
-`main` (stable, mirrors npm) ← `V2` (v2 integration) ← `V2-dev-p<n>`
-(phase work; draft PRs into `V2`). Never create `V2/<anything>` — git can't
-hold `V2` and `V2/…` simultaneously. Full rules: `CONTRIBUTING.md`.
+`dev/<topic>` → PR → `main` (the v2 line; alpha versions published with
+`npm publish --tag alpha`, npm `latest` moves only on stable releases).
+The `V2` integration branch was retired 2026-09-29 — its job (isolating the
+breaking v1→v2 transition) shipped with 0.3.0. Full rules: `CONTRIBUTING.md`.
 
 ## Style notes
 

package/CONTRIBUTING.md

@@ -2,17 +2,17 @@
 
 ## Branch workflow
 
-- `main` — stable. Mirrors the npm release line. Never commit directly;
-  only merge from `V2` when a milestone is tested and ready to release.
-- `V2` — integration branch for the v2 line. Phase work lands here via
-  pull request. Merges to `main` only after the milestone is dogfooded
-  (plugin tested in opencode, `migrate --to-v2 --dry-run` clean on real data).
-- `V2-dev-p<n>` — phase dev branches (e.g. `V2-dev-p1`). Open as **draft**
-  PRs against `V2`; mark ready and merge after local testing passes.
+- `main` — the v2 line. Never commit directly; land work via pull request
+  from a dev branch. Alpha versions (e.g. `0.5.0-alpha.x`) live on `main`;
+  publish them with `npm publish --tag alpha` so the npm `latest` tag only
+  moves on stable releases.
+- `dev/<topic>` — feature/fix branches (e.g. `dev/init-ux`). Open as **draft**
+  PRs against `main`; mark ready and merge after local testing passes.
 
-**Naming rule:** never create `V2/<anything>` — git cannot hold a branch
-named `V2` and a branch named `V2/…` at the same time (ref file vs.
-directory conflict). Use the flat `V2-dev-*` form instead.
+(The `V2` integration branch was retired 2026-09-29 — it existed only to
+isolate the breaking v1→v2 transition, which shipped with 0.3.0. If a future
+breaking change ever needs isolation, create an integration branch then;
+branches are cheap.)
 
 ## Before opening a PR
 

package/README.md

@@ -90,7 +90,7 @@ personal scope: this machine only — never synced, never enters a repo.
 npm install -g open-memex
 ```
 
-This installs the `0.4.0` stable release.
+This installs the `0.4.1` stable release.
 
 **Alpha** (bleeding edge, for testers) — the `alpha` tag:
 
@@ -114,10 +114,10 @@ npx -y open-memex <command>         # e.g. npx -y open-memex init --client vscod
 npx -y open-memex@alpha <command>  # alpha line, no install
 ```
 
-**From source** (bleeding edge, `V2-dev-p2` branch):
+**From source** (bleeding edge, `main` branch):
 
 ```sh
-git clone -b V2-dev-p2 https://github.com/stoneskin/open-memex.git
+git clone -b main https://github.com/stoneskin/open-memex.git
 cd open-memex
 npm install
 node --experimental-strip-types src/cli.ts <command>
@@ -156,16 +156,36 @@ folders under your global npm root and install again.
 
 Run from your **project root** (so the project scope resolves to this repo):
 
+```sh
+open-memex init --yes
+# …or without installing the package first:
+npx -y open-memex init --yes
+```
+
+With no `--client`, `init` **detects your installed editors and wires them all**
+— user-level where the editor supports it (VS Code / Cursor MCP config, opencode
+native plugin), so one init covers every project. Visual Studio joins in when the
+project has a solution file. Prefer to pick a single editor? Pass `--client`:
+
+> **Two different "globals" — don't mix them up.**
+> - `npm install -g open-memex` installs the *package* globally: it puts the
+>   `open-memex` command on your PATH.
+> - `init --global` writes the *editor config* at user level instead of the
+>   project: init once, the wiring works in every project. It works the same
+>   whether the package was installed globally or run via npx.
+
 **VS Code** (Copilot):
 
 ```sh
 open-memex init --client vscode
-# …or without a global install:
+# …or without installing the package first:
 npx -y open-memex init --client vscode
 ```
 
-Writes `.vscode/mcp.json` and user-level Copilot instructions, then reload the
-window and confirm the `open-memex` server is started in Copilot Chat's MCP panel.
+Wires the project-level `.vscode/mcp.json` and user-level Copilot instructions,
+then reload the window and confirm the `open-memex` server is started in Copilot
+Chat's MCP panel. On a TTY, `init` asks whether the MCP config should be
+per-project or user-level instead of guessing; `--global` forces user-level.
 
 **Cursor:**
 
@@ -173,7 +193,36 @@ window and confirm the `open-memex` server is started in Copilot Chat's MCP pane
 open-memex init --client cursor
 ```
 
-Writes `.cursor/mcp.json` and user-level Copilot instructions.
+Same shape as VS Code: project-level `.cursor/mcp.json` by default, user-level
+with `--global` (or when `init` asks on a TTY), plus user-level Copilot
+instructions.
+
+**One-time setup for all projects (VS Code / Cursor):**
+
+```sh
+open-memex init --client vscode --global --yes
+```
+
+Writes the server entry to the editor's *user-level* MCP config
+(`%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 — init once, the server starts in every project.
+A per-project `.vscode/mcp.json` still wins if a project defines its own.
+If the user-level file has comments in it (VS Code accepts JSONC), `init` leaves
+the file untouched and prints the exact snippet to paste in by hand.
+
+**opencode** (native plugin — recommended):
+
+```sh
+open-memex init --client opencode --global --yes
+```
+
+Merges `"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]` into your
+user-level `~/.config/opencode/opencode.json` — one-time, every project picks it
+up, no per-project init. You get keyword auto-capture and first-turn context
+injection on top of the tools. (A config file with comments is left untouched —
+add the `plugin` line by hand in that case.)
 
 **opencode** (as a plain MCP consumer):
 
@@ -181,10 +230,8 @@ Writes `.cursor/mcp.json` and user-level Copilot instructions.
 open-memex init --client opencode
 ```
 
-Writes project-level `opencode.jsonc` (`type: "local"`). Prefer the native plugin
-instead? Add `"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]` to
-`~/.config/opencode/opencode.jsonc` — you get keyword auto-capture and first-turn
-context injection on top of the tools.
+Writes project-level `opencode.jsonc` (`type: "local"`). Needed only if you
+prefer plain MCP over the native plugin.
 
 **Claude Code** (from your project root):
 
@@ -208,18 +255,38 @@ above works too.
 `open-memex mcp --print-config` as a starting point (`[mcp_servers]` in
 `config.toml`, or `codex mcp add`).
 
+**Remove the wiring:**
+
+```sh
+open-memex uninstall --yes
+```
+
+Reverses `init` — removes the MCP server entry, the opencode plugin line, and
+the open-memex section of the Copilot instructions. With no `--client` it cleans
+up every detected editor (project-level and user-level wiring); `--global`
+limits the cleanup to user-level. Your memories are never touched.
+
 `init` notes:
 
+- With no `--client`, `init` auto-detects installed editors (VS Code via `code`
+  on `PATH` / install location / existing user config; Cursor via `cursor` on
+  `PATH` or `~/.cursor`; opencode via `opencode` on `PATH` or its config dir;
+  Visual Studio when the project has a `.sln`) and wires them all — user-level
+  where supported, so one init covers every project.
+- `--global` writes the MCP server entry to the editor's user-level config
+  (VS Code / Cursor) — one init for all projects. For opencode, `--global`
+  wires the native plugin at user level (no per-project init needed);
+  Visual Studio stays solution-level by design.
 - The Copilot memory instructions default to **user-level**
   (`~/.copilot/copilot-instructions.md`; `%USERPROFILE%\copilot-instructions.md`
   for Visual Studio) — they apply to all your projects and are never checked
   into a repo, so teammates without open-memex see nothing and nothing breaks
   for them. `--instructions project` writes `.github/copilot-instructions.md`
   instead, for teams where everyone uses open-memex.
-- On a terminal it interactively asks which editor to set up, whether to enable
-  keyword auto-capture, and whether to inject memories on the first turn.
-  `--yes` accepts the defaults; scripts / non-TTY never prompt (editor defaults to
-  VS Code).
+- On a terminal it shows the detected editors, asks you to confirm wiring them
+  all (or pick one), and asks whether to enable keyword auto-capture and
+  first-turn memory injection. `--yes` accepts the defaults; scripts /
+  non-TTY never prompt and wire every detected editor.
 - Existing config files are **merged, never clobbered** — re-running is safe.
   `--force` overwrites.
 - With no durable `open-memex` on `PATH` (e.g. one-shot npx), `init` writes an
@@ -393,7 +460,9 @@ Settable keys: `maxProjectMemories`, `maxProfileItems`, `injectOnFirstTurn`,
 Setup & health:
 
 ```sh
-open-memex init [--client vscode|cursor|opencode|visualstudio] [--force] [--yes]
+open-memex init [--client vscode|cursor|opencode|visualstudio]
+              [--instructions personal|project] [--global] [--force] [--yes]
+open-memex uninstall [--client vscode|cursor|opencode|visualstudio] [--global] [--yes]
 open-memex config                                  # print effective config
 open-memex config set <key> <value>                # change a setting
 open-memex doctor                                  # environment health check
@@ -563,6 +632,52 @@ sharing, ACL, or compliance needs demand it.
 
 Design details: [docs/V2-DESIGN.md](./docs/V2-DESIGN.md) (append-only decision log).
 
+## FAQ
+
+**Do I need to initialize open-memex for each project after installing?**
+Two layers. The data layer needs nothing — there is no per-project init:
+the data dir is created on demand and the project scope is derived
+automatically from your cwd's git remote or path, so memories are
+namespaced per project with zero setup. The editor wiring takes one step:
+run `open-memex init` with no arguments and it auto-detects every editor
+you have installed (VS Code, Cursor, opencode — plus Visual Studio when the
+project has a `.sln`) and wires them all, user-level wherever the editor
+supports it, so one init covers every project. Prefer a single editor?
+`open-memex init --client <vscode|cursor|opencode|visualstudio>`. Prefer to
+force user-level for VS Code / Cursor? Add `--global`. The Copilot memory
+instructions default to user-level (`~/.copilot/`), which is global.
+
+**Does opencode need `init`?**
+Two paths. Recommended: `open-memex init --client opencode --global` —
+it merges the native open-memex plugin into
+`~/.config/opencode/opencode.json` for you. One-time setup, applies to all
+projects, and additionally enables keyword auto-capture and first-turn
+memory injection. Prefer to do it by hand? Add
+`"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]`
+(the installed package's path) to that file instead. As a plain MCP
+consumer: `open-memex init --client opencode` writes a project-level
+`opencode.jsonc` (no hooks). If your user-level config has comments, `init`
+leaves it untouched and prints the manual step.
+
+**VS Code — run `init` once, or per project?**
+Once. Plain `open-memex init` auto-detects VS Code and writes the MCP server
+entry to VS Code'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), so the server starts in every
+project. A per-project `.vscode/mcp.json` still wins when present, and the
+entry keeps `cwd=${workspaceFolder}` so project-scope resolution keeps
+working per window. If your user-level `mcp.json` has comments (VS Code
+accepts JSONC), `init` leaves it alone and prints the exact snippet to add
+by hand.
+
+**How do I remove the editor wiring?**
+`open-memex uninstall` reverses `init`: it removes the MCP server entry,
+the opencode plugin line, and the open-memex section of the Copilot
+instructions. With no `--client` it cleans up every detected editor;
+`--global` limits the cleanup to user-level wiring. Your memories are
+never touched.
+
 ## License
 
 [Apache-2.0](./LICENSE)

package/README.zh-CN.md

@@ -87,7 +87,7 @@ personal scope：只属于这台机器——永不同步，永远进不了仓库
 npm install -g open-memex
 ```
 
-安装的是 `0.4.0` 正式版。
+安装的是 `0.4.1` 正式版。
 
 **Alpha 版**（最新开发版，给测试者）——`alpha` 标签：
 
@@ -111,10 +111,10 @@ npx -y open-memex <命令>          # 例如 npx -y open-memex init --client vsc
 npx -y open-memex@alpha <命令>   # alpha 线，免安装
 ```
 
-**从源码安装**（最新开发版，`V2-dev-p2` 分支）：
+**从源码安装**（最新开发版，`main` 分支）：
 
 ```sh
-git clone -b V2-dev-p2 https://github.com/stoneskin/open-memex.git
+git clone -b main https://github.com/stoneskin/open-memex.git
 cd open-memex
 npm install
 node --experimental-strip-types src/cli.ts <命令>
@@ -151,16 +151,35 @@ Windows 下被进程加载的 DLL 是锁死的：如果 open-memex MCP server
 
 在**项目根目录**下运行（这样 project scope 会解析到这个仓库）：
 
+```sh
+open-memex init --yes
+# ……没先装包的话：
+npx -y open-memex init --yes
+```
+
+不带 `--client` 时，`init` 会**自动检测本机装了哪些编辑器，一次全接上**——
+支持用户级的编辑器走用户级（VS Code / Cursor 的 MCP 配置、opencode 原生插件），
+一次 init，所有项目通用；项目里有 solution 文件时 Visual Studio 也会一起配。
+想只配某一个编辑器？加 `--client`：
+
+> **两个"全局"不是一回事，别搞混。**
+> - `npm install -g open-memex` 是把*包*装到全局：让 `open-memex` 命令出现在
+>   你的 PATH 里。
+> - `init --global` 是把*编辑器配置*写到用户级而不是项目里：init 一次，
+>   每个项目都生效。不管包是全局安装的还是用 npx 临时跑的，效果一样。
+
 **VS Code**（Copilot）：
 
 ```sh
 open-memex init --client vscode
-# ……没装全局包的话：
+# ……没先装包的话：
 npx -y open-memex init --client vscode
 ```
 
-自动写 `.vscode/mcp.json` 和用户级 Copilot instructions，然后重新加载窗口，
-在 Copilot Chat 的 MCP 面板里确认 `open-memex` server 已启动。
+配项目级 `.vscode/mcp.json` 和用户级 Copilot instructions，然后重新加载窗口，
+在 Copilot Chat 的 MCP 面板里确认 `open-memex` server 已启动。终端交互模式下
+`init` 会问你要配到项目级还是用户级，而不是替你猜；`--global` 直接强制
+用户级。
 
 **Cursor：**
 
@@ -168,7 +187,35 @@ npx -y open-memex init --client vscode
 open-memex init --client cursor
 ```
 
-自动写 `.cursor/mcp.json` 和用户级 Copilot instructions。
+和 VS Code 一个套路：默认写项目级 `.cursor/mcp.json`，`--global`
+（或终端里 `init` 问你时选用户级）就写用户级，外加用户级 Copilot
+instructions。
+
+**一次配置、所有项目通用（VS Code / Cursor）：**
+
+```sh
+open-memex init --client vscode --global --yes
+```
+
+把 server 条目写到编辑器的*用户级* MCP 配置（Windows 下是
+`%APPDATA%\Code\User\mcp.json`，macOS 是
+`~/Library/Application Support/Code/User/mcp.json`，Linux 是
+`~/.config/Code/User/mcp.json`；Cursor 是 `~/.cursor/mcp.json`），
+而不是写到项目里——init 一次，每个项目打开自动启动 server。
+如果某个项目自己定义了 `.vscode/mcp.json`，项目级的优先。
+如果用户级文件里带注释（VS Code 接受 JSONC），`init` 不会碰这个文件，
+只打印可直接手贴的配置片段。
+
+**opencode**（原生插件——推荐）：
+
+```sh
+open-memex init --client opencode --global --yes
+```
+
+把 `"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]` 合并进用户级
+`~/.config/opencode/opencode.json`——一次配置，每个项目自动生效，不用逐个项目
+init。在 tools 之外还能获得关键词自动捕获和首轮上下文注入。（带注释的配置文件
+不会被改动——那种情况请手动加 `plugin` 这一行。）
 
 **opencode**（作为普通 MCP 客户端）：
 
@@ -176,10 +223,8 @@ open-memex init --client cursor
 open-memex init --client opencode
 ```
 
-写项目级 `opencode.jsonc`（`type: "local"`）。想用原生插件？
-在 `~/.config/opencode/opencode.jsonc` 里加
-`"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]`——
-在 tools 之外还能获得关键词自动捕获和首轮上下文注入。
+写项目级 `opencode.jsonc`（`type: "local"`）。只有当你更想要纯 MCP 而不是原生
+插件时才需要。
 
 **Claude Code**（在项目根目录运行）：
 
@@ -202,6 +247,16 @@ Visual Studio 也会自动发现 `.vscode/mcp.json` 和 `.cursor/mcp.json`，
 **Codex：** 暂无 `init` 客户端——以 `open-memex mcp --print-config` 为起点手动添加
 （`config.toml` 的 `[mcp_servers]`，或 `codex mcp add`）。
 
+**拆掉接线：**
+
+```sh
+open-memex uninstall --yes
+```
+
+`init` 的逆操作——删掉 MCP server 条目、opencode 插件行和 Copilot
+instructions 里的 open-memex 段。不带 `--client` 时把检测到的编辑器全清掉
+（项目级和用户级都清）；`--global` 只清用户级。你的记忆数据永远不会被碰。
+
 `init` 说明：
 
 - Copilot 记忆 instructions 默认写到**用户级**
@@ -210,11 +265,19 @@ Visual Studio 也会自动发现 `.vscode/mcp.json` 和 `.cursor/mcp.json`，
   到 repo，没装 open-memex 的同事看不到、也不会出错。团队人人都用
   open-memex 时可用 `--instructions project` 改写
   `.github/copilot-instructions.md`。
-- 在终端里会交互式询问：配哪个编辑器、是否开启关键词自动捕获、
-  是否在首轮注入记忆。`--yes` 全用默认值；脚本 / 非 TTY 环境不提问
-  （编辑器默认 VS Code）。
+- 不带 `--client` 时，`init` 自动检测已安装的编辑器（VS Code 看 `PATH` 有没有
+  `code` / 安装位置 / 已有的用户级配置；Cursor 看 `PATH` 有没有 `cursor` 或
+  `~/.cursor`；opencode 看 `PATH` 有没有 `opencode` 或其配置目录；项目里有
+  `.sln` 时算上 Visual Studio），一次全接上——支持用户级的走用户级，
+  一次 init，所有项目通用。
+- 在终端里会列出检测到的编辑器，请你确认是一次全配还是只配一个，
+  再问是否开启关键词自动捕获、是否在首轮注入记忆。`--yes` 全用默认值；
+  脚本 / 非 TTY 环境不提问，直接配所有检测到的编辑器。
 - 已有配置文件会被**合并，不会被覆盖**——重复运行是安全的。
   `--force` 强制覆盖。
+- `--global` 把 MCP server 条目写到编辑器的用户级配置（VS Code / Cursor）——
+  一次配置，所有项目通用。opencode 的 `--global` 走用户级原生插件，
+  不用逐个项目 init；Visual Studio 按设计保持 solution 级。
 - 如果 `PATH` 上没有可用的 `open-memex`（比如一次性 npx），`init` 会把
   `npx -y open-memex mcp` 写进配置，配置照样能用。
   以后 `npm i -g open-memex` + `open-memex init --force` 可切换到更快
@@ -374,7 +437,9 @@ open-memex config set maxProjectMemories 12
 安装与健康检查：
 
 ```sh
-open-memex init [--client vscode|cursor|opencode|visualstudio] [--force] [--yes]
+open-memex init [--client vscode|cursor|opencode|visualstudio]
+              [--instructions personal|project] [--global] [--force] [--yes]
+open-memex uninstall [--client vscode|cursor|opencode|visualstudio] [--global] [--yes]
 open-memex config                                  # 打印生效配置
 open-memex config set <key> <value>                # 改设置
 open-memex doctor                                  # 环境健康检查
@@ -530,6 +595,43 @@ ACL 或合规需求出现时才做。
 
 设计细节：[docs/V2-DESIGN.md](./docs/V2-DESIGN.md)（append-only 决策日志）。
 
+## 常见问题（FAQ）
+
+**装完之后，每个项目都要初始化 open-memex 吗（像其他 app 那样）？**
+分两层。数据层不需要——没有 per-project 初始化的概念：数据目录按需自动创建，
+project scope 从当前目录的 git remote 或路径自动推导，记忆天然按项目隔离，
+零配置。编辑器接线只需要一步：直接跑 `open-memex init`（不带参数），它会自动
+检测你装好的编辑器（VS Code、Cursor、opencode；项目里有 `.sln` 时还有 Visual
+Studio）并一次全接上——支持用户级配置的编辑器就写用户级，一次 init 所有项目
+通用。只想接某一个编辑器？用
+`open-memex init --client <vscode|cursor|opencode|visualstudio>`。
+想给 VS Code / Cursor 强制写用户级？加 `--global`。
+Copilot 记忆指令默认写用户级（`~/.copilot/`），那个是全局的。
+
+**opencode 需要跑 `init` 吗？**
+两条路。推荐：`open-memex init --client opencode --global`——自动把原生插件
+合并进 `~/.config/opencode/opencode.json`。一次配置，所有项目生效，还多拿
+关键词自动捕获和首轮记忆注入。想手写？往那个文件里加
+`"plugin": ["file:///absolute/path/to/open-memex/src/index.ts"]`
+（填 open-memex 的实际安装路径）就行。当纯 MCP 用：
+`open-memex init --client opencode` 写项目级 `opencode.jsonc`（无 hooks）。
+如果你的用户级配置里带注释，`init` 不会碰它，只打印手动步骤。
+
+**VS Code 呢——跑一次就行，还是每个项目都要跑？**
+跑一次就行。直接 `open-memex init` 会自动检测到 VS Code，把 MCP server 写进
+VS Code 的用户级 `mcp.json`（Windows：`%APPDATA%/Code/User/mcp.json`；
+macOS：`~/Library/Application Support/Code/User/mcp.json`；
+Linux：`~/.config/Code/User/mcp.json`），每个项目打开 server 都在。
+项目里如果有 `.vscode/mcp.json` 仍然优先；entry 里保留了
+`cwd=${workspaceFolder}`，project scope 按窗口照常工作。
+如果你的用户级 `mcp.json` 带注释（VS Code 接受 JSONC），`init` 不会碰它，
+只打印可直接手贴的配置片段。
+
+**怎么拆掉编辑器接线？**
+`open-memex uninstall` 就是 `init` 的逆操作：删掉 MCP server 条目、opencode
+插件行和 Copilot instructions 里的 open-memex 段。不带 `--client` 时把检测
+到的编辑器全清掉；`--global` 只清用户级。你的记忆数据永远不会被碰。
+
 ## 许可证
 
 [Apache-2.0](./LICENSE)

package/dist/cli.js

@@ -250,17 +250,38 @@ Examples:
 agent memory instructions. Existing files are merged, never clobbered.
 
 Usage: open-memex init [--client vscode|cursor|opencode|visualstudio]
-              [--instructions personal|project] [--force] [--yes]
+              [--instructions personal|project] [--global] [--force] [--yes]
 
 Flags:
-  --client        editor to configure (default: auto-detect)
+  --client        editor to configure (default: auto-detect all installed editors)
   --instructions  personal (default, ~/.copilot/copilot-instructions.md) or project
+  --global        write the MCP server entry to the editor's user-level config
+                  (VS Code / Cursor) — init once, works in every project.
+                  For opencode, --global wires the native plugin at user level
+                  (~/.config/opencode/opencode.json) — no per-project init needed.
   --force         overwrite existing config
   --yes           accept all defaults, never prompt
 
 Examples:
   open-memex init
+  open-memex init --client vscode --global --yes
   open-memex init --client cursor --yes`,
+    uninstall: `Remove the editor wiring that \`init\` wrote: the MCP server entry,
+the opencode native plugin line, and the Copilot instructions section.
+Your memories are never touched.
+
+Usage: open-memex uninstall [--client vscode|cursor|opencode|visualstudio]
+              [--global] [--yes]
+
+Flags:
+  --client   editor to unwire (default: auto-detect all installed editors)
+  --global   only the user-level config; without it, both project-level and
+             user-level wiring are removed (init may have written either)
+  --yes      accept all defaults, never prompt
+
+Examples:
+  open-memex uninstall
+  open-memex uninstall --client vscode --yes`,
     config: `Show config, or set a key.
 
 Usage: open-memex config [set <key> <value>]
@@ -313,6 +334,8 @@ Usage:
   open-memex mcp [--print-config vscode|cursor|claude|opencode|visualstudio]
   open-memex init [--client vscode|cursor|opencode|visualstudio]
               [--instructions personal|project] [--force] [--yes]
+  open-memex uninstall [--client vscode|cursor|opencode|visualstudio]
+              [--global] [--yes]
   open-memex config [set <key> <value>]
   open-memex capture --dry-run "text"
   open-memex doctor
@@ -320,16 +343,19 @@ Usage:
 Every command has its own help with description and examples:
   open-memex <command> --help   (or -h)
 
-One-command project setup: \`open-memex init\` (or \`npx open-memex@alpha init\`) writes
-the MCP config for your editor (\`.vscode/mcp.json\`, \`.cursor/mcp.json\`,
-\`opencode.jsonc\`, or Visual Studio's solution-level \`.mcp.json\`) — no copy-paste
-needed. The Copilot memory instructions default to your user-level
+One-command project setup: \`open-memex init\` (or \`npx open-memex@alpha init\`) detects
+your installed editors and wires them all — user-level where the editor supports it
+(VS Code / Cursor MCP config, opencode native plugin), so one init covers every project;
+Visual Studio is included when the project has a solution file (its \`.mcp.json\`
+stays solution-level by design). \`--client\` picks a single editor instead, and a
+single-editor opencode init writes the per-project plain-MCP \`opencode.jsonc\`.
+The Copilot memory instructions default to your user-level
 \`~/.copilot/copilot-instructions.md\` (all projects, never checked into a repo);
 \`--instructions project\` writes \`.github/copilot-instructions.md\` instead for
 teams where everyone uses open-memex.
 Existing files are merged, never clobbered; re-running is safe. On a terminal it
-asks which editor to set up and a couple of settings (keyword capture, first-turn
-injection); \`--yes\` accepts all defaults, and non-terminal runs never prompt.
+confirms the detected editors and asks a couple of settings (keyword capture,
+first-turn injection); \`--yes\` accepts all defaults, and non-terminal runs never prompt.
 \`open-memex config set <key> <value>\` changes those settings after install.
 
 Once installed globally (\`npm i -g open-memex@alpha\`) the \`open-memex\` command is
@@ -526,7 +552,7 @@ async function main() {
         return;
     }
     // `init` is a pure file operation (§17 adoption path) — no DB needed.
-    // Interactive when on a TTY (asks editor + settings); --yes skips prompts.
+    // Interactive when on a TTY (confirms detected editors + settings); --yes skips prompts.
     if (cmd === "init") {
         const flags = parseFlags(rest);
         const { initProject } = await import("./init.js");
@@ -535,6 +561,19 @@ async function main() {
             force: flags["force"] === "true",
             yes: flags["yes"] === "true",
             instructions: flags["instructions"],
+            global: flags["global"] === "true",
+        });
+        return;
+    }
+    // `uninstall` reverses `init` — removes the editor wiring; never touches data.
+    // No DB needed (pure file operation, like init).
+    if (cmd === "uninstall") {
+        const flags = parseFlags(rest);
+        const { uninstallProject } = await import("./init.js");
+        await uninstallProject({
+            client: flags["client"],
+            global: flags["global"] === "true",
+            yes: flags["yes"] === "true",
         });
         return;
     }