open-memex 0.7.0-alpha.1 → 0.7.0-alpha.13

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,
@@ -133,6 +150,34 @@ ok("list --type filter", r.out.includes(idDecision) && !r.out.includes(idFact));
 r = cli(["search", "ff merges"], PROJ);
 ok("search finds decision", r.out.includes(idDecision), r.out.slice(0, 150));
 
+// D61: capture-time aliases — a differently-worded query still hits.
+const idAlias = addMem(["fulltest holiday policy lives in the handbook", "--aliases", "time off;vacation days"], PROJ);
+r = cli(["search", "vacation"], PROJ);
+ok("search hits via alias-only term", r.out.includes(idAlias), r.out.slice(0, 150));
+ok("alias-only hit explains itself (aka)", /aka:/i.test(r.out), r.out.slice(0, 150));
+
+// D61 review: aliases go through the same redaction as content. (The
+// secret is assembled at runtime so no credential-shaped literal sits
+// in this file.)
+const fakePat = "ghp_" + "Ab3".repeat(12);
+const idSecretAlias = addMem(["fulltest alias redaction target", "--aliases", `${fakePat}; benign alias`], PROJ);
+r = cli(["search", "benign"], PROJ);
+ok("benign alias still searchable", r.out.includes(idSecretAlias), r.out.slice(0, 150));
+{
+  const dir = path.join(TESTENV.MY_O_MEMORY_HOME, "memories");
+  const stack = [dir];
+  let hit = "";
+  while (stack.length && !hit) {
+    const d = stack.pop()!;
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) stack.push(p);
+      else if (p.endsWith(`${idSecretAlias}.md`)) hit = fs.readFileSync(p, "utf8");
+    }
+  }
+  ok("secret-looking alias is masked in the stored file", !!hit && !hit.includes(fakePat), hit.slice(0, 200));
+}
+
 // ---------- 3. supersede / status / forget ----------
 console.log("== supersede / status / forget ==");
 r = cli(["supersede", idFact, "fulltest fact about deploys v2"], PROJ);
@@ -148,6 +193,40 @@ ok("forget deletes", r.code === 0 && /delet/i.test(r.out), r.out.slice(0, 120));
 r = cli(["list"], PROJ);
 ok("forgotten id gone from list", !r.out.includes(idDecision));
 
+// P0: forget must not report success when the file cannot be deleted —
+// the file is the source of truth and would be re-indexed on next sync.
+// (Simulated by putting a directory where the file belongs: unlink fails
+// with EISDIR even for root, unlike permission bits.)
+{
+  const idF = addMem(["fulltest forget failure"], PROJ);
+  const memRoot = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories");
+  let memFile = "";
+  const findFile = (d: string) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p2 = path.join(d, e.name);
+      if (e.isDirectory()) findFile(p2);
+      else if (e.name === idF + ".md") memFile = p2;
+    }
+  };
+  findFile(memRoot);
+  ok("forget-failure setup found the file", !!memFile);
+  const backup = fs.readFileSync(memFile, "utf8");
+  fs.rmSync(memFile);
+  fs.mkdirSync(memFile);
+  try {
+    r = cli(["forget", idF], PROJ);
+    ok("forget reports failure when unlink fails",
+      r.code !== 0 && /could not delete/i.test(r.err + r.out),
+      (r.err || r.out).slice(0, 150));
+  } finally {
+    fs.rmSync(memFile, { recursive: true });
+    fs.writeFileSync(memFile, backup);
+  }
+  r = cli(["list"], PROJ);
+  ok("memory survives failed forget", r.out.includes(idF), r.out.slice(0, 150));
+  r = cli(["forget", idF], PROJ);
+  ok("forget succeeds once the file is deletable again", r.code === 0, (r.err || r.out).slice(0, 150));
+}
 // ---------- 4. propose / submit / promote / sync-status ----------
 console.log("== review workflow: propose / submit / promote ==");
 const idProp = addMem(["fulltest proposal candidate", "--scope", "personal"], PROJ);
