open-memex 0.7.0-alpha.6 → 0.7.0-alpha.9

package/AGENTS.md

@@ -33,6 +33,7 @@ npm run typecheck                                    # tsc --noEmit — the only
 npm run cli -- where | list | search "q" | add ... | forget <id> | reindex
 npm run cli -- <command> --help                          # per-command help (AI assistants discover flags this way)
 npm run cli -- sync-status                                  # last sync time/kind + outbox drafts + repo review states + uncommitted files
+npm run cli -- inventory [--format text|json] [--scope both]  # what is remembered, in the open (D68); personal-bearing output refused inside a git worktree without --allow-personal
 npm run cli -- audit [--scope project|personal|both]            # memory health: near-dup pairs, stale actives, broken chains, personal-in-repo (read-only)
 npm run cli -- pull                                          # fetch + fast-forward only (explicit; diverged = clean failure, never force-merge)
 npm run cli -- push                                          # push current branch to remote (explicit only; open-memex never auto-pushes)
@@ -157,15 +158,17 @@ AGENTS.md hygiene footer, the MCP handshake, and the tool descriptions.
 - 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 (decisions D1–D64 settled; open questions tracked at the end of the doc). Per its §12:
+`docs/V2-DESIGN.md` is the frozen protocol v0.2 (decisions settled through D68; 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–D68). 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,33 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## Memory visibility: see it, hide it, delete it (D68)
+
+Group 3-C — the surface a user reads to learn what the store actually remembers:
+
+- **`memory_list` is now a numbered inventory.** Lines are structured (`[type] id=… created=… source=…`), keep the raw provenance, and every listing states its true total — a truncated list says how many entries it is not showing instead of quietly looking complete. New input `include: "active" | "all"` (default `active`): **behavior change** — superseded versions, retracted and archived memories no longer appear unless you pass `include=all` (the audit view). The CLI gains the matching `list --include` flag.
+- **`open-memex inventory`** renders the same data as readable text (default) or JSON (`--format json`, format `open-memex-inventory/1`) — personal plus the current project, outbox drafts in their own section, hidden history counted rather than silently dropped. A report containing personal memories refuses to be written inside a git working tree without `--allow-personal`.
+- **Hide instead of delete:** `memory_forget` gains `soft=true` (CLI: `forget --soft`) — the memory is retracted: out of lists and search, file kept. Still one-way (D64): bringing the fact back means saving it again.
+- **Guidance kept in one voice:** the tool descriptions, the MCP session-start instructions, SKILL.md and the `distill-agents` AGENTS.md snippet all teach the same flow — answer "what do you remember?" conversationally from the inventory, re-list before acting on a number, read an entry back before deleting it.
+
+## 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:

package/README.md

@@ -364,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
@@ -410,9 +416,9 @@ 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 (`project`, `personal`, or `both`), newest first |
+| ● `memory_list`      | List memories in a scope (`project`, `personal`, or `both`) as a numbered inventory; `include=all` is the audit view |
 | ● `memory_supersede` | Replace a memory with a newer version (keeps a supersede chain) |
-| ● `memory_forget`    | Delete a memory by id |
+| ● `memory_forget`    | Delete a memory by id (`soft=true` hides it instead — retracted, one-way) |
 | `memory_status`      | Show the sync queue: outbox drafts, repo review states, uncommitted files |
 | `memory_submit`      | Move named drafts into the repo memory dir (local branch + commit) |
 | `memory_propose`     | Copy personal memories into the project scope as review candidates |
@@ -636,9 +642,18 @@ 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 list --include all      # audit view: superseded versions, retracted, archived
 open-memex supersede <id> "Updated content"
 open-memex status <id> deprecated
 open-memex forget <id>
+open-memex forget <id> --soft      # hide instead of delete (retracted; one-way)
+
+open-memex inventory                        # everything remembered, as readable text
+open-memex inventory --format json          # the same data, for agents
+# Personal + current project, outbox drafts in their own section, hidden
+# history counted. Refuses to write a personal-bearing report inside a
+# git working tree unless you pass --allow-personal.
 ```
 
 Team review workflow (two homes, one per stage):

package/README.zh-CN.md

@@ -252,7 +252,7 @@ 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` / `--tag` / `--type` / `--aliases`。
@@ -275,9 +275,9 @@ MCP 服务器暴露十一个工具；opencode 原生插件暴露其中五个核
 |---|---|
 | ● `memory_add`       | 保存一条事实、偏好、决策、笔记 |
 | ● `memory_search`    | 关键词搜索（BM25），横跨项目 + 个人记忆 |
-| ● `memory_list`      | 列出某个作用域（`project`、`personal` 或 `both`）的记忆，最新在前 |
+| ● `memory_list`      | 以编号清单列出某个作用域（`project`、`personal` 或 `both`）的记忆；`include=all` 是审计视图 |
 | ● `memory_supersede` | 用新版本替换一条记忆（保留 supersede 链） |
