open-memex 0.6.2 → 0.7.0-alpha.11

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
@@ -271,13 +272,32 @@ function opencodePluginUrl() {
     const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
     return pathToFileURL(path.join(pkgRoot, "src", "index.ts")).href;
 }
+/**
+ * D60: the same plugin directory, in the form OpenCode 2 wants. v2 rejects
+ * file entries in `plugins` ("configured plugin path must be a directory")
+ * and loads `<dir>/index.ts` instead.
+ */
+function opencodePluginDir() {
+    const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    return path.join(pkgRoot, "src");
+}
 /**
  * D46: opencode's user-level config. opencode reads `~/.config/opencode/`
  * (`$XDG_CONFIG_HOME` when set) on every platform; a `plugin` entry there
  * 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.
@@ -297,6 +317,63 @@ export function mergePluginEntry(doc, url, force) {
         list.push(url);
     return "added";
 }
+/** The package path an OpenCode 2 `plugins` entry refers to, if any. */
+function v2EntryPackage(entry) {
+    if (typeof entry === "string")
+        return entry;
+    if (entry !== null && typeof entry === "object" && "package" in entry) {
+        const p = entry.package;
+        return typeof p === "string" ? p : null;
+    }
+    return null;
+}
+/**
+ * D60: pure merge of the open-memex directory into the `plugins` array
+ * (the OpenCode 2 spelling). An existing open-memex entry (any form)
+ * counts as present; with force, stale open-memex entries are replaced
+ * by `dir`. Same "added"/"kept" contract as mergePluginEntry.
+ */
+export function mergeV2PluginEntry(doc, dir, force) {
+    let plugins = doc["plugins"];
+    if (!Array.isArray(plugins)) {
+        plugins = [];
+        doc["plugins"] = plugins;
+    }
+    const list = plugins;
+    const ours = (e) => (v2EntryPackage(e) ?? "").includes("open-memex");
+    if (!force && list.some(ours))
+        return "kept";
+    for (let i = list.length - 1; i >= 0; i--) {
+        const p = v2EntryPackage(list[i]);
+        if (p === dir) {
+            if (!force)
+                return "kept";
+            list.splice(i, 1);
+        }
+        else if (force && ours(list[i])) {
+            list.splice(i, 1);
+        }
+    }
+    list.push(dir);
+    return "added";
+}
+/**
+ * Pure removal of open-memex entries from the `plugins` array (OpenCode 2
+ * spelling — strings and `{package}` objects). Drops the key when empty.
+ */
+export function removeV2PluginEntry(doc, match) {
+    const plugins = doc["plugins"];
+    if (!Array.isArray(plugins))
+        return "absent";
+    const kept = plugins.filter((p) => !(v2EntryPackage(p) ?? "").includes(match));
+    if (kept.length === plugins.length)
+        return "absent";
+    if (kept.length === 0)
+        delete doc["plugins"];
+    else
+        doc["plugins"] = kept;
+    return "removed";
+}
 /**
  * D46: wire the native plugin at the opencode user level — the one-time
  * global setup. Merges into the existing config when it parses as JSON;
@@ -309,6 +386,7 @@ function writeOpencodeGlobalPlugin(force) {
         .map((f) => path.join(dir, f))
         .find((f) => fs.existsSync(f)) ?? path.join(dir, "opencode.json");
     const url = opencodePluginUrl();
+    const pluginDir = opencodePluginDir();
     let doc = {};
     if (fs.existsSync(file)) {
         try {
@@ -316,7 +394,8 @@ function writeOpencodeGlobalPlugin(force) {
         }
         catch {
             console.log(`  ! ${file} has comments or invalid JSON — left untouched, fix it manually.`);
-            console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] to it.`);
+            console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] (opencode 1)`);
+            console.log(`    and "plugins": ["${pluginDir}"] (opencode 2) to it.`);
             console.log(`    Also remove any "${LEGACY_PACKAGE_NAME}" entries from "plugin" (stale — package renamed).`);
             return null;
         }
@@ -325,8 +404,12 @@ function writeOpencodeGlobalPlugin(force) {
     // alongside the new one — it writes to the OLD data dir, silently splitting
     // memories in two. Drop it wherever init touches the plugin list.
     const staleRemoved = removePluginEntry(doc, LEGACY_PACKAGE_NAME) === "removed";
+    removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
     const merged = mergePluginEntry(doc, url, force);
-    if (merged === "kept" && !staleRemoved) {
+    // D60: write both key generations — opencode 1 reads `plugin`, opencode 2
+    // reads `plugins`; each host ignores the other's key.
+    const mergedV2 = mergeV2PluginEntry(doc, pluginDir, force);
+    if (merged === "kept" && mergedV2 === "kept" && !staleRemoved) {
         console.log(`  = ${file} already loads the open-memex plugin — left as is (use --force to overwrite)`);
         return file;
     }
@@ -334,7 +417,7 @@ function writeOpencodeGlobalPlugin(force) {
     fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     if (staleRemoved)
         console.log(`  - ${file} (stale my-o-memory plugin entry removed — package renamed to open-memex)`);
-    if (merged === "added")
+    if (merged === "added" || mergedV2 === "added")
         console.log(`  + ${file} (native plugin — works in every project, no per-project init needed)`);
     return file;
 }
@@ -398,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.
@@ -733,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>\`)`);
@@ -882,13 +971,16 @@ function removeOpencodePluginFile(file) {
     const doc = parseJsonConfig(fs.readFileSync(file, "utf8"));
     if (doc === null) {
         console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
-        console.error(`    Delete the open-memex URL from the "plugin" array.`);
+        console.error(`    Delete the open-memex URL from the "plugin" array and the open-memex path from "plugins".`);
         return null;
     }
     const res = removePluginEntry(doc, "open-memex");
+    // D60: the v2 `plugins` entry goes too (strings and {package} objects).
+    const resV2 = removeV2PluginEntry(doc, "open-memex");
     // F30: also sweep the pre-rename leftover — see removeServerEntryFile.
     const stale = removePluginEntry(doc, LEGACY_PACKAGE_NAME);
-    if (res === "removed" || stale === "removed") {
+    removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
+    if (res === "removed" || resV2 === "removed" || stale === "removed") {
         fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
         console.log(`  - ${file} (memory-plugin entries removed)`);
         return "removed";

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/opencode-v2.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
+import { makeTools } from "./tools/memory.js";
+/** Register the five memory tools on a v2 host. */
+async function registerTools(ctx, state) {
+    const tools = makeTools(() => state.scope, state.cfg);
+    await ctx.tool.transform((editor) => {
+        for (const [name, t] of Object.entries(tools)) {
+            editor.add({
+                name,
+                description: t.description,
+                input: z.toJSONSchema(z.object(t.args)),
+                options: { codemode: false },
+                execute: async (input) => {
+                    const r = await t.execute(input, undefined);
+                    const content = typeof r === "string" ? r : (r.output ?? JSON.stringify(r));
+                    return { content };
+                },
+            });
+        }
+    });
+}
+export const v2Plugin = {
+    id: PLUGIN_ID,
+    async setup(ctx) {
+        const root = ctx.location?.directory ?? ctx.location?.project?.directory ?? process.cwd();
+        const state = bootstrapPlugin(root);
+        const registrations = [];
+        await registerTools(ctx, state);
+        registrations.push(await ctx.session.hook("prompt", (ev) => {
+            captureFromText(ev.prompt?.text ?? "", state);
+        }));
+        registrations.push(await ctx.session.hook("context", (ev) => {
+            injectOnce(ev.sessionID ?? "", state, (block) => {
+                ev.system.push({ type: "text", text: block });
+            });
+        }));
+        return () => {
+            for (const r of registrations)
+                void r.dispose?.();
+        };
+    },
+};

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