@@ -203,6 +282,26 @@ const cfile = path.join(T, "conflict.tar.gz");
 execFileSync("tar", ["-czf", cfile, "-C", cstage, "manifest.json", "memories"], { env: TESTENV });
 r = cli2Retry(["import", cfile], PROJ2);
 ok("import conflict reported, never overwritten", /conflict/.test(r.out) && /imported 0/.test(r.out), r.out.slice(0, 160));
+// P0: a bundle manifest pointing outside the bundle must be rejected —
+// it otherwise imports arbitrary local .md files into the store. The
+// secret is planted next to the import staging dir (os.tmpdir()), which
+// is where "../" from a manifest entry lands.
+{
+  const secretName = `outside-secret-${process.pid}.md`;
+  const secretFile = path.join(os.tmpdir(), secretName);
+  const secretId = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
+  fs.writeFileSync(secretFile, `---\nid: ${secretId}\nscope: personal\nscope_key: personal\nvisibility: private\ntype: fact\nstatus: active\ncreated_at: 2026-01-01T00:00:00Z\nupdated_at: 2026-01-01T00:00:00Z\n---\n\nfulltest traversal secret\n`);
+  const tstage = path.join(T, "tstage");
+  fs.mkdirSync(tstage, { recursive: true });
+  fs.writeFileSync(path.join(tstage, "manifest.json"), JSON.stringify({ format: "open-memex-export/1", exported_at: "2026-01-01T00:00:00Z", open_memex_version: "t", include_private: true, filters: {}, memories: [{ id: secretId, scope: "personal", file: `../${secretName}` }] }));
+  const tfile = path.join(T, "traversal.tar.gz");
+  execFileSync("tar", ["-czf", tfile, "-C", tstage, "manifest.json"], { env: TESTENV });
+  r = cli2Retry(["import", tfile], PROJ2);
+  ok("import rejects path outside bundle", /imported 0/.test(r.out) && /rejected/.test(r.out), r.out.slice(0, 160));
+  r = cli2(["search", "traversal", "--scope", "personal"], PROJ2);
+  ok("traversed file never landed in store", !/traversal secret/.test(r.out), r.out.slice(0, 160));
+  fs.rmSync(secretFile, { force: true });
+}
 
 // ---------- 6. distill-agents ----------
 console.log("== distill-agents ==");
