open-memex 0.7.0-alpha.8 → 0.7.0

package/dist/retrieve/search.js

@@ -21,6 +21,8 @@ function toHit(r) {
         updated_at: r.updated_at,
         status: r.status,
         review_state: r.review_state ?? "draft",
+        source: r.source ?? "",
+        created_at: r.created_at ?? r.updated_at ?? 0,
     };
 }
 /**
@@ -61,7 +63,7 @@ function resolveVisible(rows, limit, stats) {
             return cached;
         const r = db()
             .prepare(`SELECT id, scope_key, project_name, type, tags, updated_at, status,
-                superseded_by, review_state, substr(content, 1, 240) AS snippet
+                superseded_by, review_state, source, created_at, substr(content, 1, 240) AS snippet
          FROM memories WHERE id = ?`)
             .get(id);
         if (!r)
@@ -134,7 +136,7 @@ export function search(query, opts = {}) {
     const typeFilter = opts.type ? ` AND m.type = ?` : "";
     const sql = `
     SELECT m.id, m.scope_key, m.project_name, m.type, m.tags, m.aliases, m.updated_at,
-           m.status, m.superseded_by, m.review_state,
+           m.status, m.superseded_by, m.review_state, m.source, m.created_at,
            snippet(memories_fts, 0, '[', ']', ' ... ', 12) AS snippet,
            bm25(memories_fts) AS score
     FROM memories_fts
@@ -164,7 +166,7 @@ export function list(scopeKey, opts = {}) {
     const typeFilter = opts.type ? ` AND type = ?` : "";
     const sql = `
     SELECT id, scope_key, project_name, type, tags, updated_at, status,
-           superseded_by, review_state, substr(content, 1, 240) AS snippet
+           superseded_by, review_state, source, created_at, substr(content, 1, 240) AS snippet
     FROM memories
     WHERE scope_key = ?${typeFilter}
     ORDER BY updated_at DESC
@@ -178,5 +180,33 @@ export function list(scopeKey, opts = {}) {
         .prepare(sql)
         .all(...params);
     const raw = rows.map((r) => ({ ...r, score: 1 }));
+    if (opts.include === "all") {
+        // D68: the audit view — every row as stored (superseded versions,
+        // retracted, archived), no chain collapsing, capped at limit.
+        return raw.slice(0, limit).map(toHit);
+    }
     return resolveVisible(raw, limit);
 }
+/**
+ * True totals for the inventory's truncation disclosure (D68). Under
+ * `active` the visible set is the newest of each chain, which in a
+ * consistent store is exactly the rows whose status is active/deprecated.
+ *
+ * D70: one deliberate exception — a `superseded` row whose chain target is
+ * missing (a dangling pointer, which the read path self-heals with a
+ * warning) is returned as a visible hit by resolveVisible but is not
+ * counted here, so the total can read one low in that state. Not worth
+ * widening the query for a self-healing case; the disclosure stays honest
+ * in every state a user can reach deliberately.
+ */
+export function countList(scopeKey, opts = {}) {
+    const typeFilter = opts.type ? ` AND type = ?` : "";
+    const statusFilter = opts.include === "all" ? "" : ` AND status IN ('active', 'deprecated')`;
+    const params = [scopeKey];
+    if (opts.type)
+        params.push(opts.type);
+    const row = db()
+        .prepare(`SELECT COUNT(*) AS n FROM memories WHERE scope_key = ?${statusFilter}${typeFilter}`)
+        .get(...params);
+    return row.n;
+}

package/dist/scope.js

@@ -57,6 +57,23 @@ export function resolveCwdScope(worktree) {
         projectName = "workspace";
     return scopeFromSeed(seed, projectName);
 }