-| ● `memory_forget`    | 按 id 删除一条记忆 |
+| ● `memory_forget`    | 按 id 删除一条记忆（`soft=true` 改为隐藏——retracted，单向） |
 | `memory_status`      | 显示同步队列：outbox 草稿、仓库评审状态、未提交文件 |
 | `memory_submit`      | 把指定的草稿移进仓库记忆目录（本地分支 + 提交） |
 | `memory_propose`     | 把个人记忆复制到项目作用域，作为评审候选 |
@@ -442,9 +442,17 @@ 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 list --include all      # 审计视图：被替换的版本、已撤回、已归档
 open-memex supersede <id> "Updated content"
 open-memex status <id> deprecated
 open-memex forget <id>
+open-memex forget <id> --soft      # 隐藏而不是删除（retracted，单向）
+
+open-memex inventory                        # 记住的一切，纯文本清单
+open-memex inventory --format json          # 同一份数据，JSON 格式给 agent 用
+# 个人 + 当前项目，outbox 草稿单独成节，被藏起的历史只计数。含个人内容的
+# 报告拒绝写进 git 工作树，除非显式 --allow-personal。
 ```
 
 团队评审工作流（两个家，一个阶段一个）：

package/dist/.build-stamp

@@ -0,0 +1 @@
+3a590ae176c625e174a075a2d9068fe443d23c374f70fc7df76809ff10a63ad4

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

@@ -17,7 +17,22 @@ import { redact } from "./redact.js";
 import { resolveMcpCommand } from "./init.js";
 import fs from "node:fs";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+/** True when `target` sits inside a git working tree (D68 guard). */
+function isInsideWorkTree(target) {
+    try {
+        const dir = path.dirname(path.resolve(target));
+        const out = execFileSync("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+        });
+        return out.trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
 /** Per-command help, printed by `open-memex <command> --help`.
     AI assistants discover the CLI through --help, so every command needs one. */
 const COMMAND_HELP = {
@@ -29,12 +44,14 @@ 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] [--include active|all]
 
 Flags:
-  --scope   project (default) or personal
-  --type    filter by memory type
-  --limit   max results
+  --scope    project (default), personal, or both
+  --type     filter by memory type
+  --limit    max results
+  --include  active (default: what is currently remembered) or all (audit
+             view: superseded versions, retracted and archived included)
 
 Examples:
   open-memex list
@@ -80,14 +97,20 @@ 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.
+    forget: `Delete a memory by id. With --soft, hide it instead: the memory
+is retracted (out of lists and search, file kept). Retraction is one-way —
+save the content as a new memory to bring it back.
 
-Usage: open-memex forget <id>
+Usage: open-memex forget <id> [--soft]
 
 Example:
-  open-memex forget 01ABC`,
+  open-memex forget 01ABC
+  open-memex forget 01ABC --soft`,
     propose: `Copy personal memories into the project outbox as review drafts.
 The personal originals stay put. Nothing enters git at this step.
 
@@ -134,6 +157,19 @@ Usage: open-memex sync-status
 
 Example:
   open-memex sync-status`,
+    inventory: `Show everything remembered — personal + this project — in the
+open: what each memory says, where it came from, and whether it has reached
+the repo yet. Read-only; deleting stays a confirmed conversation with your
+agent. Formats: text (default, diffable) and json (for agents).
+
+Usage: open-memex inventory [--format text|json] [--scope project|personal|both] [--out <path>] [--allow-personal]
+
+Default scope: both. Without --out the report goes to stdout. A report that
+includes personal memories is refused inside a git working tree unless
+--allow-personal is passed — personal content must not ride a commit.
+
+Example:
+  open-memex inventory --format json --out ~/inventory.json`,
     pull: `Pull shared project memories from the git remote: fetch + fast-forward
 only. Never auto-merges — a diverged branch fails with a clear message and is
 left for you to resolve by hand. On success the local index re-syncs.
@@ -331,16 +367,17 @@ function usage(exitCode = 1) {
 
 Usage:
   open-memex where
-  open-memex list [--scope project|personal] [--type T] [--limit N]
+  open-memex list [--scope project|personal|both] [--type T] [--limit N] [--include active|all]
   open-memex search "query" [--scope project|personal|both] [--type T] [--limit N] [--explain]
   open-memex add "content" [--scope project|personal] [--type T] [--tag t1,t2]
   open-memex supersede <id> "new content" [--type T] [--tag t1,t2]
   open-memex status <id> active|deprecated|retracted|archived
-  open-memex forget <id>
+  open-memex forget <id> [--soft]
   open-memex propose <id...> --to project [--local-approve]
   open-memex promote <id> [--reject] [--resubmit] [--note "..."] [--by NAME]
   open-memex resolve [id-or-path]
   open-memex sync-status
+  open-memex inventory [--format text|json] [--scope project|personal|both] [--out <path>] [--allow-personal]
   open-memex pull
   open-memex push
   open-memex export [--scope project|personal|both] [--type T] [--tag t] [--all] [-o <file>]
@@ -720,12 +757,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 +770,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).
@@ -767,20 +810,27 @@ 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,
+                include: flags.include === "all" ? "all" : "active",
+            });
+            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 !== "active" ? ` [${h.status}]` : "";
+                const rev = hitStateLabel(h);
+                console.log(`[${h.type}]${dep}${rev} ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+            }
         }
         return;
     }