@@ -213,7 +312,53 @@ ok("distill-agents proposes snippet", /## Learned/.test(r.out), r.out.slice(0, 1
 r = cliRetry(["distill-agents", "--type", "decision", "-o", path.join(T, "snip.md")], PROJ);
 ok("distill-agents -o writes file", fs.existsSync(path.join(T, "snip.md")));
 
-// ---------- 7. pull / push ----------
+// ---------- 7. inventory (D68) ----------
+console.log("== inventory (D68) ==");
+addMem(["fulltest inventory entry with <script>alert(1)</script> tail", "--scope", "personal"], PROJ);
+r = cliRetry(["inventory"], PROJ);
+ok("inventory text lists the personal memory", r.out.includes("fulltest inventory entry"));
+ok("inventory text keeps structured provenance", /source=cli/.test(r.out));
+const invJson = cliRetry(["inventory", "--format", "json"], PROJ);
+const invData = JSON.parse(invJson.out.slice(invJson.out.indexOf("{")));
+ok("inventory json is the shared data layer", invData.format === "open-memex-inventory/2" && invData.total >= 1 && Array.isArray(invData.scopes), invData.format);
+const invFile = path.join(T, "inventory.json");
+r = cliRetry(["inventory", "--format", "json", "--out", invFile], PROJ);
+ok("inventory --out writes the file", r.code === 0 && fs.existsSync(invFile), (r.err || r.out).slice(0, 150));
+// D68/3-C v2: a personal-bearing report must not land in a git worktree.
+const inTree = path.join(PROJ, "inv.json");
+r = cliRetry(["inventory", "--out", inTree], PROJ);
+ok("inventory refuses a worktree path without --allow-personal", r.code !== 0 && !fs.existsSync(inTree));
+r = cliRetry(["inventory", "--out", inTree, "--allow-personal"], PROJ);
+ok("inventory allows the worktree path with --allow-personal", r.code === 0 && fs.existsSync(inTree));
+fs.rmSync(inTree, { force: true });
+// D68: soft forget hides; audit view still shows it; delete still works.
+const softId = addMem(["fulltest soft-hide candidate"], PROJ);
+r = cliRetry(["forget", softId, "--soft"], PROJ);
+ok("forget --soft hides the memory", r.code === 0 && /hidden/.test(r.out), r.out.slice(0, 120));
+r = cliRetry(["list"], PROJ);
+ok("hidden memory out of the default list", !r.out.includes(softId));
+r = cliRetry(["list", "--include", "all"], PROJ);
+ok("hidden memory visible with --include all", r.out.includes(softId) && r.out.includes("[retracted]"), r.out.slice(0, 160));
+r = cliRetry(["forget", softId], PROJ);
+ok("hard forget still deletes a hidden memory", r.code === 0 && /deleted/.test(r.out));
+// D68 follow-up: the HTML rendering of the same data layer.
+const htmlId = addMem(["fulltest html page entry"], PROJ);
+cliRetry(["forget", htmlId, "--soft"], PROJ);
+const htmlFile = path.join(T, "inventory-page.html");
+r = cliRetry(["inventory", "--format", "html", "--out", htmlFile], PROJ);
+ok("inventory --format html writes the page", r.code === 0 && fs.existsSync(htmlFile), (r.err || r.out).slice(0, 150));
+const page = fs.readFileSync(htmlFile, "utf8");
+ok("html page shows current memories", page.includes("fulltest inventory entry"));
+ok("html page escapes memory content", page.includes("&lt;script&gt;alert(1)&lt;/script&gt;") && !page.includes("<script>alert(1)</script>"));
+ok("html page folds the hidden history", page.includes("Replaced &amp; hidden history") && page.includes(htmlId) && page.includes("retracted"));
+ok("html page enforces 'no network' with a CSP", /Content-Security-Policy/.test(page) && /default-src 'none'/.test(page));
+r = cliRetry(["inventory", "--format", "html"], PROJ);
+ok("html defaults to the data dir", r.code === 0 && fs.existsSync(path.join(T, "data", "inventory.html")), (r.err || r.out).slice(0, 150));
+const inTreePage = path.join(PROJ, "page.html");
+r = cliRetry(["inventory", "--format", "html", "--out", inTreePage], PROJ);
+ok("html refuses a worktree path without --allow-personal", r.code !== 0 && !fs.existsSync(inTreePage));
+
+// ---------- 8. pull / push ----------
 console.log("== pull / push ==");
 r = cliRetry(["push"], PROJ);
 ok("push explicit", r.code === 0, (r.err || r.out).slice(0, 150));
@@ -235,7 +380,7 @@ cli(["push"], PROJ3);
 r = cli(["pull"], PROJ);
 ok("pull diverged → clear failure", r.code !== 0 && /diverg|behind|ahead/i.test(r.out + r.err), (r.out + r.err).slice(0, 160));
 
-// ---------- 8. migrate / reindex ----------
+// ---------- 9. migrate / reindex ----------
 console.log("== migrate / reindex ==");
 r = cli(["migrate", "--dry-run"], PROJ);
 ok("migrate bare → graceful no-op message", /no --from given/.test(r.out + r.err), (r.out + r.err).slice(0, 150));
@@ -251,8 +396,26 @@ try { dbOk = fs.existsSync(dbPath) && fs.statSync(dbPath).mtimeMs >= beforeReind
 ok("reindex rebuilds", dbOk, `db exists: ${fs.existsSync(dbPath)}`);
 r = cli(["list", "--scope", "personal"], PROJ);
 ok("list works after reindex", r.out.includes(idMig) || r.out.includes(idPersonal));
+// P0: a real migrate must re-scope the file, not just re-key it — a
+// personal memory migrated to the project key must become submittable
+// project memory (scope: project in its frontmatter).
+r = cli(["migrate", "--from", "personal", "--to", "project"], PROJ);
+ok("migrate personal→project runs", r.code === 0, (r.err || r.out).slice(0, 150));
+{
+  const memRoot = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories");
+  let moved = "";
+  const walk = (d: string) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name === idMig + ".md") moved = fs.readFileSync(p, "utf8");
+    }
+  };
+  walk(memRoot);
+  ok("migrated file is now scope: project", /^scope: project$/m.test(moved), moved.slice(0, 200));
+}
 
