open-memex 0.7.0-alpha.4 → 0.7.0-alpha.8

package/AGENTS.md

@@ -151,18 +151,23 @@ AGENTS.md hygiene footer, the MCP handshake, and the tool descriptions.
 
 - Statuses: `active → superseded | deprecated | retracted | archived`. Retrieval excludes `retracted`/`archived`, ranks `active` above `deprecated`.
 - Never hand-write `status: superseded` or half a chain. Use the `supersede` code path (`src/store/lifecycle.ts`): the old record keeps its file, flips to `superseded`, and both sides get `supersedes`/`superseded_by`. Only `active` memories can be superseded.
+- Superseding a memory that had entered review (proposed/approved/published/rejected) starts the replacement at `review_state: proposed` so `promote` can advance it (D64). Never reset it to `draft` — a draft in the repo dir is stranded (submit only moves outbox files).
+- `setStatus` refuses `retracted → active` (D64): retracted content must not silently return to recall. Save a new memory instead.
+- **Every memory-file write goes through `atomicWriteTextSync`** (markdown.ts; tmp + rename). The create path, supersede flips, review transitions, submit landings, migrate/v2migrate rewrites — no direct `fs.writeFileSync` on a memory file. A torn read mid-rewrite parses as a deletion and drops the memory from the index.
 - Chain integrity is self-healing: on read, a missing counterpart is auto-completed with a warning; a dangling pointer warns but is never fabricated. Don't "fix" chains by editing frontmatter directly — let the read path do it.
 - Frontmatter is `schema_version: 2`. The SQLite index schema is versioned separately and rebuilds automatically on version change — never hand-edit `index.db`.
 
-Keyword capture fires from `chat.message` on the user's message parts (`UserMessage`). Patterns live in `src/capture/keywords.ts` / config `keywordPatterns`; regex group 1 is the memory body. Scope routing: personal patterns (`cfg.keywordPersonalPatterns`) force the personal scope — the rule is 我 → personal (记住我/替我记/我觉得/我喜欢/remember for me), 我们 → current scope (我们认为/我们决定/帮我们记住); personal patterns run first and claim their line so a generic trigger can't double-fire.
+Keyword capture fires from `chat.message` on the user's message parts (`UserMessage`). Patterns live in `src/capture/keywords.ts` / config `keywordPatterns`; regex group 1 is the memory body. Scope routing: personal patterns (`cfg.keywordPersonalPatterns`) force the personal scope — the rule is 我 → personal (记住我/替我记/帮我记/我觉得/我喜欢/remember for me/help me remember), 我们 → current scope (我们认为/我们决定/帮我们记住); personal patterns run first and claim their line so a generic trigger can't double-fire (a rejected personal match keeps the claim — see D67).
+
+D67 rules for any new pattern: a trigger must be a **statement to the store**, not narration — 记得… / `remind me to…` are deliberately out, and the ambiguous forms require an explicit marker (`别忘了：…`, `don't forget: …`, `don't forget that …`). The 帮/替/我们 family takes the full verb phrase (`记` + optional `住|录`, never followed by a verb continuation) + optional `一下`; the separator boundary applies to the **bare** verb only, so `帮我记一下这个配置` captures while `帮我记得带伞` cannot produce mid-word garbage. Bodies under `MIN_CAPTURE_CHARS` (3) are rejected as fragments — never lower the floor silently; `scanKeywords` returns the drop so `capture --dry-run` and the debug log can report it.
 
 Context injection happens exactly once per session in `experimental.chat.system.transform`, guarded by an in-memory `Set<sessionID>` in `src/index.ts`. It is not persisted — restarting opencode re-injects on the next first turn.
 
 ## Design constraints — read the frozen design first
 
-`docs/V2-DESIGN.md` is the frozen protocol v0.2 (zero open questions). Per its §12:
+`docs/V2-DESIGN.md` is the frozen protocol v0.2 (decisions D1–D64 settled; open questions tracked at the end of the doc). Per its §12:
 AGENTS.md answers "how should AI work here"; the design doc answers "why is it
-built this way" (principles, iron rules, D1–D49 decision log). Before changing
+built this way" (principles, iron rules, the append-only decision log, currently D1–D67). Before changing
 architecture, scope semantics, lifecycle, or the protocol surface (frontmatter
 schema, MCP tools, CLI contract), read the relevant design section — the decision
 log records what was already considered and rejected.

package/CHANGELOG.md