@@ -949,6 +999,20 @@ async function main() {
         const id = rest[0];
         if (!id)
             usage();
+        // D68: --soft hides (retracts) instead of deleting — same action as
+        // the memory_forget tool's soft flag. One-way (D64).
+        if (rest.includes("--soft")) {
+            try {
+                const mf = setStatus(id, "retracted");
+                upsertFromFile(mf);
+                console.log(`hidden ${id} (retracted — out of lists and search; save it again as a new memory to bring it back)`);
+            }
+            catch (e) {
+                console.error(`hide failed: ${e.message}`);
+                process.exit(1);
+            }
+            return;
+        }
         const row = db().prepare(`SELECT file_path FROM memories WHERE id = ?`).get(id);
         if (!row) {
             console.error("not found");
@@ -1086,11 +1150,57 @@ async function main() {
         }
         return;
     }
+    if (cmd === "inventory") {
+        // D68: refresh both scopes first so the report matches the markdown
+        // on disk. Default scope: personal + this project.
+        syncScope(project.key, "cli");
+        syncScope(PERSONAL_SCOPE.key, "cli");
+        const flags = parseFlags(rest);
+        const format = flags.format ?? "text";
+        if (format !== "text" && format !== "json") {
+            console.error(`inventory: unknown --format '${format}' (text|json; html arrives separately)`);
+            process.exit(2);
+        }
+        const scopeKeys = flags.scope === "personal"
+            ? [PERSONAL_SCOPE.key]
+            : flags.scope === "project"
+                ? [project.key]
+                : [PERSONAL_SCOPE.key, project.key];
+        const outPath = flags["out"] ?? flags["output"];
+        // D68/3-C v2: the report contains personal content. Writing it into
+        // a git working tree would ride the next commit off this machine —
+        // refuse unless the user explicitly accepts that.
+        if (outPath &&
+            scopeKeys.includes(PERSONAL_SCOPE.key) &&
+            flags["allow-personal"] !== "true" &&
+            isInsideWorkTree(outPath)) {
+            console.error(`inventory: ${outPath} is inside a git working tree and this report includes personal memories. ` +
+                `Refusing to write it there. Pass --allow-personal if you really want that, or write outside the repo.`);
+            process.exit(2);
+        }
+        try {
+            const { loadInventory, renderInventoryText, renderInventoryJson } = await import("./inventory.js");
+            const data = loadInventory(scopeKeys);
+            const rendered = format === "json" ? renderInventoryJson(data) : renderInventoryText(data);
+            if (outPath) {
+                fs.writeFileSync(outPath, rendered, "utf8");
+                console.log(`inventory: ${data.total} memories → ${outPath}`);
+            }
+            else {
+                process.stdout.write(rendered);
+            }
+        }
+        catch (e) {
+            console.error(`inventory failed: ${e.message}`);
+            process.exit(2);
+        }
+        return;
+    }
     if (cmd === "sync-status") {
         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

@@ -9,25 +9,38 @@ export const DEFAULT_CONFIG = {
     captureAliases: true,
     keywordPatterns: [
         "^\\s*remember(?!\\s+for\\s+me)(?:\\s+that|\\s+to)?[:,]?\\s+(.+)$",
-        "^\\s*(?:please\\s+)?(?:note|don'?t\\s+forget)(?:\\s+that)?[:,]?\\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*(.+)$",
+        // 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*(.+)$",
         // 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

@@ -62,7 +62,10 @@ export function distillAgentsMarkdown(opts) {
     // 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.`);
+    `- Mark captures you infer (rather than the user stating) with`, `  \`source: "inference"\` — provenance matters more than polish.`, 
+    // D68: same voice for the visibility surface — opencode agents reading
+    // this footer never see the MCP handshake either.
+    `- When the user asks what you remember, list it conversationally`, `  (\`memory_list\` with scope both, or \`open-memex inventory\`) — plain`, `  words, not raw ids. Before deleting an entry they point at, read it`, `  back in full and confirm; deletion is permanent. Offer hiding`, `  (\`memory_forget\` soft / \`forget --soft\`) when they hesitate.`);
     lines.push(``);
     return lines.join("\n");
 }