-// ---------- 9. capture / doctor / mcp --print-config / init ----------
+// ---------- 10. capture / doctor / mcp --print-config / init ----------
 console.log("== capture / doctor / mcp / init ==");
 r = cli(["capture", "--dry-run", "remember: we deploy on Fridays and use ff merges"], PROJ);
 ok("capture --dry-run", r.code === 0 && /deploy|friday/i.test(r.out), r.out.slice(0, 150));
@@ -262,10 +425,21 @@ for (const c of ["vscode", "cursor", "claude", "opencode", "visualstudio"]) {
 }
 r = cli(["init", "--client", "vscode", "--yes"], PROJ);
 ok("init --client vscode --yes", r.code === 0 && fs.existsSync(path.join(PROJ, ".vscode", "mcp.json")), (r.err || r.out).slice(0, 150));
+// P0: VS init must merge into an existing .mcp.json, not replace it —
+// the parsed doc used to be dropped, wiping other MCP servers.
+{
+  const mcpFile = path.join(PROJ, ".mcp.json");
+  fs.writeFileSync(mcpFile, JSON.stringify({ servers: { "other-server": { type: "stdio", command: "other" } } }));
+  r = cli(["init", "--client", "visualstudio", "--yes"], PROJ);
+  const after = JSON.parse(fs.readFileSync(mcpFile, "utf8")) as { servers?: Record<string, unknown> };
+  ok("VS init preserves other servers in .mcp.json",
+    r.code === 0 && !!after.servers?.["other-server"] && !!after.servers?.["open-memex"],
+    JSON.stringify(after).slice(0, 160));
+}
 r = cliRetry(["doctor"], PROJ);
 ok("doctor", r.code === 0 && /All checks passed/.test(r.out), (r.err || r.out).slice(0, 200));
 
