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

package/AGENTS.md

@@ -157,7 +157,9 @@ 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.
 
@@ -165,7 +167,7 @@ Context injection happens exactly once per session in `experimental.chat.system.
 
 `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,24 @@ 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:

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
@@ -636,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

@@ -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`。
@@ -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>

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

@@ -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).
@@ -767,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;
     }
@@ -1090,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

@@ -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/submit.js

@@ -127,7 +127,7 @@ export function outboxDraftCount(scopeKey) {
         .get(scopeKey, outboxDir + path.sep);
     return row?.n ?? 0;
 }
-export function formatSyncStatus(st) {
+export function formatSyncStatus(st, opts = {}) {
     const lines = [];
     lines.push(`project: ${st.projectName} (${st.scopeKey})`);
     // D31: when the index was last synced and what triggered it.
@@ -138,13 +138,16 @@ export function formatSyncStatus(st) {
     else {
         lines.push(`last sync: never`);
     }
-    const CAP = 20;
+    // Agent-facing renders cap each section so a big store can't flood a
+    // tool result; the cap line points at the CLI, which shows everything.
+    const CAP = opts.cap ?? 20;
+    const more = (n) => `  … and ${n} more (full list: open-memex sync-status)`;
     lines.push(`outbox (appdata, pending sync): ${st.outbox.length}`);
     for (const e of st.outbox.slice(0, CAP)) {
         lines.push(`  ${e.id}  [${e.reviewState}] ${e.title}`);
     }
     if (st.outbox.length > CAP)
-        lines.push(`  … and ${st.outbox.length - CAP} more`);
+        lines.push(more(st.outbox.length - CAP));
     const byState = new Map();
     for (const e of st.inRepo)
         byState.set(e.reviewState, (byState.get(e.reviewState) ?? 0) + 1);
@@ -155,7 +158,7 @@ export function formatSyncStatus(st) {
         lines.push(`  ${e.id}  [${e.reviewState}]${u} ${e.title}`);
     }
     if (st.inRepo.length > CAP)
-        lines.push(`  … and ${st.inRepo.length - CAP} more`);
+        lines.push(more(st.inRepo.length - CAP));
     if (st.uncommitted.length > 0) {
         lines.push(`note: ${st.uncommitted.length} repo file(s) not yet committed — they ride with the working tree until you commit.`);
     }

package/dist/tools/memory.js

@@ -22,9 +22,14 @@ export function makeTools(getScope, cfg) {
             syncScope(getScope().key, "request");
             syncScope(PERSONAL_SCOPE.key, "request");
         }
-        catch {
-            // A failed sync must not take the tools down with it; the index
-            // may be stale for this call but the tool still answers.
+        catch (err) {
+            // Deliberate asymmetry with the MCP adapter (which lets sync errors
+            // propagate as tool errors): a failed sync must not take the plugin
+            // tools down — the index may be stale for this call but the tool
+            // still answers. Loud at debug, silent otherwise.
+            if (cfg.logLevel === "debug") {
+                console.error("[open-memex] pre-tool sync failed:", err);
+            }
         }
     };
     const memory_add = tool({

package/docs/V2-DESIGN.md

@@ -1,6 +1,6 @@
 # OpenMemex — Design Document (protocol v0.2)
 
-**Status:** FROZEN — protocol v0.2 (2026-09-26). Decisions D1–D64 are settled; open questions are tracked at the end of this document.
+**Status:** FROZEN — protocol v0.2 (2026-09-26). Decisions D1–D67 are settled; open questions are tracked at the end of this document.
 **Author:** Stone, with 小沐
 **Changelog vs v1:** incorporates round-3 review from Perplexity, Grok, Gemini, ChatGPT, DeepSeek.
 Key changes: Design Principles section; `role` separated from `type`; two iron rules;
@@ -569,8 +569,10 @@ requirement: personal data never touches third-party services). Benchmarks to tr
 - Times: epoch ms → RFC 3339. `priority: N` → `importance: low|normal|high` (1–3 low, 4–7 normal, 8–10 high).
 - `type: instruction` (if any v1 memory used it) → `type: <content-kind>` + `role: instruction`.
 - Index is discarded and rebuilt from markdown files. `open-memex migrate --dry-run` previews everything.
-- Legacy paths: v1 `.my-o-memory/` repo dirs and `~/.my-o-memory/` config are moved to `.open-memex/` /
-  `~/.open-memex/` during migration (originals kept as backup until the user confirms).
+- Legacy paths: v1 `.my-o-memory/` repo dirs and `~/.my-o-memory/` config are moved to the
+  v2 locations (in-repo `.ai/open-memex/`; data root per §4/paths — `OPEN_MEMEX_HOME`, else
+  `%APPDATA%\open-memex` or `$XDG_DATA_HOME/open-memex`) by `open-memex migrate --to-v2`,
+  with the pre-migration tree kept as a dated backup.
 
 ---
 
@@ -1383,6 +1385,65 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   and the secret-masking windows stay as they are — narrowing them is a
   capture-recall tradeoff that needs an explicit decision, not a drive-by.
 
+- **D66 — follow-up review of the D63–D65 stack.** (1) The 帮/替
+  keyword family is rebuilt around full verb phrases: an optional `请`,
+  `记` + optional `住|录` + optional `一下`, then a separator boundary —
+  `请帮我记住：…` captures (D65's new pattern lacked its own `请`),
+  `帮我记录一下：…` saves `周五不发布` instead of the mid-word garbage
+  `录一下：…`, and `帮我记得…` does not fire. `help me remember: …`
+  joins the personal patterns. Still deliberately unchanged: shortening
+  the ≥3-char content floor (it eats `记一下这个`-type captures, but
+  lowering it invites junk) and adding narrative triggers like `记得…` /
+  `remind me to…` (imperative-vs-narration ambiguity) — both need an
+  explicit decision. (2) `sync-status` CLI shows the full list; the
+  20-line cap binds only agent renders, whose "… and N more" line names
+  the CLI. `list --scope both` reaches CLI parity with the tool, and
+  `status --help` documents the retracted one-way door. (3) The test
+  suite is Windows-safe (probe imports are `file://` URLs, the uninstall
+  test sets `USERPROFILE` since `os.homedir()` ignores `HOME` there)
+  and refuses to run against a stale `dist/`. (4) Sync-error posture is
+  now a stated asymmetry: the MCP adapter lets pre-call sync errors
+  propagate as tool errors; the plugin adapter logs them at debug and
+  answers from a possibly-stale index rather than taking the tools
+  down. (5) §19's legacy-paths text now names the shipped locations;
+  historical decision entries keep their as-decided wording.
+
+- **D67 — keyword capture: a trigger must be a statement to the store.**
+  Three rulings, all from the D66 review's open items plus one bug D66
+  introduced. (1) **The boundary guard guards the bare verb only.** D66 put
+  a separator requirement *after* the whole verb phrase, which killed the
+  commonest Chinese form — `帮我记一下这个配置`, `帮我记住这个配置`,
+  `替我记一下我住在杭州`, `帮我们记一下这个约定` all stopped matching, because
+  the noun follows 记一下/记住 directly. The guard now applies only to a
+  bare 记: `记` + (`住`|`录`, never followed by a verb continuation like
+  得/着) + optional `一下`, or a separator. So mid-word garbage (`帮我记得带伞`
+  → `带伞`) is still impossible while the natural form captures. (2) **The
+  ≥3-char body floor stays, but stops being silent.** A trigger that yields
+  `这个` or `OK` is a match on the trigger, not a memory, and a 2-char memory
+  is noise in every later injection — so the floor is deliberately *not*
+  lowered (a script-aware floor is the escape hatch if short Latin bodies
+  ever matter). What changed is honesty: `capture --dry-run` prints the
+  rejection with the reason, and `logLevel: debug` logs it, so "nothing
+  happened" is never a mystery. A rejected **personal** match also keeps
+  its line claimed — otherwise `记住我：OK` fell through to the generic
+  记住 and was saved as the nonsense project memory `我：OK`. (3) **Narrative
+  forms are not triggers.** `记得…`, `remind me to…`, `I always forget to…`
+  stay out: they are imperatives aimed at the agent, they are the most
+  frequent sentences in any conversation that mentions memory, and a false
+  trigger writes permanent state nobody reviewed — while a missed trigger
+  costs one sentence. The asymmetry is deliberate: precision over recall.
+  For the two ambiguous forms already in the list, an explicit marker now
+  separates narration from instruction: `别忘了：…` / `don't forget: …` /
+  `don't forget that …` capture; bare `别忘了带伞` / `don't forget the wifi
+  password` do not. The `note` family is untouched — `note the API is v2`
+  was never ambiguous. (4) Test/tooling honesty: `test-full.ts` guards the
+  built `dist/` with a content fingerprint (`scripts/build-stamp.mjs`)
+  rather than mtimes — `git checkout` rewrites mtimes, so a branch switch
+  could leave an older-branch dist looking fresh — and the agent-facing
+  `memory_status` cap is pinned again (20 entries per section plus a
+  "full list: open-memex sync-status" pointer) after D66's CLI-parity test
+  had dropped that coverage.
+
 ## Open Questions
 
 _Some early questions are resolved — see D10 (rename), D11 (type/role split), D12 (explicit pull). The entries below are open unless marked decided._

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.7.0-alpha.6",
+  "version": "0.7.0-alpha.8",
   "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,7 +17,7 @@
     "typecheck": "tsc --noEmit",
     "cli": "node --experimental-strip-types src/cli.ts",
     "mcp": "node --experimental-strip-types src/mcp.ts",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node scripts/build-stamp.mjs",
     "prepublishOnly": "npm run build",
     "postinstall": "node scripts/postinstall.js"
   },

