open-memex 0.7.0-alpha.8 → 0.7.0

package/scripts/test-full.ts

@@ -312,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));
@@ -334,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));
@@ -369,7 +415,7 @@ ok("migrate personal→project runs", r.code === 0, (r.err || r.out).slice(0, 15
   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));
@@ -393,7 +439,7 @@ ok("init --client vscode --yes", r.code === 0 && fs.existsSync(path.join(PROJ, "
 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], {
@@ -467,7 +513,7 @@ console.log("== MCP tools ==");
   child.kill();
 }
 
-// ---------- 11. D64: P1 review-flow honesty fixes ----------
+// ---------- 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);
@@ -582,6 +628,147 @@ console.log("== D64: p1 fixes (propose visibility / supersede published / status
   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,12 @@ 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.
 
+One thing the user said is one memory. When their own wording triggered keyword
+capture (`remember …`, `记住…`), that sentence is already stored — do not save it
+again in any rewording. Save only what the stored text does not contain, as its
+own statement; if your version replaces it, use `memory_supersede`. `memory_add`
+refuses the echo and hands you the stored id.
+
 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.
@@ -64,6 +70,29 @@ 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)
 
 New project memories land in a local outbox (not in git). Review and publish:

package/src/capture/handoff.ts

@@ -0,0 +1,74 @@
+/**
+ * Turn hand-off between keyword capture and the agent (D73).
+ *
+ * The keyword hook and the agent are two writers for one user turn. The hook
+ * stores the user's sentence verbatim, with no agent in the loop; the agent
+ * then sees only the chat transcript and cannot tell the sentence is already
+ * stored, so it saves its own paraphrase — the same statement lands two or
+ * three times (observed 2026-10-04: one `remember …` sentence → one
+ * `source: keyword` file plus two `source: tool` files).
+ *
+ * Two mechanisms, in this order:
+ *   (a) the hand-off note — this module's `formatHandoffBlock`, pushed into the
+ *       turn's system context so the agent knows what is already stored;
+ *   (b) the turn-echo guard — `TURN_ECHO_THRESHOLD` below, enforced in
+ *       `addMemory` (src/tools/ops.ts) over what the hook just wrote.
+ *
+ * Pure module: no db, no fs, no config, so the threshold behavior is testable
+ * in scripts/smoke-pure.ts.
+ */
+
+/**
+ * Overlap bar for refusing a re-save of a just-captured user statement.
+ *
+ * Deliberately high, and only ever applied to memories the *hook* wrote
+ * (`source: keyword` / `user`) inside `TURN_ECHO_WINDOW_MS`. Measured on the
+ * reported case and its near neighbours (token Jaccard, see
+ * `similarity` in src/store/lifecycle.ts): a wholesale re-save of the captured
+ * sentence scores 0.29–0.36, while a genuinely distinct fact the same
+ * sentence also contained scores 0.21 and below. Lexical overlap cannot
+ * separate an agent's gloss from a new fact — those two measured 0.211 and
+ * 0.214 — so the guard sits at the high-confidence end and everything under
+ * the bar is left to (a) and the agent's judgment. A refusal is always
+ * reported with the stored id, so the caller can supersede or rephrase.
+ */
+export const TURN_ECHO_THRESHOLD = 0.28;
+
+/** How long a hook capture counts as "this turn" (10 minutes). */
+export const TURN_ECHO_WINDOW_MS = 10 * 60 * 1000;
+
+/** One hook capture, in memory only — never persisted (like `injectedSessions`). */
+export interface CaptureRecord {
+  id: string;
+  scopeKey: string;
+  content: string;
+  at: number;
+  /** The note has already been pushed for this capture. */
+  delivered?: boolean;
+}
+
+export function isTurnEcho(score: number): boolean {
+  return score >= TURN_ECHO_THRESHOLD;
+}
+
+/** Records still inside the window. */
+export function freshCaptures(records: CaptureRecord[], now: number): CaptureRecord[] {
+  return records.filter((r) => now - r.at <= TURN_ECHO_WINDOW_MS);
+}
+
+function preview(content: string): string {
+  const one = content.replace(/\s+/g, " ").trim();
+  return one.length > 160 ? `${one.slice(0, 160)}…` : one;
+}
+
+/** The hand-off note (a). Empty string when there is nothing to hand off. */
+export function formatHandoffBlock(records: CaptureRecord[]): string {
+  if (records.length === 0) return "";
+  const lines = records.map((r) => `- id=${r.id} (${r.scopeKey}) — "${preview(r.content)}"`);
+  return [
+    "[open-memex] The user's own wording in this turn was ALREADY stored verbatim, before you saw it. It is not unsaved.",
+    ...lines,
+    "Do not call memory_add to save that text again in any rewording — one statement is already one memory, and a rewording only adds a second copy that retrieval will return alongside the first.",
+    "Save a memory only for information those lines do NOT contain, as its own self-contained statement. If your version is meant to replace one of them, call memory_supersede with that id instead of memory_add.",
+  ].join("\n");
+}

package/src/cli.ts

@@ -9,7 +9,8 @@ import { findDuplicates, supersede, setStatus } from "./store/lifecycle.ts";
 import { proposeMemories, promoteMemory, listConflicts, resolveConflict, formatReviewHistory } from "./review.ts";
 import { getSyncStatus, formatSyncStatus, submitMemories } from "./submit.ts";
 import { getPrStatus, formatPrStatus, applyPrStatus } from "./github.ts";
-import { search, list, hitStateLabel } from "./retrieve/search.ts";
+import { search, list, countList, hitStateLabel } from "./retrieve/search.ts";
+import { formatInventoryLine, truncationNote } from "./retrieve/display.ts";
 import {
   writeMemoryFile,
   readMemoryFile,
@@ -19,13 +20,65 @@ import {
   type Frontmatter,
 } from "./store/markdown.ts";
 import { loadConfig, configSource } from "./config.ts";
-import { paths, projectRoot } from "./paths.ts";
+import { paths, projectRoot, isInRepoMemoryFile } from "./paths.ts";
 import { redact } from "./redact.ts";
 import { resolveMcpCommand } from "./init.ts";
 import fs from "node:fs";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
+/**
+ * True when `target` sits inside a git working tree (D68 guard).
+ *
+ * D70: resolve the nearest EXISTING ancestor first. `git -C` on a
+ * directory that does not exist throws, and the old code turned that
+ * into "not in a worktree" — a fail-open guard on the one path where
+ * personal memories would ride a commit.
+ */
+function isInsideWorkTree(target: string): boolean {
+  try {
+    let dir = path.dirname(path.resolve(target));
+    while (!fs.existsSync(dir)) {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    const out = execFileSync("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return out.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * D70: the one place that decides where a report may be written, for
+ * every `inventory` format. Returns an error message to print, or null
+ * when the path is safe. Kept single so the text/json/html paths cannot
+ * drift apart (they already had two copies, D68).
+ */
+function inventoryWriteRefusal(
+  target: string,
+  includesPersonal: boolean,
+  allowPersonal: boolean,
+): string | null {
+  // Personal content must not ride a commit (the design's hardest rule).
+  if (includesPersonal && !allowPersonal && isInsideWorkTree(target)) {
+    return (
+      `inventory: ${target} is inside a git working tree and this report includes personal memories. ` +
+      `Refusing to write it there. Pass --allow-personal if you really want that, or write outside the repo.`
+    );
+  }
+  const parent = path.dirname(path.resolve(target));
+  if (!fs.existsSync(parent)) {
+    return `inventory: the directory ${parent} does not exist — create it first, or choose another --out path.`;
+  }
+  return null;
+}
+
 /** Per-command help, printed by `open-memex <command> --help`.
     AI assistants discover the CLI through --help, so every command needs one. */
 const COMMAND_HELP: Record<string, string> = {
@@ -36,14 +89,20 @@ Usage: open-memex where
 Example:
   open-memex where`,
 
-  list: `List memories in a scope, newest first.
+  list: `List memories in a scope, newest first, as a numbered inventory.
 
-Usage: open-memex list [--scope project|personal|both] [--type T] [--limit N]
+Usage: open-memex list [--scope project|personal|both] [--type T] [--limit N] [--include active|all]
 
 Flags:
-  --scope   project (default), personal, or both
-  --type    filter by memory type
-  --limit   max results
+  --scope    project (default), personal, or both
+  --type     filter by memory type
+  --limit    max results (default 20, max 100)
+  --include  active (default: what is currently remembered) or all (audit
+             view: superseded versions, retracted and archived included)
+
+A cut list says how many entries it left out. Numbers are unique within one
+listing, so "the third one" names exactly one memory - but they are only
+valid for the listing you just ran.
 
 Examples:
   open-memex list
@@ -99,12 +158,16 @@ Retraction is one-way: a retracted memory cannot be set back to active
 Example:
   open-memex status 01ABC deprecated`,
 
-  forget: `Delete a memory by id.
+  forget: `Delete a memory by id. With --soft, hide it instead: the memory
+is retracted (out of lists and search, file kept). Retraction is one-way —
+save the content as a new memory to bring it back. If the memory lives in
+the repo, either action is only local until you commit and push it.
 
-Usage: open-memex forget <id>
+Usage: open-memex forget <id> [--soft]
 
 Example:
-  open-memex forget 01ABC`,
+  open-memex forget 01ABC
+  open-memex forget 01ABC --soft`,
 
   propose: `Copy personal memories into the project outbox as review drafts.
 The personal originals stay put. Nothing enters git at this step.
@@ -156,6 +219,22 @@ Usage: open-memex sync-status
 Example:
   open-memex sync-status`,
 
+  inventory: `Show everything remembered — personal + this project — in the
+open: what each memory says, where it came from, and whether it has reached
+the repo yet. Read-only; deleting stays a confirmed conversation with your
+agent. Formats: text (default, diffable), json (for agents), html (a local
+page for your browser; default writes <data dir>/inventory.html).
+
+Usage: open-memex inventory [--format text|json|html] [--scope project|personal|both] [--out <path>] [--allow-personal]
+
+Default scope: both. Without --out, text/json go to stdout. A report that
+includes personal memories is refused inside a git working tree unless
+--allow-personal is passed — personal content must not ride a commit.
+
+Example:
+  open-memex inventory --format json --out ~/inventory.json
+  open-memex inventory --format html`,
+
   pull: `Pull shared project memories from the git remote: fetch + fast-forward
 only. Never auto-merges — a diverged branch fails with a clear message and is
 left for you to resolve by hand. On success the local index re-syncs.
@@ -370,16 +449,17 @@ function usage(exitCode = 1): never {
 
 Usage:
   open-memex where
-  open-memex list [--scope project|personal] [--type T] [--limit N]
+  open-memex list [--scope project|personal|both] [--type T] [--limit N] [--include active|all]
   open-memex search "query" [--scope project|personal|both] [--type T] [--limit N] [--explain]
   open-memex add "content" [--scope project|personal] [--type T] [--tag t1,t2]
   open-memex supersede <id> "new content" [--type T] [--tag t1,t2]
   open-memex status <id> active|deprecated|retracted|archived
-  open-memex forget <id>
+  open-memex forget <id> [--soft]
   open-memex propose <id...> --to project [--local-approve]
   open-memex promote <id> [--reject] [--resubmit] [--note "..."] [--by NAME]
   open-memex resolve [id-or-path]
   open-memex sync-status
+  open-memex inventory [--format text|json|html] [--scope project|personal|both] [--out <path>] [--allow-personal]
   open-memex pull
   open-memex push
   open-memex export [--scope project|personal|both] [--type T] [--tag t] [--all] [-o <file>]
@@ -833,7 +913,7 @@ async function main() {
       );
     }
     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
@@ -875,23 +955,41 @@ async function main() {
     // 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)];
+      flags.scope === "both" ? [PERSONAL_SCOPE, project] : [resolveCliScope(flags, project)];
+    const include = flags.include === "all" ? "all" : "active";
+    // D70: the CLI renders the SAME structured inventory the agent sees,
+    // numbering runs across the whole listing, and a cut list says how
+    // many entries it dropped — `open-memex list` is the surface a
+    // sceptical user runs first, so it may not look complete when it isn't.
+    let seq = 0;
     for (const s of scopes) {
       syncScope(s.key, "cli");
       const hits = list(s.key, {
         type: flags.type,
         limit: flags.limit ? Number(flags.limit) : undefined,
+        include,
       });
-      if (scopes.length > 1) console.log(`## ${s.kind} (${s.key})`);
+      const total = countList(s.key, { type: flags.type, include });
+      if (scopes.length > 1) {
+        console.log(
+          s.key === PERSONAL_SCOPE.key
+            ? "## About you (personal — stays on this machine, applies everywhere)"
+            : `## This project (${s.projectName || s.key})`,
+        );
+      }
       if (hits.length === 0) {
-        console.log(`(no memories in ${s.key})`);
+        console.log(
+          scopes.length > 1
+            ? "(nothing remembered in this scope yet)"
+            : `(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()}`);
+        console.log(formatInventoryLine(seq++, h, PERSONAL_SCOPE.key));
       }
+      const note = truncationNote(hits.length, total);
+      if (note) console.log(note);
     }
     return;
   }
@@ -1071,6 +1169,29 @@ async function main() {
   if (cmd === "forget") {
     const id = rest[0];
     if (!id) usage();
+    // D68: --soft hides (retracts) instead of deleting — same action as
+    // the memory_forget tool's soft flag. One-way (D64).
+    if (rest.includes("--soft")) {
+      const target = db().prepare(`SELECT file_path FROM memories WHERE id = ?`).get(id) as
+        | { file_path: string }
+        | undefined;
+      try {
+        const mf = setStatus(id, "retracted");
+        upsertFromFile(mf);
+        console.log(`hidden ${id} (retracted — out of lists and search; save it again as a new memory to bring it back)`);
+        // D70: same honesty as the hard delete — a retraction of an in-repo
+        // memory is a local working-tree edit until it is committed and pushed.
+        if (target && isInRepoMemoryFile(target.file_path)) {
+          console.log(
+            `note: that memory lives in the repo (.ai/open-memex/) — the retraction is only local until you commit and push it; until then the team still sees it.`,
+          );
+        }
+      } catch (e) {
+        console.error(`hide failed: ${(e as Error).message}`);
+        process.exit(1);
+      }
+      return;
+    }
     const row = db().prepare(`SELECT file_path FROM memories WHERE id = ?`).get(id) as
       | { file_path: string }
       | undefined;
@@ -1204,6 +1325,68 @@ function positionalArgs(argv: string[]): string[] {
     return;
   }
 
+  if (cmd === "inventory") {
+    // D68: refresh both scopes first so the report matches the markdown
+    // on disk. Default scope: personal + this project.
+    syncScope(project.key, "cli");
+    syncScope(PERSONAL_SCOPE.key, "cli");
+    const flags = parseFlags(rest);
+    const format = flags.format ?? "text";
+    if (format !== "text" && format !== "json" && format !== "html") {
+      console.error(`inventory: unknown --format '${format}' (text|json|html)`);
+      process.exit(2);
+    }
+    const scopeKeys =
+      flags.scope === "personal"
+        ? [PERSONAL_SCOPE.key]
+        : flags.scope === "project"
+          ? [project.key]
+          : [PERSONAL_SCOPE.key, project.key];
+    const outPath = flags["out"] ?? flags["output"];
+    const includesPersonal = scopeKeys.includes(PERSONAL_SCOPE.key);
+    const allowPersonal = flags["allow-personal"] === "true";
+    try {
+      const { loadInventory, renderInventoryText, renderInventoryJson } = await import("./inventory.ts");
+      if (format === "html") {
+        const { renderInventoryHtml, defaultHtmlOutPath } = await import("./inventory-html.ts");
+        const target = outPath ?? defaultHtmlOutPath(paths().root);
+        // D70: one guard for every format (this path had its own copy).
+        const refusal = inventoryWriteRefusal(target, includesPersonal, allowPersonal);
+        if (refusal) {
+          console.error(refusal);
+          process.exit(2);
+        }
+        // D70: only the audit surface needs the hidden rows themselves;
+        // text/json report counts, so they must not pay to load them.
+        const data = loadInventory(scopeKeys, { hidden: "entries" });
+        fs.writeFileSync(target, renderInventoryHtml(data), "utf8");
+        console.log(`inventory: ${data.total} memories → ${target}`);
+        console.log(`open it in any browser; the report is read-only.`);
+        return;
+      }
+      const data = loadInventory(scopeKeys);
+      const rendered = format === "json" ? renderInventoryJson(data) : renderInventoryText(data);
+      if (outPath) {
+        // D68/3-C v2: the report contains personal content. Writing it into
+        // a git working tree would ride the next commit off this machine —
+        // refuse unless the user explicitly accepts that.
+        const refusal = inventoryWriteRefusal(outPath, includesPersonal, allowPersonal);
+        if (refusal) {
+          console.error(refusal);
+          process.exit(2);
+        }
+        fs.writeFileSync(outPath, rendered, "utf8");
+        console.log(`inventory: ${data.total} memories → ${outPath}`);
+      } else {
+        process.stdout.write(rendered);
+      }
+    } catch (e) {
+      console.error(`inventory failed: ${(e as Error).message}`);
+      process.exit(2);
+    }
+    return;
+  }
+
   if (cmd === "sync-status") {
     syncScope(project.key, "cli");
     syncScope(PERSONAL_SCOPE.key, "cli");