+/** Pick the directory that seeds scope resolution from a host's candidate
+ *  roots. OpenCode v1 hands the plugin both `worktree` (the repo root — but
+ *  the filesystem root, e.g. `C:\` or `/`, when the opened folder is not a
+ *  git repo) and `directory` (the folder actually opened). Seeding on a
+ *  filesystem root collapses every non-git folder on a drive into one shared
+ *  `project__workspace__…` scope (D71), so prefer `worktree` only when it is
+ *  a real directory below the filesystem root. */
+export function pickScopeRoot(worktree, directory) {
+    const isFsRoot = (p) => path.parse(p).root === p;
+    if (worktree && !isFsRoot(worktree))
+        return worktree;
+    if (directory)
+        return directory;
+    if (worktree)
+        return worktree;
+    return process.cwd();
+}
 export function resolveProjectScope(worktree) {
     const target = worktree && worktree.length > 0 ? worktree : ".";
     const remote = tryGitRemote(target);

package/dist/store/lifecycle.js

@@ -5,6 +5,7 @@ import { db } from "./db.js";
 import { paths, projectRoot, inRepoMemoriesDirPath, } from "../paths.js";
 import { loadConfig } from "../config.js";
 import { cjkIndexText } from "../retrieve/cjk.js";
+import { isTurnEcho } from "../capture/handoff.js";
 import { parse, serialize, atomicWriteTextSync, ulid, msToRfc3339, } from "./markdown.js";
 /**
  * Dedup + lifecycle (V2-DESIGN §3.3, §3.4).
@@ -40,6 +41,10 @@ export function similarity(a, b) {
     return union === 0 ? 0 : inter / union;
 }
 export const NEAR_DUP_THRESHOLD = 0.8;
+/** `source` values the keyword hook (or an agent marking a user statement) writes.
+ *  Only these are turn-echo candidates — a `tool` memory is the agent's own
+ *  inference and keeps the 0.8 near-dup notice instead of a refusal. */
+const ECHO_SOURCES = "('keyword','user')";
 /** Find exact + near duplicates of `body` among ACTIVE memories in scope. */
 export function findDuplicates(scopeKey, body, excludeId) {
     const hash = contentHash(body);
@@ -64,6 +69,43 @@ export function findDuplicates(scopeKey, body, excludeId) {
     near.sort((x, y) => y.score - x.score);
     return { exact, near: near.slice(0, 3) };
 }
+/**
+ * D73: memories written from the user's own words moments ago — the keyword
+ * hook's captures, plus agent saves marked `source: user`. `memory_add` uses
+ * this to refuse a re-save of a statement the store already holds verbatim
+ * (see TURN_ECHO_THRESHOLD in src/capture/handoff.ts for why the bar is high).
+ * `created_at` is epoch ms in the index, so the window is a numeric compare.
+ */
+export function findTurnEcho(scopeKey, body, windowMs) {
+    const cutoff = Date.now() - windowMs;
+    let rows;
+    try {
+        rows = db()
+            .prepare(`SELECT id, content, source, created_at FROM memories
+         WHERE scope_key = ? AND status = 'active'
+           AND source IN ${ECHO_SOURCES} AND created_at >= ?`)
+            .all(scopeKey, cutoff);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const r of rows) {
+        if (typeof r.created_at !== "number" || r.created_at < cutoff)
+            continue;
+        const score = similarity(body, r.content);
+        if (isTurnEcho(score)) {
+            out.push({
+                id: r.id,
+                score,
+                source: r.source,
+                snippet: r.content.replace(/\s+/g, " ").trim().slice(0, 120),
+            });
+        }
+    }
+    out.sort((x, y) => y.score - x.score);
+    return out.slice(0, 3);
+}
 /** Locate a memory file by id: index file_path first, then dir-scan fallback. */
 export function findMemoryFile(id) {
     const { memories } = paths();

package/dist/tools/ops.js

@@ -7,18 +7,19 @@
  * result; each host adapts that to its own tool-result shape.
  */
 import fs from "node:fs";
-import path from "node:path";
 import { z } from "zod";
 import { PERSONAL_SCOPE } from "../scope.js";
-import { search, list, hitStateLabel } from "../retrieve/search.js";
+import { search, list, countList, hitStateLabel } from "../retrieve/search.js";
+import { formatInventoryLine, truncationNote } from "../retrieve/display.js";
 import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, MEMORY_TYPE_TAXONOMY, normalizeAliases, } from "../store/markdown.js";
 import { upsertFromFile, deleteFromIndex } from "../store/sync.js";
-import { findDuplicates, supersede } from "../store/lifecycle.js";
+import { findDuplicates, findTurnEcho, supersede, setStatus } from "../store/lifecycle.js";
+import { TURN_ECHO_WINDOW_MS } from "../capture/handoff.js";
 import { db } from "../store/db.js";
 import { redact } from "../redact.js";
 import { getSyncStatus, formatSyncStatus, submitMemories, outboxDraftCount } from "../submit.js";
 import { getPrStatus, formatPrStatus, applyPrStatus } from "../github.js";
-import { paths } from "../paths.js";
+import { isInRepoMemoryFile } from "../paths.js";
 import { proposeMemories, promoteMemory, listConflicts, resolveConflict, formatReviewHistory, } from "../review.js";
 /**
  * D53: push, don't poll. Append the project-outbox pending count to mutating
@@ -37,11 +38,11 @@ export async function withOutboxNote(scopeKey, p, reviewHint) {
 }
 /** LLM-facing tool descriptions, shared by the opencode plugin and the MCP server. */
 export const TOOL_DESCRIPTIONS = {
-    memory_add: "Save a fact, preference, decision, or note to persistent local memory. Call this PROACTIVELY whenever the user shares something worth remembering across sessions — project conventions, tool choices, personal preferences, decisions made, error fixes and their causes. Worth saving: decisions and their reasons, preferences, conventions, gotchas, approaches tried and abandoned. Not worth saving: one-off task details or anything re-derivable from the code. Do not wait to be asked. For facts you infer yourself rather than the user stating, propose them first and save only on approval. Keep each memory to one self-contained statement; attach aliases when the parameter is available. Default scope is the current project; use the personal scope for facts about the user that apply across all projects.",
+    memory_add: "Save a fact, preference, decision, or note to persistent local memory. Call this PROACTIVELY whenever the user shares something worth remembering across sessions — project conventions, tool choices, personal preferences, decisions made, error fixes and their causes. Worth saving: decisions and their reasons, preferences, conventions, gotchas, approaches tried and abandoned. Not worth saving: one-off task details or anything re-derivable from the code. Do not wait to be asked. For facts you infer yourself rather than the user stating, propose them first and save only on approval. Keep each memory to one self-contained statement; attach aliases when the parameter is available. If a note tells you the user's own wording was already stored verbatim this turn, that statement is already saved: do not retry it in a rewording — save only what that text does not contain, or use memory_supersede on the given id. Default scope is the current project; use the personal scope for facts about the user that apply across all projects.",
     memory_search: "Search persistent memory by keyword (BM25 full-text). Returns matching memories from the current project and/or personal scope. Call before asking the user about past decisions, conventions, or preferences they may have told you before. Search well: break the question into its concepts and try 2–3 phrasings per concept — synonyms, the user's other language, shorter keyword forms — and check the other scope too, before concluding nothing is stored.",
-    memory_list: "List memories in a scope, newest first. Useful for browsing what is remembered, or verifying that a save landed.",
+    memory_list: "List memories in a scope, newest first, as a numbered inventory. Each line keeps the raw fields — [type] id=… created=… source=… — say them back to the user in plain words (source=user → 'you told me this'; inference → 'I inferred this, check me'; keyword → 'caught from your own wording'), never read the raw id aloud unless they ask. When the user asks 'what do you remember about me?', use scope=both and present the inventory conversationally. The user may point at an entry by its number ('delete #3'): numbers are only valid for the listing you just produced — re-run memory_list, read the candidate back in full, and get a confirmation before calling memory_forget (deletion is permanent). include=all is the audit view (superseded versions, retracted, archived also shown).",
     memory_supersede: "Replace an existing memory with a newer version. The old memory is kept as history (status: superseded) and retrieval returns the new one. Use when a saved fact becomes outdated and should be replaced rather than duplicated.",
-    memory_forget: "Delete a memory by id. Use when the user asks to forget something.",
+    memory_forget: "Delete a memory by id. Use when the user asks to forget something. Deletion is permanent: before deleting, restate the memory's content to the user and get a confirmation. With soft=true the memory is hidden instead (retracted: out of lists and search, file kept, one-way).",
     memory_status: "Show the project memory sync pipeline: drafts waiting in the outbox (appdata), memories in the repo awaiting review or published, and any repo files not yet committed. Call this at session start, when the server reports drafts waiting for review, or when the user says 'sync memory' (or '同步记忆'); then ask the user which drafts to sync. (MCP server and the `open-memex sync-status` CLI; the opencode native plugin does not expose this tool.)",
     memory_submit: "Move outbox drafts into the repo memory dir for review: copies the drafts in as proposed (or keeps a local approval), commits locally on the current branch, and moves the outbox originals out. Never creates a branch on its own — pass branch= only with the user's explicit approval for the full chain. Prints the push and PR commands — those need the user's explicit approval and are never run automatically. (MCP server and the `open-memex submit` CLI; the opencode native plugin does not expose this tool.)",
     memory_propose: "Copy personal memories into the project outbox as review drafts. The personal originals stay put. (MCP server and the `open-memex propose` CLI; the opencode native plugin does not expose this tool.)",
@@ -91,6 +92,10 @@ export const memoryListArgs = {
         .describe("Which scope(s) to list. `project` = tied to this repo. `personal` = global across all your projects. `both` lists each scope's newest. Default: project."),
     type: z.string().optional(),
     limit: z.number().int().min(1).max(100).optional(),
+    include: z
+        .enum(["active", "all"])
+        .optional()
+        .describe("D68: `active` (default) shows what is currently remembered — newest version of each fact, retracted/archived hidden. `all` is the audit view: every stored row including superseded versions and hidden ones. The default CHANGED in D68: superseded versions no longer appear unless include=all."),
 };
 export const memorySupersedeArgs = {
     id: z.string().min(1).describe("ID of the memory being replaced."),
@@ -104,6 +109,10 @@ export const memorySupersedeArgs = {
 };
 export const memoryForgetArgs = {
     id: z.string().min(1),
+    soft: z
+        .boolean()
+        .optional()
+        .describe("D68: hide instead of delete. The memory is retracted — excluded from lists and search — but its file stays. Retraction is one-way (D64): it does not come back; to restore the fact, save it again as a new memory. Offer `soft` when the user is unsure about deleting."),
 };
 export const memoryStatusArgs = {};
 export const memorySubmitArgs = {
@@ -189,6 +198,26 @@ export async function addMemory(getScope, cfg, args) {
             output: `Identical memory already exists: id=${dups.exact.id}. Not duplicated.`,
         };
     }
+    // D73: one user statement, one memory. The keyword hook stores the user's
+    // sentence verbatim with no agent in the loop; a paraphrase of that same
+    // sentence is refused instead of written beside it. The stored id comes back
+    // so the caller can supersede it or save only the genuinely new part.
+    const echo = findTurnEcho(s.key, redacted, TURN_ECHO_WINDOW_MS);
+    if (echo.length > 0) {
+        const top = echo[0];
+        const others = echo
+            .slice(1)
+            .map((e) => `id=${e.id} (${e.source}, overlap ${e.score.toFixed(2)})`)
+            .join(", ");
+        return {
+            title: "memory: already captured verbatim",
+            output: `Not saved — the user's own words were already stored moments ago (source: ${top.source}, overlap ${top.score.toFixed(2)}): ` +
+                `id=${top.id} — ${top.snippet}` +
+                (others ? `\nAlso matching: ${others}` : "") +
+                `\nDo not retry with a rewording: that only adds a second copy of one statement. ` +
+                `Save a separate memory only for information that stored text does not contain, or call memory_supersede on that id if this replaces it.`,
+        };
+    }
     const fm = buildFrontmatter(s, {
         type: args.type ?? "fact",
         tags: args.tags ?? [],
@@ -233,32 +262,52 @@ export async function searchMemories(getScope, args) {
     return { title: `memory: ${hits.length} result(s)`, output: lines.join("\n") };
 }
 export async function listMemories(getScope, args) {
+    // D68: the list is the user's inventory of what is remembered. Lines
+    // are structured (number + id + created= + source= + state tags) and
+    // every section reports its true total — a truncated list says so
+    // instead of quietly looking complete (the D66 sync-status lesson).
+    const include = args.include ?? "active";
+    // D70: numbering runs across every section of THIS listing, so "delete
+    // #3" names exactly one memory. A per-section counter emitted two "#1"s.
+    let seq = 0;
+    const render = (scopeKey) => {
+        const hits = list(scopeKey, { type: args.type, limit: args.limit, include });
+        const total = countList(scopeKey, { type: args.type, include });
+        const lines = hits.map((h) => formatInventoryLine(seq++, h, PERSONAL_SCOPE.key));
+        const note = truncationNote(hits.length, total);
+        if (note)
+            lines.push(note);
+        return lines;
+    };
     if (args.scope === "both") {
         // D64: "what do you remember about me" spans both stores; search
         // already defaults to both, list now matches. Each scope lists its
         // own newest (the limit applies per scope).
         const project = getScope();
         const sections = [];
-        for (const s of [project, PERSONAL_SCOPE]) {
-            const hits = list(s.key, { type: args.type, limit: args.limit });
-            if (hits.length === 0) {
-                sections.push(`## ${s.kind} (${s.key})\n  (none)`);
-                continue;
-            }
-            const lines = hits.map((h) => `- [${h.type}]${hitStateLabel(h)} id=${h.id} — ${h.snippet.replace(/\s+/g, " ").trim()}`);
-            sections.push(`## ${s.kind} (${s.key})\n${lines.join("\n")}`);
+        for (const s of [PERSONAL_SCOPE, project]) {
+            const lines = render(s.key);
+            const heading = s.key === PERSONAL_SCOPE.key
+                ? "## About you (personal — stays on this machine, applies everywhere)"
+                : `## This project (${s.projectName || s.key})`;
+            sections.push(lines.length === 0 ? `${heading}\n(none yet)` : `${heading}\n${lines.join("\n")}`);
         }
-        return { title: "memory: list (both scopes)", output: sections.join("\n") };
+        return { title: "memory: list (both scopes)", output: sections.join("\n\n") };
     }
     const s = resolveScope(getScope, args.scope === "project" || args.scope === "personal" || args.scope === "user"
         ? args.scope
         : undefined);
-    const hits = list(s.key, { type: args.type, limit: args.limit });
-    if (hits.length === 0) {
+    const lines = render(s.key);
+    if (lines.length === 0) {
         return { title: "memory: empty", output: `No memories in scope ${s.key}.` };
     }
-    const lines = hits.map((h) => `- [${h.type}]${hitStateLabel(h)} id=${h.id} — ${h.snippet.replace(/\s+/g, " ").trim()}`);
-    return { title: `memory: ${hits.length} in ${s.key}`, output: lines.join("\n") };
+    const heading = s.key === PERSONAL_SCOPE.key
+        ? "## About you (personal — stays on this machine, applies everywhere)"
+        : `## This project (${s.projectName || s.key})`;
+    return {
+        title: `memory: ${countList(s.key, { type: args.type, include })} in ${s.key}`,
+        output: `${heading}\n${lines.join("\n")}`,
+    };
 }
 export async function supersedeMemory(cfg, args) {
     const { content: redacted, hadSecret, matchedPattern } = redact(args.content, cfg.redactPatterns);
@@ -296,6 +345,28 @@ export async function forgetMemory(args) {
     if (!row) {
         return { title: "memory: not found", output: `No memory with id ${args.id}.` };
     }
+    if (args.soft) {
+        // D68: hide instead of delete. The status flip is the whole action —
+        // retrieval and the inventory exclude retracted, the file stays put.
+        // One-way (D64): no un-hide; restoring the fact means saving it again.
+        try {
+            const mf = setStatus(args.id, "retracted");
+            upsertFromFile(mf);
+            return {
+                title: "memory: hidden",
+                output: `Hidden ${args.id} (retracted). It no longer appears in lists or search, but the file is kept. This is one-way — to bring the fact back, save it again as a new memory.` +
+                    // D70: a retraction of an in-repo memory is a local working-tree
+                    // edit like the delete — without a commit (and a push) the memory
+                    // stands on every teammate's clone, so "hidden" would be a lie.
+                    (isInRepoMemoryFile(row.file_path)
+                        ? ` Note: this memory lives in the repo (.ai/open-memex/), so the retraction is only local until you commit and push it — until then the team still sees it.`
+                        : ""),
+            };
+        }
+        catch (e) {
+            return { title: "memory: hide failed", output: e.message };
+        }
+    }
     // Delete by indexed file_path — location-agnostic (appdata or in-repo, 2B/D24).
     // Only ENOENT counts as "deleted": on any other unlink failure the file
     // is still the source of truth and would be re-indexed on next sync, so
@@ -318,8 +389,7 @@ export async function forgetMemory(args) {
     // D64: forgetting an in-repo memory deletes a file inside the user's
     // git working tree. Say so — the deletion should ride a commit, or the
     // file silently diverges from what teammates have.
-    const inRepo = row.file_path.includes(`${path.sep}.ai${path.sep}`) &&
-        !row.file_path.startsWith(paths().root);
+    const inRepo = isInRepoMemoryFile(row.file_path);
     return {
         title: "memory: forgotten",
         output: inRepo

package/docs/TEST-PLAN.md

@@ -73,7 +73,7 @@
 
 ## H. 已知问题观察
 
-- [ ] better-sqlite3 在 Node 24 退出时偶发 crash（exit 134）：注意是否丢数据（预期：不丢，只影响退出码）
+- [x] better-sqlite3 在 Node 24 退出时偶发 crash（exit 134）：D72 已把驱动升到 13（N-API 线）；Linux Node 24.20 连续 3 次 `test-full` 114/114。Windows 真机仍需确认同一版本下无 `SIGABRT` / exit 134，且不丢数据。
 - [ ] `memory_list` 默认只列 project scope 是否符合预期（Stone 已定保持现状）
 
 ---

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–D67 are settled; open questions are tracked at the end of this document.
+**Status:** FROZEN — protocol v0.2 (2026-09-26). Decisions D1–D73 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;
@@ -1444,6 +1444,121 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   "full list: open-memex sync-status" pointer) after D66's CLI-parity test
   had dropped that coverage.
 
+- **D68 — memory visibility: the inventory is a protocol surface.** Group 3-C
+  (design: `docs/memory-visibility-design.md` v2). `memory_list` output
+  becomes a numbered, structured inventory (`[type] id=… created=…
+  source=…`, state tags for project scopes; `created=` is when the fact
+  was learned, `updated=` shown only when it moved materially later). The
+  raw enums stay in the data; plain-language renderings live in the
+  guidance surfaces (tool descriptions, MCP handshake, SKILL.md,
+  distill-agents footer) so agents rephrase in the conversation's
+  language. New input `include: "active" | "all"` (default `active`) —
+  a deliberate behavior change: superseded versions and retracted /
+  archived memories leave the default listing (audit view via `all`).
+  Every listing states its true total; truncation is disclosed, never
+  silent (the D66 lesson applied to this surface). `open-memex
+  inventory` renders the same data layer as text (default) or JSON
+  (`open-memex-inventory/1`); a report containing personal memories
+  refuses to be written inside a git working tree without
+  `--allow-personal`. `memory_forget` gains `soft` (CLI `forget
+  --soft`): retraction as a first-class tool action — hidden from lists
+  and search, file kept, still one-way per D64 (restoring the fact means
+  saving it again; no un-hide, no undo, no recycle bin). Deletion stays
+  a confirmed conversation: agents re-list before acting on a number
+  (numbers are only valid for the listing just produced) and read the
+  entry back before deleting. The HTML rendering of the same data layer
+  follows as a separate change; auto-draft stays gated on the unlock
+  conditions in the design doc.
+- **D73 — one user statement, one memory: the keyword hook hands off to the
+  agent.** The keyword hook and the agent are two writers for one user turn,
+  and only one of them knows the sentence is already stored. Observed
+  2026-10-04: a single `remember this folder is for my spark tank ideas …
+  shared memory across agents and employees` produced **three** memories — one
+  `source: keyword` verbatim capture plus two `source: tool` paraphrases the
+  agent wrote because it could see the chat transcript but not the store. The
+  existing §3.4 guard could not catch it: token Jaccard scored those
+  paraphrases 0.21–0.38 against the capture, below the 0.8 near-dup bar, and
+  `open-memex audit` reported zero near-dup pairs, so the store looked healthy
+  while holding three copies of one statement (retrieval then returns all
+  three). Two mechanisms, deliberately layered:
+  **(a) hand-off note** — `captureFromText` records each capture against the
+  host session id (`chat.message` / v2 `prompt`, both of which carry one), and
+  the system-context hook (`experimental.chat.system.transform` / v2
+  `context`) pushes a short block naming what was already stored, delivered
+  once per capture and pruned after the turn window. The agent can now avoid
+  the duplicate write it had no way to see. In-memory only, like
+  `injectedSessions`: never persisted, gone on restart.
+  **(b) turn-echo guard** — `memory_add` additionally refuses a write that
+  overlaps a `source: keyword`/`user` memory created in the same scope within
+  the last 10 minutes, returning the stored id and pointing at
+  `memory_supersede`. This is the deterministic backstop for the case where
+  (a) is ignored. It is deliberately scoped and high-barred, because lexical
+  overlap **cannot** separate an agent's gloss from a genuinely new fact: in
+  the same measured set, the agent's gloss scored 0.211 and a distinct fact
+  the same sentence happened to contain scored 0.214. So the bar sits at
+  0.28 — wholesale re-saves of the captured sentence measure 0.29–0.36 and are
+  refused; anything below is left to (a) and the agent's judgment, and a
+  refusal always names the stored id so the caller can rephrase to the new
+  part or supersede. Agent-authored `source: tool` saves keep the old 0.8
+  near-dup *notice* and are never refused. The refused case is recoverable by
+  construction (supersede, or a follow-up add carrying only the new
+  information), and no D14-style masking, dedup, or lifecycle rule changes.
+  What is deliberately NOT done: no fuzzy-matching upgrade (D73 measures why a
+  better metric still cannot decide "new information"), no auto-merging of the
+  agent's gloss into the capture, and no transcript store (the replay-distillation
+  open question owns that).
+
+- **D72 — the Node SQLite driver moves to the N-API line.** The D70 suite was stable on Windows and failed in shifting clusters on Linux under Node 24.20: individual CLI processes intermittently died with `SIGABRT` in `Statement::~Statement()` (`RemoveEnvironmentCleanupHook ... Assertion failed: (env) != nullptr`) and lost their stdout, so unrelated supersede / submit / inventory checks failed depending on which process the GC reaped. The work itself had always landed; only the exit path was broken. Root cause is upstream: Node 24.19 changed `node::ObjectWrap` cleanup-hook registration, and `better-sqlite3` <13 (raw `node::ObjectWrap`) can finalize a prepared statement from a GC callback with no Environment entered. `better-sqlite3` 13 is the N-API rewrite and removes that path; it still supports Node ≥22, and every API this repo uses (`Database`, `prepare`, `exec`, `pragma`-style PRAGMAs, `close`) is unchanged. The suite's crash-retry shim stays as belt-and-braces for older installs, but the shipped driver no longer needs it on current Node. Verified: three consecutive Linux `test-full` runs at 114/114 plus a 40-command add/list/search loop with zero aborts (was ~50% per process).
+
+- **D71 — the scope seed is the folder opened, never a filesystem root.**
+  OpenCode v1 hands the plugin two roots: `worktree` (the repo root — but
+  the filesystem root itself, `C:\` or `/`, when the opened folder is not a
+  git repo) and `directory` (the folder actually opened). The v1 adapter
+  preferred `worktree`, so every non-git folder on a drive seeded its scope
+  on the drive root and collapsed into one shared
+  `project__workspace__<hash of the root>` bucket — a `c:\temp` project
+  landing in `project__workspace__3dc8472eaebe` (seed `c:\`) is what
+  surfaced it. `pickScopeRoot` (src/scope.ts) now takes `worktree` only when
+  it is a real directory below the filesystem root, else `directory`. The
+  repo-root behavior is unchanged: a real worktree still wins, so opening a
+  repo subfolder keeps the repo's scope. Memories already written under a
+  root-seeded key stay where they are (no auto-migration, per the existing
+  rule); `open-memex scopes` shows the stray bucket and
+  `open-memex migrate --from <old-key>` moves them. The v2 adapter already
+  seeded on the opened directory and is unaffected.
+
+- **D70 — visibility follow-ups: one number, one guard, one truth.** The
+  3-C review of D68/D69 found the surfaces honest individually and
+  inconsistent with each other. (1) **Every visibility surface discloses
+  truncation.** `memory_list` did; `open-memex list` — the command a
+  sceptical user runs first — silently showed 20 of 25. It now renders
+  the same structured line as the tool and states how many entries it
+  dropped, naming the command that shows everything. (2) **Numbers are
+  unique within a listing.** Ordinals ran per scope, so a single
+  `scope: both` output contained two `#1`s and "delete #3" was a guess;
+  the counter now runs across every section of one listing (tool, CLI and
+  the text report). (3) **A correction that touches the repo says so.**
+  The hard delete already did (D64); the soft hide did not, so a
+  retraction of an in-repo memory read as "hidden" while it was only a
+  local working-tree edit — the team still had the memory. Both surfaces
+  now name the commit and push. (4) **The report guard fails closed and
+  exists once.** `isInsideWorkTree` ran `git -C` on the output's parent
+  directory, so a not-yet-created directory made the check throw and
+  report "not in a worktree" — a fail-open on the one path where personal
+  memories would ride a commit; it now resolves the nearest existing
+  ancestor, reports a missing directory as itself, and both formats share
+  a single refusal helper instead of two copies. (5) **`open-memex-inventory/2`**
+  drops the absolute `file` path: the JSON renderer exists to be handed to
+  an agent, i.e. pasted into a cloud conversation, and it carried the
+  user's home directory. (6) Smaller honesty fixes: an empty scope is
+  reported as `(0)` instead of vanishing; only the HTML audit view loads
+  the hidden rows themselves (text/json pay for counts); the page's
+  "no network requests" claim is now enforced by a `default-src 'none'`
+  CSP rather than asserted; and `countList`'s comment states its one known
+  divergence (a self-healed dangling chain pointer) instead of claiming
+  equivalence. Deliberately NOT done, pending a decision: HTML i18n and a
+  size cap for very large stores.
+
 ## 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._
@@ -1463,7 +1578,7 @@ _Some early questions are resolved — see D10 (rename), D11 (type/role split),
 
 - **Novice experience: first success and plain language (open, 2026-10-03):** from an AI-novice review. The install ends with instructions, not an experience: candidate fix is a 60-second magic moment — init offers to save one sample memory and immediately has the user's agent answer a question using it, so the user *sees* recall work before being asked to trust it. Same screen should state the privacy model in plain words (personal never leaves this machine, no cloud, detected secrets are masked — all already true, all currently buried in docs), and the first time a suspected secret is masked, the capture path should say so. Underneath: a plain-language layer over the state machine ("saved on this computer" / "shared with the team") with outbox/submit/promote vocabulary becoming the advanced view — this is the same vocabulary wall the PM/BA question above hits from the other side. **Status (2026-10-03): partially addressed** — `init` now states the privacy model in plain words (D56); the 60-second magic moment and the plain-language layer remain open.
 
-- **Memory visibility and correctability (open, 2026-10-03):** also from the novice review, and arguably the trust foundation for every other feature. A non-CLI user currently cannot answer "what does my assistant remember about me?" without reading Markdown files. Candidate directions: a human-readable inventory (local HTML export or equivalent) listing memories in plain language with provenance shown the way a person asks for it ("saved 3 days ago while you were discussing deploys in project X") and one-step forget/undo from the same view. Provenance fields already exist in frontmatter; this is presentation, not schema. Without it, proactive capture (above) will read to novices as surveillance rather than help — so this question probably gates the auto-draft posture decision in the capture question.
+- **Memory visibility and correctability (open, 2026-10-03):** also from the novice review, and arguably the trust foundation for every other feature. A non-CLI user currently cannot answer "what does my assistant remember about me?" without reading Markdown files. Candidate directions: a human-readable inventory (local HTML export or equivalent) listing memories in plain language with provenance shown the way a person asks for it ("saved 3 days ago while you were discussing deploys in project X") and one-step forget/undo from the same view. Provenance fields already exist in frontmatter; this is presentation, not schema. Without it, proactive capture (above) will read to novices as surveillance rather than help — so this question probably gates the auto-draft posture decision in the capture question. **Status (2026-10-03): decided (D68)** — the inventory ships as structured list + text/JSON report with conversational rendering taught to agents; "one-step forget/undo from the view" was deliberately not built (deletion stays a confirmed conversation; soft-hide added instead); the HTML rendering follows separately. Auto-draft remains gated on the unlock conditions in `docs/memory-visibility-design.md`.
 
 ---