package/scripts/build-stamp.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Dist freshness stamp (D67).
+ *
+ * scripts/test-full.ts runs the *built* dist/cli.js, so a stale dist turns src
+ * fixes into phantom product failures. An mtime comparison is not enough:
+ * `git checkout` rewrites src mtimes, so switching branches can leave an
+ * older-branch dist looking newer than the branch's own src. So the build
+ * records a content fingerprint of every .ts file under src/ and the test
+ * compares that.
+ *
+ *   node scripts/build-stamp.mjs           # write dist/.build-stamp
+ *   node scripts/build-stamp.mjs --check   # verify, exit 1 when stale
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const SRC = path.join(REPO, "src");
+const STAMP = path.join(REPO, "dist", ".build-stamp");
+
+function tsFiles(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...tsFiles(p));
+    else if (entry.name.endsWith(".ts")) out.push(p);
+  }
+  return out.sort();
+}
+
+/** Hash of every .ts path + content under src/: stable across checkouts, exact. */
+export function srcFingerprint() {
+  const h = createHash("sha256");
+  for (const file of tsFiles(SRC)) {
+    h.update(path.relative(REPO, file).replace(/\\/g, "/"));
+    h.update(readFileSync(file));
+  }
+  return h.digest("hex");
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const want = srcFingerprint();
+  if (process.argv.includes("--check")) {
+    const have = existsSync(STAMP) ? readFileSync(STAMP, "utf8").trim() : "";
+    if (have !== want) {
+      console.error(
+        `dist/ is stale (build stamp ${have ? have.slice(0, 12) : "missing"} != src ${want.slice(0, 12)}) - run \`npm run build\` before scripts/test-full.ts`,
+      );
+      process.exit(1);
+    }
+    console.log(`dist/ build stamp ok (${want.slice(0, 12)})`);
+  } else {
+    if (!existsSync(path.join(REPO, "dist"))) {
+      console.error("dist/ not found - run `npm run build` first");
+      process.exit(1);
+    }
+    writeFileSync(STAMP, want + "\n", "utf8");
+    console.log(`wrote dist/.build-stamp (${want.slice(0, 12)})`);
+  }
+}