-// ---------- 10. MCP: all 11 tools + session-start instructions ----------
+// ---------- 11. MCP: all 11 tools + session-start instructions ----------
 console.log("== MCP tools ==");
 {
   const child = spawn("node", ["--experimental-strip-types", MCP_TS], {
@@ -339,6 +513,262 @@ console.log("== MCP tools ==");
   child.kill();
 }
 
+// ---------- 12. D64: P1 review-flow honesty fixes ----------
+console.log("== D64: p1 fixes (propose visibility / supersede published / status door / plugin sync / status cap / doctor v1 / uninstall jsonc) ==");
+{
+  r = cli(["where"], PROJ);
+  const pkey = (/project:\s*(\S+)/.exec(r.out) || [])[1] ?? "";
+
+  // propose: the project copy must not inherit visibility: private, or
+  // export would silently drop it from every team bundle.
+  const seedId = addMem(["zzq p1 visible fact for the team", "--scope", "personal"], PROJ);
+  const copyId = proposeMem(seedId, PROJ);
+  const copyFile = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories", pkey, `${copyId}.md`);
+  const copyText = fs.existsSync(copyFile) ? fs.readFileSync(copyFile, "utf8") : "";
+  ok("propose copy is internal, not private", /visibility: internal/.test(copyText), copyText.slice(0, 160));
+
+  // supersede a published memory: the replacement must re-enter review
+  // at "proposed" (promotable), not land as a stranded repo draft.
+  const did = addMem(["zzq p1 publish flow fact"], PROJ);
+  cli(["submit", did], PROJ);
+  cli(["promote", did], PROJ);
+  r = cli(["promote", did], PROJ);
+  const pubFile = path.join(PROJ, ".ai", "open-memex", `${did}.md`);
+  ok("setup: promoted to published", r.code === 0 && /review_state: published/.test(fs.readFileSync(pubFile, "utf8")), (r.err || r.out).slice(0, 150));
+  r = cli(["supersede", did, "zzq p1 publish flow fact v2"], PROJ);
+  const nid = grabArrowId(r.out);
+  const newFile = nid ? path.join(PROJ, ".ai", "open-memex", `${nid}.md`) : "";
+  const newText = newFile && fs.existsSync(newFile) ? fs.readFileSync(newFile, "utf8") : "";
+  ok("supersede of published → proposed (not stranded draft)", /review_state: proposed/.test(newText), (r.out + newText).slice(0, 200));
+  r = cli(["promote", nid], PROJ);
+  ok("promote advances the replacement", r.code === 0 && /approved/.test(r.out + (fs.existsSync(newFile) ? fs.readFileSync(newFile, "utf8") : "")), (r.err || r.out).slice(0, 150));
+
+  // status: retracted cannot silently return to active.
+  const sid = addMem(["zzq p1 retract flow fact"], PROJ);
+  r = cli(["status", sid, "retracted"], PROJ);
+  ok("status → retracted", r.code === 0, (r.err || r.out).slice(0, 120));
+  r = cli(["status", sid, "active"], PROJ);
+  ok("retracted → active is refused", r.code !== 0 && /retracted/.test(r.err), (r.out + r.err).slice(0, 160));
+
+  // plugin host: per-call sync — wipe the (rebuildable) index and the
+  // opencode tools must still see memories written by other processes.
+  const marker = `zzqp1sync${Date.now()}`;
+  const pmid = addMem([`${marker} plugin freshness fact`, "--scope", "personal"], PROJ);
+  fs.rmSync(path.join(TESTENV.MY_O_MEMORY_HOME as string, "index.db"), { force: true });
+  fs.rmSync(path.join(TESTENV.MY_O_MEMORY_HOME as string, "index.db-wal"), { force: true });
+  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, [
+    // 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);`,
+  ].join("\n"));
+  let probeOut = "";
+  try {
+    probeOut = execFileSync("node", ["--experimental-strip-types", probe], { cwd: PROJ, env: TESTENV, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (e: any) { probeOut = (e.stdout ?? "") + (e.stderr ?? ""); }
+  ok("plugin tools sync before answering (index rebuilt)", probeOut.includes(pmid) || probeOut.includes(marker), probeOut.slice(0, 200));
+
+  // sync-status: long sections are capped with an "and N more" line.
+  const outboxDir = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories", pkey);
+  const template = fs.readFileSync(copyFile, "utf8");
+  for (let i = 0; i < 21; i++) {
+    const cid = `01P1CAP${String(i).padStart(19, "0")}`;
+    fs.writeFileSync(path.join(outboxDir, `${cid}.md`), template.replace(copyId, cid).replace("zzq p1 visible fact for the team", `zzq cap filler ${i}`));
+  }
+  cli(["reindex"], PROJ);
+  r = cli(["sync-status"], PROJ);
+  // 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.
+  const userDir = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories", "user");
+  fs.mkdirSync(userDir, { recursive: true });
+  fs.writeFileSync(path.join(userDir, "legacy-one.md"), "---\nid: legacy\n---\nold personal note\n");
+  r = cliRetry(["doctor"], PROJ);
+  ok("doctor flags invisible v1 user memories", /v1 personal memories/.test(r.out), r.out.slice(0, 200));
+  fs.rmSync(userDir, { recursive: true, force: true });
+  cli(["reindex"], PROJ);
+
+  // uninstall: a .jsonc-only global opencode config must be found.
+  const home2 = path.join(T, "home-opencode");
+  const ocDir = path.join(home2, ".config", "opencode");
+  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));
+  // 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));
+}
+
+// ---------- 12. D70: the visibility fixes from the 3-C review ----------
+// Last section on purpose: nothing here may perturb the flows above it.
+// It writes only into a scratch project and into appdata fixtures (no
+// commits in PROJ, no extra CLI spawns beyond a handful) so the suite stays
+// order-independent and cheap — the shared PROJ git state is never dirtied.
+console.log("== D70: honest counts, stable numbers, one guard ==");
+{
+  const fixture = (dir: string, id: string, body: string, scopeKey: string) => {
+    const now = new Date().toISOString();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, `${id}.md`),
+      `---
+id: ${id}
+schema_version: 2
+scope_key: ${scopeKey}
+scope: project
+visibility: internal
+project_name: d70
+type: fact
+role: knowledge
+importance: normal
+status: active
+tags: []
+source: cli
+created_at: "${now}"
+updated_at: "${now}"
+supersedes: null
+superseded_by: null
+review_state: draft
+proposed_by: null
+approved_by: null
+derived_from: null
+review_note: null
+review_history: []
+---
+
+${body}
+`,
+      "utf8",
+    );
+  };
+
+  // The guard must not fail open: a --out whose parent directory does not
+  // exist used to skip the worktree check (git -C on a missing dir throws)
+  // and then die with a raw ENOENT. Outside a worktree the missing directory
+  // is the only problem left, so it gets its own message.
+  const missingDir = path.join(T, "no-such-dir", "report.json");
+  r = cliRetry(["inventory", "--out", missingDir], PROJ);
+  ok(
+    "inventory explains a missing parent directory",
+    r.code !== 0 && /does not exist/.test(r.err) && !r.err.includes("ENOENT"),
+    (r.err || r.out).slice(0, 160),
+  );
+  // ...and inside a worktree the personal-content refusal wins over it.
+  const missingInTree = path.join(PROJ, "no-such-dir", "report.json");
+  r = cliRetry(["inventory", "--out", missingInTree], PROJ);
+  ok(
+    "worktree refusal wins over a missing directory",
+    r.code !== 0 && /git working tree/.test(r.err) && !fs.existsSync(missingInTree),
+    (r.err || r.out).slice(0, 160),
+  );
+
+  // `open-memex list` is the surface a sceptical user runs first: it must
+  // not look complete when it isn't. Fixtures go straight into the outbox
+  // (appdata, never the repo), so this needs no commits and no cleanup in git.
+  const d70Key = (/project:\s*(\S+)/.exec(cli(["where"], PROJ).out) || [])[1] ?? "";
+  const outboxDir = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories", d70Key);
+  const fillerIds: string[] = [];
+  for (let i = 0; i < 22; i++) {
+    const cid = `01P1D70${String(i).padStart(19, "0")}`;
+    fillerIds.push(cid);
+    fixture(outboxDir, cid, `fulltest d70 filler ${i} padding text`, d70Key);
+  }
+  cli(["reindex"], PROJ);
+  r = cliRetry(["list", "--limit", "5"], PROJ);
+  ok("cli list discloses truncation", /… and \d+ more not shown/.test(r.out), r.out.slice(-160));
+  ok(
+    "cli list renders the structured inventory line",
+    /^\d+\. \[[a-z]+\] id=\S+ created=\S+ source=/m.test(r.out),
+    r.out.slice(0, 200),
+  );
+  // Numbering runs across the whole listing, so a number names one entry.
+  r = cliRetry(["list", "--scope", "both", "--limit", "5"], PROJ);
+  const nums = [...r.out.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
+  ok(
+    "numbers are unique and ascending across scopes",
+    nums.length > 2 && new Set(nums).size === nums.length && nums[0] === 1 && nums.every((n, i) => i === 0 || n === nums[i - 1]! + 1),
+    JSON.stringify(nums),
+  );
+  // The text report numbers the same way.
+  r = cliRetry(["inventory", "--scope", "project"], PROJ);
+  const textNums = [...r.out.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
+  ok(
+    "inventory text numbers continuously too",
+    textNums.length > 2 && new Set(textNums).size === textNums.length && textNums.every((n, i) => i === 0 || n === textNums[i - 1]! + 1),
+    JSON.stringify(textNums.slice(0, 8)),
+  );
+  for (const id of fillerIds) fs.rmSync(path.join(outboxDir, `${id}.md`), { force: true });
+  cli(["reindex"], PROJ);
+
+  // A retraction of an in-repo memory is a local working-tree edit until it
+  // is committed - "hidden" must not read as "gone for the team". Runs in its
+  // own project so PROJ's git state stays clean for the sections above.
+  const d70Proj = mkproj("d70-proj");
+  const repoHideId = addMem(["fulltest d70 repo retraction"], d70Proj);
+  cliRetry(["submit", repoHideId], d70Proj);
+  r = cliRetry(["forget", repoHideId, "--soft"], d70Proj);
+  ok(
+    "soft hide of a repo memory warns about the commit",
+    /commit and push/i.test(r.out) && /team still sees it/i.test(r.out),
+    r.out.slice(0, 200),
+  );
+  r = cliRetry(["forget", repoHideId], d70Proj);
+  ok("hard forget of a hidden repo memory still deletes", r.code === 0 && /deleted/i.test(r.out), (r.err || r.out).slice(0, 120));
+
+  // An empty scope must still appear: "this project has nothing" is an answer.
+  const emptyProj = mkproj("empty-proj");
+  r = cliRetry(["inventory", "--scope", "project"], emptyProj);
+  ok(
+    "inventory shows an empty scope as 0",
+    /Project:.*\(0\)/.test(r.out) && /nothing remembered/i.test(r.out),
+    r.out.slice(0, 200),
+  );
+
+  // JSON: no absolute local paths, and the format id records the change.
+  r = cliRetry(["inventory", "--format", "json"], PROJ);
+  const invJson2 = JSON.parse(r.out.slice(r.out.indexOf("{")));
+  ok(
+    "inventory json is /2 and carries no absolute file paths",
+    invJson2.format === "open-memex-inventory/2" &&
+      !JSON.stringify(invJson2).includes(TESTENV.MY_O_MEMORY_HOME as string) &&
+      !/"file":/.test(JSON.stringify(invJson2)),
+    `${invJson2.format} ${JSON.stringify(invJson2).slice(0, 120)}`,
+  );
+  ok(
+    "inventory json counts hidden without the entries",
+    invJson2.hidden !== undefined && !("hiddenEntries" in invJson2),
+  );
+}
+
 console.log("\n================ SUMMARY ================");
 console.log(`pass: ${pass}, fail: ${fail}`);
 if (failures.length) { console.log("failed tests:"); for (const f of failures) console.log("  - " + f); }

package/skills/open-memex/SKILL.md

@@ -25,6 +25,32 @@ open-memex add "I prefer concise diffs" --scope personal   # applies everywhere
 Keep each memory one self-contained statement. Scope routing: facts about the
 user ("I"/"me") → `personal`; everything else → the current project.
 
+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.
+
+Attach alternate phrasings when saving — synonyms, another way the question
+might be worded, equivalents in the user's other language — so reworded
+questions still find the memory:
+
+```sh
+open-memex add "Public holidays are listed in the HR portal" --aliases "holidays;time off;节假日"
+```
+
+(Aliases are stored only when the install has capture aliases enabled — the
+init default.)
+
+## At task checkpoints — propose, don't just save
+
+For conclusions you infer yourself (the user never stated them): when you
+finish a task the user would describe in one sentence, propose 1–3 short
+memories capturing the useful conclusion (what was learned or decided, how an
+issue was resolved, what to avoid, where the authoritative doc lives — not the
+raw transcript). Save nothing the user did not approve; on approval, save it —
+with the `memory_add` tool pass `source: "inference"` so the capture is marked
+as agent-proposed. Don't interrupt mid-task, and don't re-propose something
+the user already declined.
+
 ## Recall
 
 ```sh
@@ -33,7 +59,33 @@ open-memex list                       # recent memories in the current project
 ```
 
 Search before asking the user about past decisions or preferences they may
-have told you before.
+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.
+
+## Seeing and removing what is remembered
+
+When the user asks "what do you remember about me?" (or wants to check or
+clean up), show them the inventory:
+
+```sh
+open-memex inventory              # everything remembered, read-only
+```
+
+In chat, present the memories conversationally — turn the fields into
+plain words (who the words came from, when it was saved, project or
+personal) instead of reading raw ids. If the user asks to remove one,
+read the entry back in full and get a confirmation before deleting —
+deletion is permanent, there is no undo. If they hesitate, offer hiding
+instead (`--soft`): it disappears from lists and search, but the file
+survives. Either way, if the memory lives in the repo, the change is only
+yours until you commit and push it.
+
+```sh
+open-memex forget <id>          # delete (permanent)
+open-memex forget <id> --soft   # hide (retracted, one-way)
+```
 
 ## Project outbox → repo (the sync flow)
 

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;
 }