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

package/dist/doctor.js

@@ -7,17 +7,25 @@ import os from "node:os";
 import path from "node:path";
 import { spawn, execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { loadConfig, configSource, DEFAULT_CONFIG } from "./config.js";
-import { paths } from "./paths.js";
+import { loadConfig, configSource, DEFAULT_CONFIG, stripJsonComments } from "./config.js";
+import { paths, homeOverride } from "./paths.js";
 import { resolveCwdScope } from "./scope.js";
 import { db, backendName } from "./store/db.js";
 import { LEGACY_PACKAGE_NAME, opencodeGlobalConfigPath, userMcpConfigPath } from "./init.js";
+// D64: the MCP server exposes eleven tools; checking only the five the
+// opencode plugin carries let a half-registered server pass as healthy.
 const EXPECTED_TOOLS = [
     "memory_add",
     "memory_search",
     "memory_list",
     "memory_supersede",
     "memory_forget",
+    "memory_status",
+    "memory_submit",
+    "memory_propose",
+    "memory_promote",
+    "memory_resolve",
+    "memory_pr_status",
 ];
 function nodeCheck() {
     const [major, minor] = process.versions.node.split(".").map(Number);
@@ -54,7 +62,13 @@ function storageCheck() {
     try {
         const p = paths();
         fs.accessSync(p.memories, fs.constants.W_OK);
-        return { name: "storage", ok: true, detail: `${p.root} (writable)` };
+        // D62: when the root came from the legacy env var, say so (still ok —
+        // the fallback is supported, doctor just names the current one).
+        const via = homeOverride()?.via;
+        const note = via === "MY_O_MEMORY_HOME"
+            ? " (via legacy MY_O_MEMORY_HOME — OPEN_MEMEX_HOME is the current name)"
+            : "";
+        return { name: "storage", ok: true, detail: `${p.root} (writable)${note}` };
     }
     catch (err) {
         return { name: "storage", ok: false, detail: String(err) };
@@ -401,7 +415,8 @@ function mcpCheck() {
     });
 }
 /** Parse JSON tolerating line/block comments plus trailing commas
- * (VS Code's settings.json is JSONC). Health-check grade, not a full parser. */
+ * (VS Code's settings.json is JSONC). Uses config.ts's string-aware
+ * stripper — one parser, not two (P0 review, 2026-10-03). */
 function parseLenientJson(raw) {
     try {
         return JSON.parse(raw);
@@ -409,47 +424,7 @@ function parseLenientJson(raw) {
     catch {
         /* fall through to comment stripping */
     }
-    let out = "";
-    let i = 0;
-    let inStr = false;
-    let esc = false;
-    while (i < raw.length) {
-        const c = raw[i];
-        const n = raw[i + 1];
-        if (inStr) {
-            out += c;
-            if (esc)
-                esc = false;
-            else if (c === "\\")
-                esc = true;
-            else if (c === '"')
-                inStr = false;
-            i++;
-            continue;
-        }
-        if (c === '"') {
-            inStr = true;
-            out += c;
-            i++;
-            continue;
-        }
-        if (c === "/" && n === "/") {
-            while (i < raw.length && raw[i] !== "\n")
-                i++;
-            continue;
-        }
-        if (c === "/" && n === "*") {
-            i += 2;
-            while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/"))
-                i++;
-            i += 2;
-            continue;
-        }
-        out += c;
-        i++;
-    }
-    out = out.replace(/,\s*([}\]])/g, "$1");
-    return JSON.parse(out);
+    return JSON.parse(stripJsonComments(raw));
 }
 function vscodeSettingsPath() {
     const home = os.homedir();
@@ -559,13 +534,28 @@ export async function runDoctor() {
 function legacyCheck() {
     const name = "legacy my-o-memory";
     const found = [];
-    const envHome = process.env.MY_O_MEMORY_HOME;
+    // D62: the override may arrive via either env var name; check the value
+    // in effect, not just the legacy one.
+    const envHome = homeOverride()?.dir;
     if (envHome && envHome.includes(LEGACY_PACKAGE_NAME))
-        found.push(`MY_O_MEMORY_HOME points at a pre-rename dir (${envHome}) — unset it, then merge old data with \`open-memex migrate --to-v2\``);
+        found.push(`memory home points at a pre-rename dir (${envHome}) — unset it, then merge old data with \`open-memex migrate --to-v2\``);
     const root = paths().root;
     const legacyDir = path.join(path.dirname(root), LEGACY_PACKAGE_NAME);
     if (fs.existsSync(legacyDir) && fs.statSync(legacyDir).isDirectory())
         found.push(`legacy data dir ${legacyDir} — merge it with \`open-memex migrate --to-v2\``);
+    // D64: v1 stored personal memories under the scope dir "user"; v2 reads
+    // only "personal". Files left there are invisible to every read path —
+    // an upgrader silently sees an empty personal scope. Surface them here;
+    // the migration itself stays explicit (no silent moves).
+    try {
+        const userDir = path.join(root, "memories", "user");
+        if (fs.existsSync(userDir) &&
+            fs.readdirSync(userDir).some((f) => f.endsWith(".md")))
+            found.push("v1 personal memories under " + userDir + " are invisible to v2 reads — convert them with `open-memex migrate --to-v2` (it moves them to the personal scope; preview with --dry-run)");
+    }
+    catch {
+        /* unreadable — not this check's problem */
+    }
     for (const f of [opencodeGlobalConfigPath(), userMcpConfigPath("vscode"), userMcpConfigPath("cursor")]) {
         try {
             if (fs.existsSync(f) && fs.readFileSync(f, "utf8").includes(LEGACY_PACKAGE_NAME))

package/dist/export.js

@@ -117,10 +117,20 @@ export function importBundle(bundlePath, opts) {
         if (manifest.format !== EXPORT_FORMAT) {
             fail(`unsupported bundle format: ${manifest.format} (expected ${EXPORT_FORMAT})`);
         }
-        const result = { imported: 0, skippedIdentical: 0, skippedConflict: [] };
+        const result = { imported: 0, skippedIdentical: 0, skippedConflict: [], rejectedPaths: [] };
         const existingStmt = db().prepare(`SELECT content_hash FROM memories WHERE id = ?`);
+        // The manifest comes from whoever sent the bundle: entry.file must
+        // stay inside the staging dir (P0 review, 2026-10-03 — "../" entries
+        // otherwise read arbitrary .md files into the store). realpath also
+        // catches symlinks planted by the tarball.
+        const stageRoot = fs.realpathSync(stage);
         for (const entry of manifest.memories ?? []) {
-            const src = path.join(stage, entry.file);
+            const joined = path.resolve(path.join(stage, entry.file));
+            const src = fs.existsSync(joined) ? fs.realpathSync(joined) : joined;
+            if (!src.startsWith(stageRoot + path.sep)) {
+                result.rejectedPaths.push(entry.file);
+                continue;
+            }
             const mf = readMemoryFile(src);
             if (!mf)
                 continue;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
+import { pickScopeRoot } from "./scope.js";
 import { makeTools } from "./tools/memory.js";
 import { v2Plugin } from "./opencode-v2.js";
 /**
@@ -12,8 +13,9 @@ import { v2Plugin } from "./opencode-v2.js";
  * type-only (D58), and v2's decode is structural.
  */
 const server = async ({ worktree, directory }) => {
-    const roots = worktree || directory || process.cwd();
-    const state = bootstrapPlugin(roots);
+    // v1's `worktree` is the filesystem root for non-git folders — never seed a
+    // scope on it (D71). `pickScopeRoot` falls back to the opened `directory`.
+    const state = bootstrapPlugin(pickScopeRoot(worktree, directory));
     const tools = makeTools(() => state.scope, state.cfg);
     return {
         tool: tools,

package/dist/init.js

@@ -56,11 +56,12 @@ You have a local memory MCP server (\`open-memex\`). Its tools are
 these full names.
 
 - The server tells you when project outbox drafts are waiting for review — in
-  tool results. At session start, call \`memory_status\` once to check. When
-  drafts are waiting, summarize them (one line each) and ask the user which
-  ones to sync into the repo; sync NOTHING the user did not name. If you
-  already asked about these drafts this session, don't ask again. When the
-  server reports none waiting, do nothing.
+  tool results. When it does (or when the user asks), call \`memory_status\`
+  to see them; don't call it blindly at session start. When drafts are
+  waiting, summarize them (one line each) and ask the user which ones to
+  sync into the repo; sync NOTHING the user did not name. If you already
+  asked about these drafts this session, don't ask again. When the server
+  reports none waiting, do nothing.
 - BE PROACTIVE about facts the user states directly: when the user shares a
   decision, preference, project convention, or fix-and-cause worth remembering
   across sessions, call \`memory_add\` without being asked. Keep each memory to
@@ -286,7 +287,17 @@ function opencodePluginDir() {
  * loads open-memex in every project with no per-project init.
  */
 export function opencodeGlobalConfigPath(home = os.homedir()) {
-    return path.join(opencodeConfigDir(home, process.env.XDG_CONFIG_HOME), "opencode.json");
+    const dir = opencodeConfigDir(home, process.env.XDG_CONFIG_HOME);
+    // D64: init writes into whichever of .json/.jsonc already exists
+    // (writeOpencodeGlobalPlugin), so readers must resolve the same file.
+    // Hardcoding .json made uninstall report "nothing to remove" on
+    // .jsonc-only setups and left the plugin entry behind.
+    for (const name of ["opencode.jsonc", "opencode.json"]) {
+        const candidate = path.join(dir, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return path.join(dir, "opencode.json");
 }
 /**
  * Pure merge of the open-memex plugin URL into a parsed opencode config doc.
@@ -470,6 +481,7 @@ function writeVisualStudioMcpJson(root, force) {
             });
             return null;
         }
+        doc = parsed;
     }
     const section = (doc["servers"] ??= {});
     // F30: drop the pre-rename server entry — it points at the OLD data dir.
@@ -805,6 +817,11 @@ export async function initProject(opts) {
         const injectOnFirstTurn = await askBool("Inject relevant memories when a session starts?", DEFAULT_CONFIG.injectOnFirstTurn);
         if (injectOnFirstTurn !== DEFAULT_CONFIG.injectOnFirstTurn)
             patch.injectOnFirstTurn = injectOnFirstTurn;
+        // D61: capture-time aliases — agents attach alternate phrasings to each
+        // memory so differently-worded questions still find it.
+        const captureAliases = await askBool("Attach alternate phrasings (aliases) to memories so reworded questions still find them?", DEFAULT_CONFIG.captureAliases);
+        if (captureAliases !== DEFAULT_CONFIG.captureAliases)
+            patch.captureAliases = captureAliases;
         if (Object.keys(patch).length > 0) {
             const file = saveConfig(patch);
             console.log(`  + settings saved to ${file} (change later with \`open-memex config set <key> <value>\`)`);

package/dist/inventory-html.js

@@ -0,0 +1,150 @@
+/**
+ * HTML renderer for the inventory (D68 follow-up): a single local file
+ * a user opens in any browser to read what the store remembers. It
+ * renders the SAME data layer as the text/JSON formats
+ * (`src/inventory.ts`) — one source, three renderings, no drift.
+ *
+ * Design rules (3-C v2) enforced here:
+ * - Every byte of memory content is HTML-escaped. Memory text can come
+ *   from an imported bundle or a pasted web page; under file:// an
+ *   unescaped <script> would execute in the user's own browser.
+ * - The filter box is plain show/hide over server-rendered entries
+ *   (no innerHTML, no network, no external resources).
+ * - History (superseded versions, retracted, archived) is a folded
+ *   section with supersede-chain pointers — auditable, never mixed
+ *   into "what is remembered now". At scale (>50 current entries) the
+ *   scope sections fold too.
+ * - Read-only: no delete buttons, no server callback. Deletion stays a
+ *   confirmed conversation; the page says so, with the id to quote.
+ */
+import path from "node:path";
+import { PERSONAL_SCOPE } from "./scope.js";
+import { escapeHtml, relativeTime, reviewStateLabel, sourceLabel, } from "./retrieve/display.js";
+const FOLD_THRESHOLD = 50;
+function entryHtml(row, now) {
+    const meta = [escapeHtml(sourceLabel(row.source))];
+    const when = relativeTime(row.created_at, now);
+    if (when)
+        meta.push(escapeHtml(when));
+    if (row.scope_key !== PERSONAL_SCOPE.key) {
+        meta.push(escapeHtml(reviewStateLabel(row.review_state)));
+        if (row.review_state !== "draft") {
+            meta.push(row.file_path.replace(/\\/g, "/").includes("/.ai/open-memex/")
+                ? "file is in the repo"
+                : "file is not in the repo yet");
+        }
+    }
+    if (row.status !== "active")
+        meta.push(escapeHtml(`marked ${row.status}`));
+    return `    <article class="entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${meta.join(" · ")} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+function hiddenEntryHtml(row, now) {
+    const when = relativeTime(row.created_at, now);
+    const chain = row.superseded_by
+        ? ` · replaced by <span class="id">${escapeHtml(row.superseded_by)}</span>`
+        : "";
+    return `    <article class="entry hidden-entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${escapeHtml(row.status)}${when ? ` · saved ${escapeHtml(when)}` : ""}${chain} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+function sectionHtml(title, blurb, entries, count, fold, open) {
+    if (fold) {
+        return `  <details${open ? " open" : ""}>
+    <summary>${escapeHtml(title)} <span class="count">${count}</span></summary>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries}
+  </details>`;
+    }
+    return `  <section>
+    <h2>${escapeHtml(title)} <span class="count">${count}</span></h2>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries || '    <p class="empty">(nothing here yet)</p>'}
+  </section>`;
+}
+export function renderInventoryHtml(data) {
+    const now = Date.now();
+    const fold = data.total > FOLD_THRESHOLD;
+    const personalCount = data.scopes
+        .filter((s) => s.scopeKey === PERSONAL_SCOPE.key)
+        .reduce((n, s) => n + s.rows.length, 0);
+    const parts = [];
+    data.scopes.forEach((s, i) => {
+        const isPersonal = s.scopeKey === PERSONAL_SCOPE.key;
+        parts.push(sectionHtml(isPersonal ? "About you — personal" : `Project: ${s.projectName}`, isPersonal
+            ? "These describe you, apply in every project, and never leave this machine."
+            : "Project memories. Each entry says whether it is still only on this machine (the outbox) or has reached the repo.", s.rows.map((r) => entryHtml(r, now)).join("\n"), s.rows.length, fold, isPersonal || i === 0));
+    });
+    if (data.outbox.length > 0) {
+        parts.push(sectionHtml("Not in the repo yet — outbox drafts", "These drafts exist only on this machine. They reach the repo through review (submit → promote), never automatically.", data.outbox.map((r) => entryHtml(r, now)).join("\n"), data.outbox.length, fold, false));
+    }
+    if (data.hiddenEntries.length > 0) {
+        const h = data.hiddenEntries.map((r) => hiddenEntryHtml(r, now)).join("\n");
+        parts.push(`  <details>
+    <summary>Replaced &amp; hidden history <span class="count">${data.hiddenEntries.length}</span></summary>
+    <p class="blurb">Older versions and withdrawn memories. Kept so you can audit how a fact changed; none of this is used for recall.</p>
+${h}
+  </details>`);
+    }
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<!-- D70: the page claims it makes no network requests - enforce it. Inline
+     style/script are the only allowances; anything else (a stray <img
+     src>, a remote font) is blocked by the browser, not just by our promise. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'">
+<title>What OpenMemex remembers</title>
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem auto; max-width: 44rem; padding: 0 1rem; color: #1a1a1a; background: #fdfdfb; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.25rem; }
+  h2, summary { font-size: 1.1rem; font-weight: 600; }
+  summary { cursor: pointer; margin: 1.2rem 0 0.4rem; }
+  .sub { color: #666; font-size: 0.9rem; margin-top: 0; }
+  .count { color: #888; font-weight: normal; font-size: 0.85em; }
+  .blurb { color: #555; font-size: 0.9rem; }
+  .entry { border-top: 1px solid #e5e2d9; padding: 0.75rem 0; }
+  .hidden-entry { opacity: 0.75; }
+  .body { white-space: pre-wrap; margin: 0 0 0.35rem; }
+  .meta { color: #666; font-size: 0.82rem; margin: 0; }
+  .id { font-family: ui-monospace, monospace; font-size: 0.78rem; }
+  .empty { color: #888; }
+  .howto { background: #f4f1e8; border-radius: 6px; padding: 0.75rem 1rem; font-size: 0.9rem; }
+  input[type="search"] { width: 100%; padding: 0.5rem; font-size: 1rem; margin: 1rem 0; box-sizing: border-box; }
+  .hidden { display: none; }
+</style>
+</head>
+<body>
+<h1>What OpenMemex remembers about you</h1>
+<p class="sub">Generated ${escapeHtml(data.generatedAt)} · ${data.total} memories (${personalCount} personal, ${data.total - personalCount} project incl. outbox). Read-only report.</p>
+<input type="search" id="filter" placeholder="Filter memories…" aria-label="Filter memories">
+<div class="howto">
+  <strong>Checking my work:</strong> every entry shows where it came from.
+  “I inferred this” means I wrote it from context, not from your words — those are the ones to check.
+  To remove one, tell your agent <em>“forget the memory about …”</em> (quote the id if you like) and it will read the entry back before deleting it — deletion is permanent, there is no undo.
+  A memory that lives in a repo is only truly gone once the deletion is committed.
+</div>
+${parts.join("\n")}
+<script>
+  var input = document.getElementById('filter');
+  input.addEventListener('input', function () {
+    var q = input.value.trim().toLowerCase();
+    var entries = document.querySelectorAll('.entry');
+    for (var i = 0; i < entries.length; i++) {
+      var el = entries[i];
+      el.classList.toggle('hidden', q !== '' && el.textContent.toLowerCase().indexOf(q) === -1);
+    }
+  });
+</script>
+</body>
+</html>
+`;
+}
+/** Default report location: the data dir, never a working tree. */
+export function defaultHtmlOutPath(dataRoot) {
+    return path.join(dataRoot, "inventory.html");
+}

package/dist/inventory.js

@@ -0,0 +1,176 @@
+/**
+ * `open-memex inventory` (D68): what the store remembers, in the open.
+ * One data layer, three renderers (text / json / html). The HTML
+ * renderer lives in inventory-html.ts; this module owns the data and
+ * the two renderers an agent or a terminal consumes directly.
+ *
+ * Design rules (3-C v2) enforced here:
+ * - Default scope is personal + the current project — "can't see it"
+ *   is the disease this surface treats.
+ * - Nothing truncates silently: every section states its totals, and
+ *   hidden history (superseded versions, retracted, archived) is
+ *   counted and pointed at, never just omitted.
+ * - Drafts that have not reached the repo (the outbox) are their own
+ *   section, consistent with what memory_status reports.
+ * - The report is read-only. Deleting stays a confirmed conversation.
+ */
+import { db } from "./store/db.js";
+import { PERSONAL_SCOPE } from "./scope.js";
+import { formatInventoryLine } from "./retrieve/display.js";
+const BASE_COLS = `id, scope_key, project_name, type, status, review_state,
+  source, created_at, updated_at, content, file_path`;
+/**
+ * Load the inventory for the given scopes. `projectScopeKey` separates the
+ * outbox drafts (they belong to that scope's draft rows).
+ *
+ * D70: `hidden: "entries"` fetches the hidden rows themselves (HTML audit
+ * view); the default keeps the cheap COUNT query, because pulling every
+ * superseded body for a text report nobody reads is pure waste.
+ */
+export function loadInventory(scopeKeys, opts = {}) {
+    const inList = scopeKeys.map(() => "?").join(",");
+    const current = db()
+        .prepare(`SELECT ${BASE_COLS} FROM memories
+       WHERE scope_key IN (${inList}) AND status IN ('active', 'deprecated')
+       ORDER BY scope_key, updated_at DESC`)
+        .all(...scopeKeys);
+    const hiddenEntries = opts.hidden === "entries"
+        ? db()
+            .prepare(`SELECT ${BASE_COLS}, superseded_by FROM memories
+             WHERE scope_key IN (${inList}) AND status IN ('superseded', 'retracted', 'archived')
+             ORDER BY updated_at DESC`)
+            .all(...scopeKeys)
+        : [];
+    const hidden = { superseded: 0, retracted: 0, archived: 0 };
+    if (hiddenEntries.length > 0) {
+        for (const r of hiddenEntries) {
+            if (r.status === "superseded")
+                hidden.superseded++;
+            if (r.status === "retracted")
+                hidden.retracted++;
+            if (r.status === "archived")
+                hidden.archived++;
+        }
+    }
+    else {
+        const counted = db()
+            .prepare(`SELECT status, COUNT(*) AS n FROM memories
+         WHERE scope_key IN (${inList}) AND status IN ('superseded', 'retracted', 'archived')
+         GROUP BY status`)
+            .all(...scopeKeys);
+        for (const r of counted) {
+            if (r.status === "superseded")
+                hidden.superseded = r.n;
+            if (r.status === "retracted")
+                hidden.retracted = r.n;
+            if (r.status === "archived")
+                hidden.archived = r.n;
+        }
+    }
+    const outbox = current.filter((r) => r.scope_key !== PERSONAL_SCOPE.key && r.review_state === "draft");
+    const outboxIds = new Set(outbox.map((r) => r.id));
+    const byScope = new Map();
+    for (const r of current) {
+        if (outboxIds.has(r.id))
+            continue;
+        const arr = byScope.get(r.scope_key) ?? [];
+        arr.push(r);
+        byScope.set(r.scope_key, arr);
+    }
+    // Personal first, then project scopes by key for a stable order.
+    // D70: every requested scope appears, including one with nothing in it —
+    // "this project has no memories" is part of the answer, and dropping the
+    // section made the report look like the project was never looked at.
+    const orderedKeys = [
+        ...scopeKeys.filter((k) => k === PERSONAL_SCOPE.key),
+        ...scopeKeys.filter((k) => k !== PERSONAL_SCOPE.key).sort(),
+    ];
+    const scopes = orderedKeys.map((k) => {
+        const rows = byScope.get(k) ?? [];
+        return {
+            scopeKey: k,
+            projectName: rows[0]?.project_name || k,
+            rows,
+        };
+    });
+    return {
+        generatedAt: new Date().toISOString(),
+        scopes,
+        outbox,
+        hidden,
+        hiddenEntries,
+        total: current.length,
+    };
+}
+function hiddenLine(data) {
+    const { superseded, retracted, archived } = data.hidden;
+    if (superseded + retracted + archived === 0)
+        return "";
+    return `Not shown: ${superseded} superseded version(s), ${retracted} retracted, ${archived} archived — inspect with \`open-memex list --include all\`.`;
+}
+function entriesText(rows, startAt = 0) {
+    if (rows.length === 0)
+        return "(nothing remembered in this scope yet)";
+    return rows
+        .map((r, i) => formatInventoryLine(startAt + i, { ...r, snippet: r.content }, PERSONAL_SCOPE.key))
+        .join("\n");
+}
+/** Plain-text rendering: diffable in any terminal or CI log. */
+export function renderInventoryText(data) {
+    const out = [];
+    out.push(`What OpenMemex remembers — ${data.generatedAt}`);
+    out.push(`${data.total} memories (${data.scopes.reduce((n, s) => n + (s.scopeKey === PERSONAL_SCOPE.key ? s.rows.length : 0), 0)} personal, ${data.outbox.length} in the outbox).`);
+    // D70: one running counter across every section, so a number quoted back
+    // ("delete #3") names exactly one entry in this report.
+    let seq = 0;
+    for (const s of data.scopes) {
+        const title = s.scopeKey === PERSONAL_SCOPE.key
+            ? "About you — personal (never leaves this machine)"
+            : `Project: ${s.projectName}`;
+        out.push("", `## ${title} (${s.rows.length})`, entriesText(s.rows, seq));
+        seq += s.rows.length;
+    }
+    if (data.outbox.length > 0) {
+        out.push("", `## Not in the repo yet — outbox drafts (${data.outbox.length})`, "These exist only on this machine. They reach the repo through review (submit → promote), never automatically.", entriesText(data.outbox, seq));
+        seq += data.outbox.length;
+    }
+    const hidden = hiddenLine(data);
+    if (hidden)
+        out.push("", hidden);
+    out.push("", "Read-only report. To remove a memory, tell your agent to forget it — it will read the entry back before deleting (deletion is permanent).");
+    return out.join("\n") + "\n";
+}
+/**
+ * JSON rendering: same data, for agents. Mirrors the export field names.
+ *
+ * D70: format `/2` drops the absolute `file` path. This artifact is meant
+ * to be handed to an agent — i.e. pasted into a cloud conversation — and it
+ * carried the user's home directory and name with it. The id locates the
+ * file (`open-memex where` prints the data root).
+ */
+export function renderInventoryJson(data) {
+    const entry = (r) => ({
+        id: r.id,
+        scope: r.scope_key,
+        project: r.project_name,
+        type: r.type,
+        status: r.status,
+        review_state: r.review_state,
+        source: r.source,
+        created_at: new Date(r.created_at).toISOString(),
+        updated_at: new Date(r.updated_at).toISOString(),
+        content: r.content,
+    });
+    return (JSON.stringify({
+        format: "open-memex-inventory/2",
+        generated_at: data.generatedAt,
+        total: data.total,
+        scopes: data.scopes.map((s) => ({
+            scope: s.scopeKey,
+            project: s.projectName,
+            memories: s.rows.map(entry),
+        })),
+        outbox: data.outbox.map(entry),
+        hidden: data.hidden,
+    }, null, 2) + "\n");
+}

package/dist/mcp.js

@@ -85,9 +85,19 @@ memory_resolve, memory_pr_status — always call them by these full names.
   docs, save it as type "reference" pointing at the doc instead of copying it.
   Long-form notes are fine ONLY when the user explicitly asks to save one.
 - Before asking the user about past decisions, conventions, or preferences they
-  may have told you before, call memory_search first — try a few keyword
-  variants (including the user's own language) when the first search comes up
-  empty.
+  may have told you before, call memory_search first — 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.
+- When the user asks what you remember (about them, or in this project),
+  call memory_list with scope=both and present it conversationally — turn
+  the structured fields into plain words (source=user → "you told me
+  this"; source=inference → "I inferred this, check me"), and don't read
+  raw ids aloud. If they ask to remove or hide an entry, re-run
+  memory_list first (numbers from an older listing may have shifted),
+  read the candidate back in full, and get a confirmation before calling
+  memory_forget: deletion is permanent. If they hesitate, offer soft=true
+  (hide it instead — still one-way, but the file survives).
 - Memories default to this project's scope; use the personal scope for facts
   about the user that hold across all projects. When a saved fact becomes
   outdated, call memory_supersede (find the old memory's id with memory_search
@@ -141,9 +151,15 @@ export async function runMcpServer() {
     // D53: session-start outbox state, pushed. The stdio server starts fresh per
     // session, so construction-time state ≈ session-start state.
     const n = outboxDraftCount(scope.key);
-    const instructions = n > 0
+    // D61: the alias guidance rides the handshake only when the install
+    // enables capture aliases — otherwise agents would attach aliases the
+    // server then drops.
+    const aliasGuidance = cfg.captureAliases
+        ? "\n- When you save a memory, attach 2–4 aliases via memory_add's aliases parameter: alternate phrasings, synonyms, equivalents in the user's other language. They are indexed with the memory so a differently-worded question still finds it."
+        : "";
+    const instructions = (n > 0
         ? `${SERVER_INSTRUCTIONS}\n\nSession start: the project outbox has ${n} draft${n === 1 ? "" : "s"} waiting for review — call memory_status to see them.`
-        : SERVER_INSTRUCTIONS;
+        : SERVER_INSTRUCTIONS) + aliasGuidance;
     const server = new McpServer({ name: "open-memex", version: SERVER_VERSION }, { instructions });
     server.registerTool("memory_add", {
         description: TOOL_DESCRIPTIONS.memory_add,

package/dist/paths.js

@@ -2,9 +2,23 @@ import path from "node:path";
 import fs from "node:fs";
 import os from "node:os";
 import { execFileSync } from "node:child_process";
-function dataRoot() {
+/**
+ * D62: the data-root override env var. `OPEN_MEMEX_HOME` is the current
+ * name; `MY_O_MEMORY_HOME` (pre-rename package name) is still honored as a
+ * fallback so existing setups and scripts keep working. New name wins
+ * when both are set.
+ */
+export function homeOverride() {
+    if (process.env.OPEN_MEMEX_HOME)
+        return { dir: path.resolve(process.env.OPEN_MEMEX_HOME), via: "OPEN_MEMEX_HOME" };
     if (process.env.MY_O_MEMORY_HOME)
-        return path.resolve(process.env.MY_O_MEMORY_HOME);
+        return { dir: path.resolve(process.env.MY_O_MEMORY_HOME), via: "MY_O_MEMORY_HOME" };
+    return null;
+}
+function dataRoot() {
+    const override = homeOverride();
+    if (override)
+        return override.dir;
     if (process.platform === "win32") {
         const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
         return path.join(appData, "open-memex");
@@ -70,6 +84,24 @@ export function inRepoMemoriesDir(root, memoryDir) {
     return dir;
 }
 /** Same as `inRepoMemoriesDir` but never creates the directory. */
+/**
+ * True when a memory file lives inside the user's git working tree (the
+ * in-repo `.ai/open-memex/` copy) rather than in the local data root.
+ *
+ * D70: both destructive/corrective surfaces need this — the hard delete
+ * already said "commit the deletion so the team sees it" (D64), and the
+ * soft hide has to say the same, because a retraction that never gets
+ * committed leaves the memory standing on every teammate's clone.
+ */
+export function isInRepoMemoryFile(filePath) {
+    if (!filePath)
+        return false;
+    const normalized = filePath.replace(/\\/g, "/");
+    return normalized.includes("/.ai/open-memex/") && !normalized.startsWith(root());
+}
+function root() {
+    return paths().root.replace(/\\/g, "/");
+}
 export function inRepoMemoriesDirPath(root, memoryDir) {
     return path.join(root, memoryDir);
 }