package/scripts/smoke-pure.ts

@@ -3,7 +3,7 @@
 import { parse, serialize, ulid, normalizeFrontmatter, msToRfc3339, timeToMs, parseRawFrontmatter, normalizeAliases, type Frontmatter } from "../src/store/markdown.ts";
 import { planConversion, isV2File, migrateV2 } from "../src/store/v2migrate.ts";
 import { redact, findSecret } from "../src/redact.ts";
-import { detectKeywords } from "../src/capture/keywords.ts";
+import { detectKeywords, scanKeywords } from "../src/capture/keywords.ts";
 import { DEFAULT_CONFIG } from "../src/config.ts";
 import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/scope.ts";
 import { cjkIndexText, cjkQueryExpr, hasCjk } from "../src/retrieve/cjk.ts";
@@ -281,6 +281,83 @@ ok("remember Toronto… body intact", g5.length === 1 && g5[0]?.content === "Tor
 const g6 = detectKeywords("帮我们记住：周五不发布", DEFAULT_CONFIG);
 ok("帮我们记住 → project", g6.length === 1 && g6[0]?.personal === false, JSON.stringify(g6));
 
+console.log("== keywords: review follow-ups (D66) ==");
+// The new 帮我记 pattern initially shipped without the (?:请)? its siblings
+// got in D65 — 请帮我记住 fell through again.
+const f1 = detectKeywords("请帮我记住：这个项目用 pnpm", DEFAULT_CONFIG);
+ok("请帮我记住 → personal", f1.length === 1 && f1[0]?.personal === true && f1[0]?.content === "这个项目用 pnpm", JSON.stringify(f1));
+// 帮我记录一下 used to capture mid-word garbage ("录一下：…"). The verb
+// phrase now includes 记录/记录一下 and must end at a separator boundary.
+const f2 = detectKeywords("帮我记录一下：周五不发布", DEFAULT_CONFIG);
+ok("帮我记录一下 body clean", f2.length === 1 && f2[0]?.content === "周五不发布", JSON.stringify(f2));
+const f3 = detectKeywords("替我记录一下：护照在抽屉里", DEFAULT_CONFIG);
+ok("替我记录一下 body clean", f3.length === 1 && f3[0]?.content === "护照在抽屉里", JSON.stringify(f3));
+// The boundary guard: 帮我记得… is not a capture form and must not fire.
+const f4 = detectKeywords("帮我记得带伞", DEFAULT_CONFIG);
+ok("帮我记得 → no capture", f4.length === 0, JSON.stringify(f4));
+// English personal phrasing on par with "remember for me".
+const f5 = detectKeywords("Help me remember: the wifi is on the fridge note", DEFAULT_CONFIG);
+ok("help me remember → personal", f5.length === 1 && f5[0]?.personal === true, JSON.stringify(f5));
+
+console.log("== keywords: separator-less verb phrases (D67) ==");
+// D66's boundary guard was one notch too strict: it demanded a separator even
+// after a COMPLETE verb phrase, so the most natural form - "帮我记一下这个配置",
+// with the noun straight after 记一下 - stopped matching. The boundary now
+// guards the bare verb only (记 must be followed by 住/录/一下 or a separator),
+// so 记得/记着 still cannot produce mid-word garbage.
+const v1 = detectKeywords("帮我记一下这个配置", DEFAULT_CONFIG);
+ok("帮我记一下这个配置 (no separator)", v1.length === 1 && v1[0]?.personal === true && v1[0]?.content === "这个配置", JSON.stringify(g1));
+const v2 = detectKeywords("帮我记住这个配置", DEFAULT_CONFIG);
+ok("帮我记住这个配置 (no separator)", v2.length === 1 && v2[0]?.content === "这个配置", JSON.stringify(g2));
+const v3 = detectKeywords("替我记一下我住在杭州", DEFAULT_CONFIG);
+ok("替我记一下我住在杭州 (no separator)", v3.length === 1 && v3[0]?.personal === true && v3[0]?.content === "我住在杭州", JSON.stringify(g3));
+const v4 = detectKeywords("帮我们记一下这个约定", DEFAULT_CONFIG);
+ok("帮我们记一下这个约定 → project", v4.length === 1 && v4[0]?.personal === false && v4[0]?.content === "这个约定", JSON.stringify(g4));
+const v5 = detectKeywords("替我记着这个流程", DEFAULT_CONFIG);
+ok("替我记着… → no capture (verb continuation)", v5.length === 0, JSON.stringify(v5));
+const v6 = detectKeywords("帮我们记得每周同步", DEFAULT_CONFIG);
+ok("帮我们记得… → no capture (verb continuation)", v6.length === 0, JSON.stringify(v6));
+const v7 = detectKeywords("帮我记：这个项目用 pnpm", DEFAULT_CONFIG);
+ok("帮我记：… (bare verb + separator)", v7.length === 1 && v7[0]?.content === "这个项目用 pnpm", JSON.stringify(v7));
+
+console.log("== keywords: narration is not a trigger (D67) ==");
+// 记得… / remind me… stay out on purpose (D67): they are imperatives aimed at
+// the agent, and a false trigger writes memory nobody reviewed. The two forms
+// already in the list follow the same rule - an explicit separator (or "that")
+// marks a statement to the store.
+const n1 = detectKeywords("别忘了带伞", DEFAULT_CONFIG);
+ok("别忘了带伞 (narration) → no capture", n1.length === 0, JSON.stringify(n1));
+const n2 = detectKeywords("别忘了：周五不发布", DEFAULT_CONFIG);
+ok("别忘了：… (instruction) → project", n2.length === 1 && n2[0]?.personal === false && n2[0]?.content === "周五不发布", JSON.stringify(n2));
+const n3 = detectKeywords("别忘了,每次发布前更新 changelog", DEFAULT_CONFIG);
+ok("别忘了,… (ascii comma) → project", n3.length === 1 && n3[0]?.content === "每次发布前更新 changelog", JSON.stringify(n3));
+const n4 = detectKeywords("Don't forget the wifi password", DEFAULT_CONFIG);
+ok("don't forget <bare> (narration) → no capture", n4.length === 0, JSON.stringify(n4));
+const n5 = detectKeywords("Don't forget that the wifi password is on the fridge", DEFAULT_CONFIG);
+ok("don't forget that … → project", n5.length === 1 && n5[0]?.content === "the wifi password is on the fridge", JSON.stringify(n5));
+const n6 = detectKeywords("don't forget: the wifi password", DEFAULT_CONFIG);
+ok("don't forget: … → project", n6.length === 1 && n6[0]?.content === "the wifi password", JSON.stringify(n6));
+// The 'note' family is unaffected - it was never the ambiguous form.
+const n7 = detectKeywords("note the API is v2", DEFAULT_CONFIG);
+ok("note <bare> still captures", n7.length === 1 && n7[0]?.content === "the API is v2", JSON.stringify(n7));
+const n8 = detectKeywords("记得每次都要跑迁移脚本", DEFAULT_CONFIG);
+ok("记得… → no capture", n8.length === 0, JSON.stringify(n8));
+const n9 = detectKeywords("remind me to lock the door", DEFAULT_CONFIG);
+ok("remind me to… → no capture", n9.length === 0, JSON.stringify(n9));
+
+console.log("== keywords: the length floor reports instead of swallowing (D67) ==");
+// D67 keeps the >=3-char floor (a trigger that yields 这个 is a match on the
+// trigger, not a memory) but a rejection is no longer silent.
+const d1 = scanKeywords("记住：这个", DEFAULT_CONFIG);
+ok("短 body 不捕获", d1.hits.length === 0, JSON.stringify(d1));
+ok("短 body 有说明 (too-short)", d1.dropped.length === 1 && d1.dropped[0]?.reason === "too-short" && d1.dropped[0]?.content === "这个", JSON.stringify(d1.dropped));
+const d2 = scanKeywords("记住：这个配置", DEFAULT_CONFIG);
+ok(">=3 字的照常捕获", d2.hits.length === 1 && d2.dropped.length === 0, JSON.stringify(d2));
+// A rejected personal match must not leak into the project scope: "记住我：OK"
+// must not be re-captured by the generic 记住 as "我：OK".
+const d3 = scanKeywords("记住我：OK", DEFAULT_CONFIG);
+ok("短 personal 不落到 project", d3.hits.length === 0 && d3.dropped.some((x) => x.reason === "too-short" && x.content === "OK"), JSON.stringify(d3));
+
 console.log("== scope ==");
 const s = resolveProjectScope(process.cwd());
 ok("kind=project", s.kind === "project");

package/scripts/test-full.ts

@@ -11,12 +11,29 @@ import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const REPO = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const CLI = path.join(REPO, "dist", "cli.js");
 const MCP_TS = path.join(REPO, "src", "mcp.ts");
 
+// Freshness guard: the CLI under test is the built dist/cli.js. A stale build
+// turns src fixes into phantom product failures, so refuse to run against one.
+// The check is a content fingerprint written by the build (scripts/build-stamp.mjs),
+// not an mtime comparison: `git checkout` rewrites src mtimes, so switching
+// branches can leave an older-branch dist looking newer than the branch's src.
+{
+  try {
+    execFileSync("node", [path.join(REPO, "scripts", "build-stamp.mjs"), "--check"], {
+      cwd: REPO,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (e: any) {
+    console.error((e.stderr ?? "").toString().trim() || "dist/ is stale — run `npm run build` first");
+    process.exit(1);
+  }
+}
+
 const T = fs.mkdtempSync(path.join(os.tmpdir(), "om-full-"));
 const TESTENV = {
   ...process.env,
@@ -496,9 +513,10 @@ console.log("== D64: p1 fixes (propose visibility / supersede published / status
   fs.rmSync(path.join(TESTENV.MY_O_MEMORY_HOME as string, "index.db-shm"), { force: true });
   const probe = path.join(T, "p1-plugin-probe.ts");
   fs.writeFileSync(probe, [
-    `import { makeTools } from ${JSON.stringify(path.join(REPO, "src", "tools", "memory.ts"))};`,
-    `import { PERSONAL_SCOPE } from ${JSON.stringify(path.join(REPO, "src", "scope.ts"))};`,
-    `import { loadConfig } from ${JSON.stringify(path.join(REPO, "src", "config.ts"))};`,
+    // file:// URLs, not raw paths — Windows rejects drive-letter specifiers.
+    `import { makeTools } from ${JSON.stringify(pathToFileURL(path.join(REPO, "src", "tools", "memory.ts")).href)};`,
+    `import { PERSONAL_SCOPE } from ${JSON.stringify(pathToFileURL(path.join(REPO, "src", "scope.ts")).href)};`,
+    `import { loadConfig } from ${JSON.stringify(pathToFileURL(path.join(REPO, "src", "config.ts")).href)};`,
     `const tools = makeTools(() => PERSONAL_SCOPE, loadConfig());`,
     `const r = await tools.memory_search.execute({ query: ${JSON.stringify(marker)} });`,
     `console.log(r.output);`,
@@ -518,8 +536,29 @@ console.log("== D64: p1 fixes (propose visibility / supersede published / status
   }
   cli(["reindex"], PROJ);
   r = cli(["sync-status"], PROJ);
-  const statusLines = r.out.split("\n").length;
-  ok("sync-status caps long sections", /… and \d+ more/.test(r.out) && statusLines < 50, `lines=${statusLines} ${r.out.slice(0, 120)}`);
+  // CLI shows the full list (the 20-line cap applies to agent tool
+  // results, whose "… and N more" line points back here).
+  const fillerShown = (r.out.match(/zzq cap filler/g) ?? []).length;
+  ok("sync-status shows the full list", fillerShown === 21 && !/… and \d+ more/.test(r.out), `shown=${fillerShown}`);
+  // ...and the agent-facing render (what memory_status returns) caps per section
+  // and names the CLI, so a hidden entry is still reachable.
+  const capProbe = path.join(T, "p1-cap-probe.ts");
+  fs.writeFileSync(capProbe, [
+    `import { getSyncStatus, formatSyncStatus } from ${JSON.stringify(pathToFileURL(path.join(REPO, "src", "submit.ts")).href)};`,
+    `console.log(formatSyncStatus(getSyncStatus()));`,
+  ].join("\n"));
+  let capOut = "";
+  try {
+    capOut = execFileSync("node", ["--experimental-strip-types", capProbe], { cwd: PROJ, env: TESTENV, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (e: any) { capOut = (e.stdout ?? "") + (e.stderr ?? ""); }
+  const outboxSection = (capOut.split("outbox (appdata")[1] ?? "").split("repo .ai/open-memex")[0];
+  const capEntries = (outboxSection.match(/\[(draft|proposed|approved|published|rejected)\]/g) ?? []).length;
+  const capFiller = (outboxSection.match(/zzq cap filler/g) ?? []).length;
+  ok(
+    "agent-facing sync-status caps and points at the CLI",
+    capEntries === 20 && capFiller < 21 && /… and \d+ more \(full list: open-memex sync-status\)/.test(outboxSection),
+    `entries=${capEntries} fillers=${capFiller} ${outboxSection.slice(0, 200)}`,
+  );
   for (let i = 0; i < 21; i++) fs.rmSync(path.join(outboxDir, `01P1CAP${String(i).padStart(19, "0")}.md`), { force: true });
 
   // doctor: v1 memories left under memories/user/ must be flagged.
@@ -537,7 +576,8 @@ console.log("== D64: p1 fixes (propose visibility / supersede published / status
   fs.mkdirSync(ocDir, { recursive: true });
   const jsoncFile = path.join(ocDir, "opencode.jsonc");
   fs.writeFileSync(jsoncFile, JSON.stringify({ plugin: ["file:///plugins/open-memex/src/index.ts"] }, null, 2));
-  r = cliRaw(["uninstall", "--client", "opencode", "--global", "--yes"], PROJ, { ...TESTENV, HOME: home2 });
+  // USERPROFILE too: os.homedir() ignores HOME on Windows.
+  r = cliRaw(["uninstall", "--client", "opencode", "--global", "--yes"], PROJ, { ...TESTENV, HOME: home2, USERPROFILE: home2 });
   const afterText = fs.readFileSync(jsoncFile, "utf8");
   ok("uninstall finds and cleans .jsonc global config", r.code === 0 && !/open-memex/.test(afterText), (r.out + r.err).slice(0, 160) + " || " + afterText.slice(0, 120));
 }

package/src/capture/keywords.ts

@@ -8,16 +8,42 @@ export interface KeywordHit {
 }
 
 /**
- * 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;
+
+/** A pattern that matched but whose body was rejected before capture. */
+export interface KeywordDrop {
+  content: string;
+  pattern: string;
+  personal: boolean;
+  reason: "too-short" | "too-long";
+}
+
+export interface KeywordScan {
+  hits: KeywordHit[];
+  dropped: KeywordDrop[];
+}
+
+/**
+ * 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: string, cfg: MyOMemoryConfig): KeywordHit[] {
-  if (!cfg.keywordCaptureEnabled) return [];
+export function scanKeywords(userText: string, cfg: MyOMemoryConfig): KeywordScan {
   const hits: KeywordHit[] = [];
+  const dropped: KeywordDrop[] = [];
+  if (!cfg.keywordCaptureEnabled) return { hits, dropped };
   const lines = userText.split(/\r?\n/);
   const claimed = new Set<number>();
   const scan = (patterns: string[], personal: boolean, skipClaimed: boolean) => {
@@ -33,15 +59,39 @@ export function detectKeywords(userText: string, cfg: MyOMemoryConfig): KeywordH
         const m = lines[i].match(re);
         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: string, cfg: MyOMemoryConfig): KeywordHit[] {
+  return scanKeywords(userText, cfg).hits;
 }

package/src/cli.ts

@@ -38,10 +38,10 @@ Example:
 
   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
 
@@ -93,6 +93,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`,
 
@@ -803,12 +806,13 @@ async function main() {
       process.exit(1);
     }
     const cfg = loadConfig();
-    const { detectKeywords } = await import("./capture/keywords.ts");
+    const { scanKeywords, MIN_CAPTURE_CHARS, MAX_CAPTURE_CHARS } = await import(
+      "./capture/keywords.ts"
+    );
     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);
@@ -819,8 +823,17 @@ async function main() {
         `  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).
   // Branched before db() — runMcpServer() does its own init, and stdout must
@@ -859,20 +872,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;
   }
@@ -1189,7 +1208,7 @@ function positionalArgs(argv: string[]): string[] {
     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 as Error).message}`);
       process.exit(2);

package/src/config.ts

@@ -45,25 +45,38 @@ export const DEFAULT_CONFIG: MyOMemoryConfig = {
   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/src/submit.ts

@@ -170,7 +170,7 @@ export function outboxDraftCount(scopeKey: string): number {
   return row?.n ?? 0;
 }
 
-export function formatSyncStatus(st: SyncStatus): string {
+export function formatSyncStatus(st: SyncStatus, opts: { cap?: number } = {}): string {
   const lines: string[] = [];
   lines.push(`project: ${st.projectName} (${st.scopeKey})`);
   // D31: when the index was last synced and what triggered it.
@@ -182,12 +182,16 @@ export function formatSyncStatus(st: SyncStatus): string {
   } else {
     lines.push(`last sync: never`);
   }
-  const CAP = 20;
+  // Agent-facing renders cap each section so a big store can't flood a
+  // tool result; the cap line points at the CLI, which shows everything.
+  const CAP = opts.cap ?? 20;
+  const more = (n: number) =>
+    `  … and ${n} more (full list: open-memex sync-status)`;
   lines.push(`outbox (appdata, pending sync): ${st.outbox.length}`);
   for (const e of st.outbox.slice(0, CAP)) {
     lines.push(`  ${e.id}  [${e.reviewState}] ${e.title}`);
   }
-  if (st.outbox.length > CAP) lines.push(`  … and ${st.outbox.length - CAP} more`);
+  if (st.outbox.length > CAP) lines.push(more(st.outbox.length - CAP));
   const byState = new Map<string, number>();
   for (const e of st.inRepo) byState.set(e.reviewState, (byState.get(e.reviewState) ?? 0) + 1);
   const breakdown = [...byState.entries()].map(([s, n]) => `${n} ${s}`).join(", ") || "none";
@@ -196,7 +200,7 @@ export function formatSyncStatus(st: SyncStatus): string {
     const u = e.gitState === "uncommitted" ? " (uncommitted)" : "";
     lines.push(`  ${e.id}  [${e.reviewState}]${u} ${e.title}`);
   }
-  if (st.inRepo.length > CAP) lines.push(`  … and ${st.inRepo.length - CAP} more`);
+  if (st.inRepo.length > CAP) lines.push(more(st.inRepo.length - CAP));
   if (st.uncommitted.length > 0) {
     lines.push(`note: ${st.uncommitted.length} repo file(s) not yet committed — they ride with the working tree until you commit.`);
   }

package/src/tools/memory.ts

@@ -44,9 +44,14 @@ export function makeTools(getScope: () => Scope, cfg: MyOMemoryConfig) {
     try {
       syncScope(getScope().key, "request");
       syncScope(PERSONAL_SCOPE.key, "request");
-    } catch {
-      // A failed sync must not take the tools down with it; the index
-      // may be stale for this call but the tool still answers.
+    } catch (err) {
+      // Deliberate asymmetry with the MCP adapter (which lets sync errors
+      // propagate as tool errors): a failed sync must not take the plugin
+      // tools down — the index may be stale for this call but the tool
+      // still answers. Loud at debug, silent otherwise.
+      if (cfg.logLevel === "debug") {
+        console.error("[open-memex] pre-tool sync failed:", err);
+      }
     }
   };