@@ -9,6 +9,46 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## Keyword capture: what counts as a trigger (D67)
+
+The D66 review left two questions open and introduced one regression. Ruled, not deferred:
+
+- **Fixed a regression:** D66's separator boundary was one notch too strict — it also demanded a separator after a *complete* verb phrase, so `帮我记一下这个配置`, `帮我记住这个配置`, `替我记一下我住在杭州` and `帮我们记一下这个约定` stopped matching. The boundary now guards the bare verb only, so `帮我记得…` still can't produce mid-word garbage.
+- **The ≥3-character body floor stays, but is no longer silent.** `记住：这个` is a fragment, not a memory, so it isn't captured — but `open-memex capture --dry-run` now says why, and `logLevel: debug` logs it. A rejected *personal* match also keeps its line, so `记住我：OK` can no longer fall through to the generic 记住 and be saved as `我：OK`.
+- **Narration is not a trigger.** `记得…`, `remind me to…` and friends stay out on purpose (a false trigger writes unreviewed memory; a missed one costs a sentence). The ambiguous forms already in the list now need an explicit marker: `别忘了：…`, `don't forget: …` and `don't forget that …` capture; bare `别忘了带伞` and `don't forget the wifi password` do not. The `note` family is unchanged.
+- **Test tooling:** the stale-`dist/` guard is now a content fingerprint (`scripts/build-stamp.mjs`) instead of mtimes, which a branch switch could defeat; the agent-facing `memory_status` cap (20 per section + a "full list" pointer) is pinned again after D66's test replaced that coverage.
+
+## Review follow-ups (D66)
+
+Fixes from the follow-up review of the D63–D65 stack:
+
+- Keyword patterns: `请帮我记住…` works (the D65 pattern had missed its `请` prefix), `帮我记录一下：…` / `替我记录一下：…` capture cleanly instead of saving mid-word garbage, `帮我记得…` no longer fires, and `help me remember: …` routes personal like `remember for me`.
+- `open-memex sync-status` (the CLI) shows the full list again — the 20-per-section cap now applies only to agent tool results, whose "… and N more" line points at the CLI. `open-memex list --scope both` matches the `memory_list` tool.
+- `open-memex status --help` documents that retraction is one-way.
+- The full test suite is Windows-safe now (file:// probe imports, USERPROFILE-aware uninstall test) and refuses to run against a stale `dist/` build.
+
+## Keyword capture gaps (D65)
+
+The most natural phrasings were the ones that fell through:
+
+- `帮我记住…` / `帮我记一下…` now capture (personal scope, same 我-rule as 替我记； `帮我们记住…` still routes project).
+- A leading `请` no longer defeats capture: `请记住我…`, `请记住（个人）…`, and `请记住：…` all work.
+- English `remember to …` no longer leaves a stray "to" at the front of the captured body.
+
+Patterns are code defaults, so these apply automatically on upgrade — unless you hand-customized `keywordPatterns` / `keywordPersonalPatterns` in your config, in which case your lists win and you can port the additions by hand.
+
+## P1 fixes: stale answers and stranded files (D64)
+
+Second batch from the whole-project review — the index, the files, and the guidance can no longer quietly disagree:
+
+- The opencode plugin now re-syncs the index before every tool call (previously only at startup): memories added via the CLI or another client are visible right away instead of after a restart.
+- Superseding a published memory re-enters review as `proposed` instead of a stranded `draft` no command could advance; `promote` can move it forward again.
+- All memory-file rewrites are atomic (tmp + rename), not just creates.
+- A retracted memory can't be flipped back to `active` via status changes — save a new memory if the content is valid again.
+- Proposed copies of personal memories are `visibility: internal` (was: `private`, which export silently excluded from team bundles).
+- `uninstall` finds the real global opencode config (`.jsonc` included), and `doctor` checks all eleven MCP tools plus stranded v1 (`user`-scope) memories.
+- `memory_status` output is capped per section; `memory_list` accepts `scope: both`; `forget` notes when the deleted file was in the repo; `where` prints the config path.
+
 ## Correctness fixes from the whole-project review (D63)
 
 Six silent-wrong-answer bugs found by an external three-lens review, each fixed with a regression test:

package/README.md

@@ -222,9 +222,10 @@ open-memex init --client vscode
 ```
 
 Writes the MCP server entry; reload the window afterwards and confirm the
-`open-memex` server is started in Copilot Chat's MCP panel. By default the
-server entry goes to VS Code's *user-level* config (works in every project);
-`init` can also write a project-level `.vscode/mcp.json` if you prefer.
+`open-memex` server is started in Copilot Chat's MCP panel. By default this
+writes a project-level `.vscode/mcp.json` (an interactive run asks which
+level you want); add `--global` for VS Code's *user-level* config instead —
+one setup that works in every project.
 
 **Cursor:**
 
@@ -232,8 +233,8 @@ server entry goes to VS Code's *user-level* config (works in every project);
 open-memex init --client cursor
 ```
 
-Same shape as VS Code: user-level MCP config by default, project-level
-`.cursor/mcp.json` on request, plus Copilot-style instructions.
+Same shape as VS Code: project-level `.cursor/mcp.json` by default,
+user-level MCP config with `--global`, plus Copilot-style instructions.
 
 **opencode** (native plugin — recommended):
 
@@ -363,12 +364,18 @@ snippet to paste instead.
 Three ways memories get in:
 
 - **Keyword triggers** (opencode native plugin only): say `remember …`,
-  `note that …`, `don't forget …`, `TIL …`, `save this …` — or in Chinese
-  `记住…` / `记一下` / `记录一下` / `别忘了…` — and the sentence is captured
+  `note that …`, `don't forget: …`, `TIL …`, `save this …` — or in Chinese
+  `记住…` / `记一下…` / `记录一下…` / `别忘了：…` — and the sentence is captured
   without any tool call. Captures land in the current **project** by default;
-  phrases that signal "this is about me" — `remember for me …`, `记住我…`,
-  `替我记…`, `我觉得…`, `我喜欢…` — go to **personal** instead, and
+  phrases that signal "this is about me" — `remember for me …`, `help me remember: …`,
+  `记住我…`, `替我记…`, `帮我记…`, `我觉得…`, `我喜欢…` — go to **personal** instead, and
   team-context phrases (`我们决定…`, `帮我们记住…`) stay in project.
+  Two rules keep the noise down (D67): a trigger must be a *statement to the
+  store*, so the narration forms `记得…` / `remind me to…` / `别忘了带伞` /
+  `don't forget the wifi password` never fire (add a separator — `别忘了：…`,
+  `don't forget: …` — or `that` to make it an instruction); and a captured body
+  under 3 characters is rejected as a fragment rather than saved — `capture
+  --dry-run` says so instead of dropping it silently.
 - **The agent saves it**: in any editor, ask your agent to remember something
   (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
@@ -378,7 +385,7 @@ Three ways memories get in:
   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`
+- **The CLI**: `open-memex add "…"` with optional `--scope` / `--tag` / `--type`
   / `--aliases`.
 
 **Aliases.** Each saved memory can carry up to 4 alternate phrasings
@@ -409,7 +416,7 @@ they only matter once you share memories through Git.
 |---|---|
 | ● `memory_add`       | Save a fact, preference, decision, note |
 | ● `memory_search`    | Keyword search (BM25) across project + personal memories |
-| ● `memory_list`      | List memories in a scope, newest first |
+| ● `memory_list`      | List memories in a scope (`project`, `personal`, or `both`), newest first |
 | ● `memory_supersede` | Replace a memory with a newer version (keeps a supersede chain) |
 | ● `memory_forget`    | Delete a memory by id |
 | `memory_status`      | Show the sync queue: outbox drafts, repo review states, uncommitted files |
@@ -605,7 +612,7 @@ open-memex config set sync.autoPull true   # best-effort pull at MCP session sta
 ```
 
 Settable keys: `maxProjectMemories`, `maxProfileItems`, `injectOnFirstTurn`,
-`keywordCaptureEnabled`, `logLevel`, `memoryDir`, and `sync.autoPull` (a dotted
+`keywordCaptureEnabled`, `captureAliases`, `logLevel`, `memoryDir`, and `sync.autoPull` (a dotted
 key that writes into the nested `sync` object). Full design:
 [docs/V2-DESIGN.md](./docs/V2-DESIGN.md).
 
@@ -635,6 +642,7 @@ open-memex add "This repo uses better-sqlite3" --type fact
 open-memex search "auth flow"
 open-memex search "auth flow" --explain   # show FTS expression, scores, lifecycle-hidden counts
 open-memex list --scope project
+open-memex list --scope both       # each scope's newest under its own header
 open-memex supersede <id> "Updated content"
 open-memex status <id> deprecated
 open-memex forget <id>

package/README.zh-CN.md

@@ -162,7 +162,7 @@ npx -y open-memex init --yes
 open-memex init --client vscode
 ```
 
-写入 MCP 服务器配置并可干净重载；重载窗口，确认 Copilot Chat 的 MCP 面板里 `open-memex` 服务器已启动。默认把配置写到 VS Code 的*用户级*配置（每个项目都生效）；也可以写到项目级 `.vscode/mcp.json`。
+写入 MCP 服务器配置；重载窗口，确认 Copilot Chat 的 MCP 面板里 `open-memex` 服务器已启动。默认写到项目级 `.vscode/mcp.json`（交互式运行会问你选哪一级）；加 `--global` 改写 VS Code 的*用户级*配置——一次设置，每个项目都生效。
 
 **Cursor**：
 
@@ -170,7 +170,7 @@ open-memex init --client vscode
 open-memex init --client cursor
 ```
 
-形态和 VS Code 一样：默认用户级 MCP 配置，可选项目级 `.cursor/mcp.json`，外加 Copilot 风格的指令文件。
+形态和 VS Code 一样：默认项目级 `.cursor/mcp.json`，`--global` 改为用户级 MCP 配置，外加 Copilot 风格的指令文件。
 
 **opencode**（原生插件——推荐）：
 
@@ -252,10 +252,10 @@ open-memex uninstall --yes
 
 三种存入方式：
 
-- **关键词触发**（仅 opencode 原生插件）：说 `remember …`、`note that …`、`don't forget …`、`TIL …`、`save this …`——中文 `记住…` / `记一下` / `记录一下` / `别忘了…`——这句话就被存下来，不需要任何工具调用。捕获默认进当前 **project**；`remember for me …`、`记住我…`、`替我记…`、`我觉得…`、`我喜欢…` 这类"这是关于我"的信号会改为进 **personal**；`我们决定…`、`帮我们记住…` 等团队语境仍留在项目里。
+- **关键词触发**（仅 opencode 原生插件）：说 `remember …`、`note that …`、`don't forget: …`、`TIL …`、`save this …`——中文 `记住…` / `记一下…` / `记录一下…` / `别忘了：…`——这句话就被存下来，不需要任何工具调用。捕获默认进当前 **project**；`remember for me …`、`help me remember: …`、`记住我…`、`替我记…`、`帮我记…`、`我觉得…`、`我喜欢…` 这类"这是关于我"的信号会改为进 **personal**；`我们决定…`、`帮我们记住…` 等团队语境仍留在项目里。两条降噪规则（D67）：触发词必须是**对存储说的话**，所以叙述型的 `记得…` / `remind me to…` / `别忘了带伞` / `don't forget the wifi password` 一律不触发（加一个分隔符——`别忘了：…`、`don't forget: …`——或用 `that`，才算指令）；捕获内容不足 3 个字符按碎片丢弃，不会存下来——`capture --dry-run` 会明确说明，不再悄悄吞掉。
 - **助手主动保存**：在任何编辑器里，你让助手记住某件事（或者你陈述了一个值得记的事实、它自己判断该保存），它会调用 `memory_add`。上面的路由是启发式规则；你可以明说"存到我的个人记忆"，或用 CLI 加 `--scope` 明确指定。
 - **检查点提议**：一个任务收尾时，助手会提议 1–3 条从这轮工作里提炼的候选记忆——决定及其理由、约定、踩过的坑、走过又放弃的路——只有你点头的那几条才存。不会有任何东西在你不知情时被写下来。
-- **CLI**：`open-memex add "…"`，可选 `--scope` / `--tags` / `--type` / `--aliases`。
+- **CLI**：`open-memex add "…"`，可选 `--scope` / `--tag` / `--type` / `--aliases`。
 
 **别名。** 每条记忆可以带最多 4 个换一种说法（同义词、另一种语言的对应词），和记忆一起进索引，这样问法不同也能找到——比如搜 "vacation days" 能找到假期政策那条。`init` 时会问一次是否开启（默认开）；随时可用 `open-memex config set captureAliases false` 关掉。
 
@@ -275,7 +275,7 @@ MCP 服务器暴露十一个工具；opencode 原生插件暴露其中五个核
 |---|---|
 | ● `memory_add`       | 保存一条事实、偏好、决策、笔记 |
 | ● `memory_search`    | 关键词搜索（BM25），横跨项目 + 个人记忆 |
-| ● `memory_list`      | 列出某个作用域的记忆，最新在前 |
+| ● `memory_list`      | 列出某个作用域（`project`、`personal` 或 `both`）的记忆，最新在前 |
 | ● `memory_supersede` | 用新版本替换一条记忆（保留 supersede 链） |
 | ● `memory_forget`    | 按 id 删除一条记忆 |
 | `memory_status`      | 显示同步队列：outbox 草稿、仓库评审状态、未提交文件 |
@@ -323,7 +323,7 @@ MCP 服务器暴露十一个工具；opencode 原生插件暴露其中五个核
 4. **PR 评审**——记忆是纯 Markdown；评审者走正常分支/PR 流程批准、要求修改或拒绝。
 5. **回想**——已发布的记忆在会话开始时注入，平时也能随时搜，人和助手都一样。
 
-看护共享记忆的人遵循 [维护者约定](./docs/CURATOR.md)：什么该批准、什么该打回、哪些卫生规则让共享记忆不腐烂。
+看护共享记忆的人遵循 [维护者约定](./docs/CURATOR.md)（英文）：什么该批准、什么该打回、哪些卫生规则让共享记忆不腐烂。
 
 ## 回想：记忆是怎么回来的
 
@@ -414,7 +414,7 @@ open-memex config set maxProjectMemories 12
 open-memex config set sync.autoPull true   # MCP 会话开始时尽力而为地 pull
 ```
 
-可设置的键：`maxProjectMemories`、`maxProfileItems`、`injectOnFirstTurn`、`keywordCaptureEnabled`、`logLevel`、`memoryDir`，以及 `sync.autoPull`（带点的键，写入嵌套的 `sync` 对象）。完整设计：[docs/V2-DESIGN.md](./docs/V2-DESIGN.md)。
+可设置的键：`maxProjectMemories`、`maxProfileItems`、`injectOnFirstTurn`、`keywordCaptureEnabled`、`captureAliases`、`logLevel`、`memoryDir`，以及 `sync.autoPull`（带点的键，写入嵌套的 `sync` 对象）。完整设计：[docs/V2-DESIGN.md](./docs/V2-DESIGN.md)（英文）。
 
 ## CLI 参考
 
@@ -442,6 +442,7 @@ open-memex add "This repo uses better-sqlite3" --type fact
 open-memex search "auth flow"
 open-memex search "auth flow" --explain   # 显示 FTS 表达式、分数、被生命周期藏掉的计数
 open-memex list --scope project
+open-memex list --scope both       # 两个作用域各自最新的，各带一个标题
 open-memex supersede <id> "Updated content"
 open-memex status <id> deprecated
 open-memex forget <id>
@@ -462,7 +463,7 @@ open-memex submit <id...> [--branch <name>] [--base <branch>]
 # 把你点名的草稿移进 .ai/open-memex/，标为 "proposed"：
 # 复制、翻转 review_state、在当前分支本地 git 提交。
 # 永不自己建分支——建分支是你（或拿到完整链路明确许可的助手）的事。
-# 全有全無；冲突（同 id 不同内容）干净地中止。
+# 全有全无；冲突（同 id 不同内容）干净地中止。
 # 打印 push + gh pr 命令；持有你 Yes 的助手可以一并执行 push/PR。
 # --branch <name> 先建分支（助手全链路路径）。PR base 默认是当前分支
 # （记忆 PR 叠在你的工作分支上）；--base 可改指到 main 或你的评审分支。
@@ -473,7 +474,7 @@ open-memex pr-status [--apply]
 # 要求修改 → 只给建议。默认只报告；--apply 在本地执行映射的迁移（不推送）。
 
 open-memex pull
-# 从 git 远程拉共享记忆：fetch + 純 fast-forward。
+# 从 git 远程拉共享记忆：fetch + 纯 fast-forward。
 # 分支分叉则明确报错失败——open-memex 永不强制合并；手工解决后再 pull。
 # 成功后本地索引重新同步。pull 默认显式触发；设置
 # `open-memex config set sync.autoPull true` 可在 MCP 会话开始时尽力拉一次
@@ -502,7 +503,7 @@ open-memex distill-agents [--scope project|personal] [--type t1,t2] [--limit N]
 
 open-memex propose <id...> --to project [--local-approve]
 # 一次提议一条或多条个人记忆（一个分支、一个 PR）；
-# 每条复制并生成新 id。全有全無：任何一条 id 出错，整批中止，绝不半途。
+# 每条复制并生成新 id。全有全无：任何一条 id 出错，整批中止，绝不半途。
 # 把一条个人记忆复制到项目作用域作为评审候选
 # （是复制不是移动——个人原件保留）。结果落进 outbox；
 # 准备进仓库时再跑 sync-status / submit。
@@ -547,7 +548,7 @@ npx -y open-memex mcp        # 无需安装
 - **project（项目）**——限定在当前仓库，键由 git origin URL 的 hash 派生（所以同一仓库的多个 clone 共享一个作用域），没有远程时退回到当前工作目录路径。新记忆的默认作用域。
 - **personal（个人）**——横跨你的所有项目，仅限本机，永不向外同步。放个人偏好用。（v1 里叫 `user`；`migrate --to-v2` 会改名。）
 
-完整的 scope 模型（键派生、迁移、可见性、保留名）见 [docs/SCOPES.md](./docs/SCOPES.md)。[概念指南](./docs/CONCEPTS.zh-CN.md)把心智模型完整走了一遍。
+完整的 scope 模型（键派生、迁移、可见性、保留名）见 [docs/SCOPES.md](./docs/SCOPES.md)（英文）。[概念指南](./docs/CONCEPTS.zh-CN.md)把心智模型完整走了一遍。
 
 ## 故障排查
 
@@ -602,7 +603,7 @@ Windows 上已加载的 DLL 是锁定的：如果 open-memex 的 MCP 服务器
 
 ## 项目状态
 
-open-memex 是稳定且日常在用的；当前稳定线以 `latest` 发到 npm 上，`alpha` 构建给测试者。发版历史在 [GitHub Releases](https://github.com/stoneskin/open-memex/releases)；设计决策记录在只追加的日志 [docs/V2-DESIGN.md](./docs/V2-DESIGN.md) 里。
+open-memex 是稳定且日常在用的；当前稳定线以 `latest` 发到 npm 上，`alpha` 构建给测试者。发版历史在 [GitHub Releases](https://github.com/stoneskin/open-memex/releases)；设计决策记录在只追加的日志 [docs/V2-DESIGN.md](./docs/V2-DESIGN.md) 里（英文）。
 
 在望的方向（不承诺版本号）：更多编辑器的原生助手插件（作为在同一组 MCP 工具之上的增强路径）；本地 embedding 作为可选择开启的实验（没经询问，永不下载任何模型）；只有在真实多仓库共享、ACL 或合规需求出现时才做 org 层。
 

package/dist/.build-stamp

@@ -0,0 +1 @@
+f4cf4e253bbf0f3254ec439b1344af50e88cc4fd068b04be73cdc20ee770e819

package/dist/capture/keywords.js

@@ -1,15 +1,27 @@
 /**
- * Scan user text for memory-capture keyword triggers.
+ * D67: capture-body length bounds. The lower bound rejects fragments — a
+ * trigger that yields "这个" or "OK" is a match on the trigger, not a memory,
+ * and a 2-char memory is noise in every future session's injection. The floor
+ * stays deliberately above 1: D67 considered lowering it and decided against
+ * it. What changed is that a rejection is no longer silent (see KeywordDrop).
+ */
+export const MIN_CAPTURE_CHARS = 3;
+export const MAX_CAPTURE_CHARS = 2000;
+/**
+ * Scan user text for memory-capture keyword triggers, reporting both what
+ * would be captured and what matched but was rejected (D67) — a dropped match
+ * that says nothing reads as a broken feature.
  * Each pattern must have a single capture group whose value becomes the memory body.
  * Personal patterns (cfg.keywordPersonalPatterns) force the personal scope.
  *
  * Personal patterns run first and claim their line: an explicit scope signal
  * (e.g. "记住我对花粉过敏") must not also fire the generic 记住 into the project scope.
  */
-export function detectKeywords(userText, cfg) {
-    if (!cfg.keywordCaptureEnabled)
-        return [];
+export function scanKeywords(userText, cfg) {
     const hits = [];
+    const dropped = [];
+    if (!cfg.keywordCaptureEnabled)
+        return { hits, dropped };
     const lines = userText.split(/\r?\n/);
     const claimed = new Set();
     const scan = (patterns, personal, skipClaimed) => {
@@ -28,16 +40,37 @@ export function detectKeywords(userText, cfg) {
                 if (!m || !m[1])
                     continue;
                 const content = m[1].trim().replace(/[.!?]$/, "").trim();
-                if (content.length >= 3 && content.length <= 2000) {
+                if (personal)
+                    claimed.add(i);
+                if (content.length >= MIN_CAPTURE_CHARS && content.length <= MAX_CAPTURE_CHARS) {
                     hits.push({ content, pattern: src, personal });
-                    if (personal)
-                        claimed.add(i);
                     break; // one hit per pattern per message
                 }
+                // Rejected: record it once per pattern. The line stays claimed for
+                // personal patterns even here - "记住我：OK" must not fall through to
+                // the generic 记住 and be saved as "我：OK" (D67).
+                if (!dropped.some((d) => d.pattern === src && d.content === content)) {
+                    dropped.push({
+                        content,
+                        pattern: src,
+                        personal,
+                        reason: content.length < MIN_CAPTURE_CHARS ? "too-short" : "too-long",
+                    });
+                }
+                break;
             }
         }
     };
     scan(cfg.keywordPersonalPatterns, true, false);
     scan(cfg.keywordPatterns, false, true);
-    return hits;
+    if (cfg.logLevel === "debug" && dropped.length > 0) {
+        for (const d of dropped) {
+            console.error(`[open-memex] keyword match not captured (${d.reason === "too-short" ? `body ${d.content.length} chars < ${MIN_CAPTURE_CHARS}` : `body ${d.content.length} chars > ${MAX_CAPTURE_CHARS}`}): "${d.content}"`);
+        }
+    }
+    return { hits, dropped };
+}
+/** Capture-only view of {@link scanKeywords} (drops are logged, not returned). */
+export function detectKeywords(userText, cfg) {
+    return scanKeywords(userText, cfg).hits;
 }

package/dist/cli.js

@@ -11,7 +11,7 @@ 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, normalizeAliases, } from "./store/markdown.js";
-import { loadConfig } from "./config.js";
+import { loadConfig, configSource } from "./config.js";
 import { paths, projectRoot } from "./paths.js";
 import { redact } from "./redact.js";
 import { resolveMcpCommand } from "./init.js";
@@ -29,10 +29,10 @@ Example:
   open-memex where`,
     list: `List memories in a scope, newest first.
 
-Usage: open-memex list [--scope project|personal] [--type T] [--limit N]
+Usage: open-memex list [--scope project|personal|both] [--type T] [--limit N]
 
 Flags:
-  --scope   project (default) or personal
+  --scope   project (default), personal, or both
   --type    filter by memory type
   --limit   max results
 
@@ -80,6 +80,9 @@ Example:
 
 Usage: open-memex status <id> active|deprecated|retracted|archived
 
+Retraction is one-way: a retracted memory cannot be set back to active
+(it was withdrawn on purpose). Save the content as a new memory instead.
+
 Example:
   open-memex status 01ABC deprecated`,
     forget: `Delete a memory by id.
@@ -720,12 +723,11 @@ async function main() {
             process.exit(1);
         }
         const cfg = loadConfig();
-        const { detectKeywords } = await import("./capture/keywords.js");
+        const { scanKeywords, MIN_CAPTURE_CHARS, MAX_CAPTURE_CHARS } = await import("./capture/keywords.js");
         const text = rest.slice(1).join(" ");
-        const hits = detectKeywords(text, cfg);
+        const { hits, dropped } = scanKeywords(text, cfg);
         if (hits.length === 0) {
-            console.log("no keyword triggers — nothing would be captured.");
-            return;
+            console.log("no keyword triggers - nothing would be captured.");
         }
         for (const h of hits) {
             const r = redact(h.content, cfg.redactPatterns);
@@ -734,6 +736,13 @@ async function main() {
             console.log(`  secret hit:   ${r.hadSecret ? `yes (${r.matchedPattern}) — will be masked` : "no"}`);
             console.log(`  body:         ${r.content.slice(0, 160)}${r.content.length > 160 ? "…" : ""}`);
         }
+        // D67: a trigger that matched but produced a fragment is reported, not
+        // silently dropped - otherwise "记住：这个" just looks broken.
+        for (const d of dropped) {
+            console.log(d.reason === "too-short"
+                ? `! matched but NOT captured: body "${d.content}" is ${d.content.length} chars (floor: ${MIN_CAPTURE_CHARS}). A trigger alone isn't a memory - write the fact: "记住：<fact>".`
+                : `! matched but NOT captured: body is ${d.content.length} chars (ceiling: ${MAX_CAPTURE_CHARS}) - save it with memory_add instead.`);
+        }
         return;
     }
     // `mcp` starts the stdio MCP server (11 tools; the opencode plugin exposes 5).
@@ -752,6 +761,7 @@ async function main() {
     if (cmd === "where") {
         const p = paths();
         console.log(`root:      ${p.root}`);
+        console.log(`config:    ${configSource() ?? "(built-in defaults)"}`);
         console.log(`memories:  ${p.memories}`);
         console.log(`index:     ${p.indexDb}`);
         console.log(`project:   ${project.key}`);
@@ -766,20 +776,26 @@ async function main() {
     }
     if (cmd === "list") {
         const flags = parseFlags(rest);
-        const s = resolveCliScope(flags, project);
-        syncScope(s.key, "cli");
-        const hits = list(s.key, {
-            type: flags.type,
-            limit: flags.limit ? Number(flags.limit) : undefined,
-        });
-        if (hits.length === 0) {
-            console.log(`(no memories in ${s.key})`);
-            return;
-        }
-        for (const h of hits) {
-            const dep = h.status === "deprecated" ? " [deprecated]" : "";
-            const rev = hitStateLabel(h);
-            console.log(`[${h.type}]${dep}${rev} ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+        // D66: --scope both, on par with the memory_list tool — prints each
+        // scope's newest under its own header.
+        const scopes = flags.scope === "both" ? [project, PERSONAL_SCOPE] : [resolveCliScope(flags, project)];
+        for (const s of scopes) {
+            syncScope(s.key, "cli");
+            const hits = list(s.key, {
+                type: flags.type,
+                limit: flags.limit ? Number(flags.limit) : undefined,
+            });
+            if (scopes.length > 1)
+                console.log(`## ${s.kind} (${s.key})`);
+            if (hits.length === 0) {
+                console.log(`(no memories in ${s.key})`);
+                continue;
+            }
+            for (const h of hits) {
+                const dep = h.status === "deprecated" ? " [deprecated]" : "";
+                const rev = hitStateLabel(h);
+                console.log(`[${h.type}]${dep}${rev} ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+            }
         }
         return;
     }
@@ -1089,7 +1105,7 @@ async function main() {
         syncScope(project.key, "cli");
         syncScope(PERSONAL_SCOPE.key, "cli");
         try {
-            console.log(formatSyncStatus(getSyncStatus()));
+            console.log(formatSyncStatus(getSyncStatus(), { cap: Number.POSITIVE_INFINITY }));
         }
         catch (e) {
             console.error(`sync-status failed: ${e.message}`);

package/dist/config.js

@@ -8,25 +8,39 @@ export const DEFAULT_CONFIG = {
     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+(.+)$",
+        "^\\s*remember(?!\\s+for\\s+me)(?:\\s+that|\\s+to)?[:,]?\\s+(.+)$",
+        "^\\s*(?:please\\s+)?note(?:\\s+that)?[:,]?\\s+(.+)$",
+        // D67: "don't forget the wifi password" is narration addressed to the
+        // agent, not a statement to the store. An explicit marker - "that" or a
+        // colon - makes it an instruction ("don't forget that ..." / "don't
+        // forget: ..."). Mirrors 别忘了 below; see D67.
+        "^\\s*(?:please\\s+)?don'?t\\s+forget(?:\\s+that\\s+|[:,]\\s+)(.+)$",
         "^\\s*TIL[:,]?\\s+(.+)$",
         "^\\s*save\\s+(?:this|to\\s+memory)[:,]?\\s+(.+)$",
         // Chinese equivalents
-        "^\\s*记住(?!（个人）)[：:,，]?\\s*(.+)$",
+        "^\\s*(?:请)?记住(?!（个人）)[：:,，]?\\s*(.+)$",
         "^\\s*(?:请)?(?:记一下|记录一下)[：:,，]?\\s*(.+)$",
-        "^\\s*别忘了[：:,，]?\\s*(.+)$",
+        // D67: separator required. "别忘了带伞" is narration ("don't forget your
+        // umbrella"); "别忘了：周五不发布" is an instruction to the store. Same
+        // rule as the English "don't forget" above.
+        "^\\s*别忘了[：:,，]\\s*(.+)$",
         // First-person plural: team/project context, NOT personal
         "^\\s*我们认为[：:,，]?\\s*(.+)$",
         "^\\s*我们决定[：:,，]?\\s*(.+)$",
-        "^\\s*帮我们记(?:住|一下)?[：:,，]?\\s*(.+)$",
+        // D67: the boundary applies to the BARE verb only. 记 + (住|录) + 一下 is a
+        // complete verb phrase, so the noun may follow directly ("帮我记住这个配置",
+        // "记一下这个约定"); only a bare 记 needs a separator, otherwise 帮我记得…
+        // would capture mid-word garbage. See D67.
+        "^\\s*(?:请)?帮我们记(?:(?:住|录)(?!得|着)(?:一下)?|一下|(?=[：:,，\\s]|$))[：:,，]?\\s*(.+)$",
     ],
     keywordPersonalPatterns: [
         "^\\s*remember\\s+for\\s+me(?:\\s+that)?[:,]?\\s+(.+)$",
-        "^\\s*记住（个人）[：:,，]?\\s*(.+)$",
+        "^\\s*(?:请)?记住（个人）[：:,，]?\\s*(.+)$",
         // First-person singular: personal scope ("我" → 个人, "我们" → 项目)
-        "^\\s*记住我(?!们)[：:,，]?\\s*(.+)$",
-        "^\\s*替我记(?:住|一下)?[：:,，]?\\s*(.+)$",
+        "^\\s*(?:请)?记住我(?!们)[：:,，]?\\s*(.+)$",
+        "^\\s*(?:请)?替我记(?:(?:住|录)(?!得|着)(?:一下)?|一下|(?=[：:,，\\s]|$))[：:,，]?\\s*(.+)$",
+        "^\\s*(?:请)?帮我记(?:(?:住|录)(?!得|着)(?:一下)?|一下|(?=[：:,，\\s]|$))[：:,，]?\\s*(.+)$",
+        "^\\s*help\\s+me\\s+remember(?:\\s+that)?[:,]?\\s+(.+)$",
         "^\\s*我觉得[：:,，]?\\s*(.+)$",
         "^\\s*我喜欢[：:,，]?\\s*(.+)$",
     ],

package/dist/distill-agents.js

@@ -57,7 +57,12 @@ 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.`, `  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(`- 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.`, 
+    // D64: the skills runbook and the MCP handshake both teach marking
+    // inferred captures source: "inference"; this footer omitted it, so
+    // opencode agents saved distilled conclusions as if the user had
+    // stated them ("tool"). Keep the rubric one voice across surfaces.
+    `- Mark captures you infer (rather than the user stating) with`, `  \`source: "inference"\` — provenance matters more than polish.`);
     lines.push(``);
     return lines.join("\n");
 }

package/dist/doctor.js

@@ -12,12 +12,20 @@ import { paths, homeOverride } from "./paths.js";
 import { resolveCwdScope } from "./scope.js";
 import { db, backendName } from "./store/db.js";
 import { LEGACY_PACKAGE_NAME, opencodeGlobalConfigPath, userMcpConfigPath } from "./init.js";
+// D64: the MCP server exposes eleven tools; checking only the five the
+// opencode plugin carries let a half-registered server pass as healthy.
 const EXPECTED_TOOLS = [
     "memory_add",
     "memory_search",
     "memory_list",
     "memory_supersede",
     "memory_forget",
+    "memory_status",
+    "memory_submit",
+    "memory_propose",
+    "memory_promote",
+    "memory_resolve",
+    "memory_pr_status",
 ];
 function nodeCheck() {
     const [major, minor] = process.versions.node.split(".").map(Number);
@@ -535,6 +543,19 @@ function legacyCheck() {
     const legacyDir = path.join(path.dirname(root), LEGACY_PACKAGE_NAME);
     if (fs.existsSync(legacyDir) && fs.statSync(legacyDir).isDirectory())
         found.push(`legacy data dir ${legacyDir} — merge it with \`open-memex migrate --to-v2\``);
+    // D64: v1 stored personal memories under the scope dir "user"; v2 reads
+    // only "personal". Files left there are invisible to every read path —
+    // an upgrader silently sees an empty personal scope. Surface them here;
+    // the migration itself stays explicit (no silent moves).
+    try {
+        const userDir = path.join(root, "memories", "user");
+        if (fs.existsSync(userDir) &&
+            fs.readdirSync(userDir).some((f) => f.endsWith(".md")))
+            found.push("v1 personal memories under " + userDir + " are invisible to v2 reads — convert them with `open-memex migrate --to-v2` (it moves them to the personal scope; preview with --dry-run)");
+    }
+    catch {
+        /* unreadable — not this check's problem */
+    }
     for (const f of [opencodeGlobalConfigPath(), userMcpConfigPath("vscode"), userMcpConfigPath("cursor")]) {
         try {
             if (fs.existsSync(f) && fs.readFileSync(f, "utf8").includes(LEGACY_PACKAGE_NAME))

package/dist/init.js

@@ -56,11 +56,12 @@ You have a local memory MCP server (\`open-memex\`). Its tools are
 these full names.
 
 - The server tells you when project outbox drafts are waiting for review — in
-  tool results. At session start, call \`memory_status\` once to check. When
-  drafts are waiting, summarize them (one line each) and ask the user which
-  ones to sync into the repo; sync NOTHING the user did not name. If you
-  already asked about these drafts this session, don't ask again. When the
-  server reports none waiting, do nothing.
+  tool results. When it does (or when the user asks), call \`memory_status\`
+  to see them; don't call it blindly at session start. When drafts are
+  waiting, summarize them (one line each) and ask the user which ones to
+  sync into the repo; sync NOTHING the user did not name. If you already
+  asked about these drafts this session, don't ask again. When the server
+  reports none waiting, do nothing.
 - BE PROACTIVE about facts the user states directly: when the user shares a
   decision, preference, project convention, or fix-and-cause worth remembering
   across sessions, call \`memory_add\` without being asked. Keep each memory to
@@ -286,7 +287,17 @@ function opencodePluginDir() {
  * 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");
+    const dir = opencodeConfigDir(home, process.env.XDG_CONFIG_HOME);
+    // D64: init writes into whichever of .json/.jsonc already exists
+    // (writeOpencodeGlobalPlugin), so readers must resolve the same file.
+    // Hardcoding .json made uninstall report "nothing to remove" on
+    // .jsonc-only setups and left the plugin entry behind.
+    for (const name of ["opencode.jsonc", "opencode.json"]) {
+        const candidate = path.join(dir, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return path.join(dir, "opencode.json");
 }
 /**
  * Pure merge of the open-memex plugin URL into a parsed opencode config doc.