open-memex 0.7.0-alpha.2 → 0.7.0-alpha.4

package/AGENTS.md

@@ -102,7 +102,7 @@ The published `open-memex` bin points at `dist/cli.js` (compiled at publish time
 From a source checkout, `npm run cli` / `npm run mcp` still run `src/` directly
 with type-stripping — no build step needed for development.
 
-There is **no `npm test`** and no CI. Verification loop is: `npm run typecheck` + `smoke-pure.ts` + (if touching sqlite) `npm run cli -- reindex` against a scratch `MY_O_MEMORY_HOME`.
+There is **no `npm test`** and no CI. Verification loop is: `npm run typecheck` + `smoke-pure.ts` + (if touching sqlite) `npm run cli -- reindex` against a scratch `OPEN_MEMEX_HOME`.
 
 To load the plugin in opencode locally, `~/.config/opencode/opencode.jsonc` must have:
 ```
@@ -115,7 +115,7 @@ Restart opencode after any change — the plugin is not hot-reloaded.
 Storage root:
 - Windows: `%APPDATA%\open-memex\`
 - Linux/macOS: `$XDG_DATA_HOME/open-memex/` (fallback `~/.local/share/open-memex/`)
-- Override with `MY_O_MEMORY_HOME` (use this for tests to avoid clobbering real data).
+- Override with `OPEN_MEMEX_HOME` (use this for tests to avoid clobbering real data). The pre-rename `MY_O_MEMORY_HOME` is still honored as a fallback (D62).
 
 Layout: `memories/<scope_key>/<id>.md` (YAML frontmatter + body) + `index.db` (SQLite FTS5).
 
@@ -136,6 +136,7 @@ Every write path (tool, keyword hook, CLI `add`) must:
 2. If `hadSecret` → the matched secret is **masked in place** (first 4 characters kept, the rest replaced with `x`) and the write proceeds; never save the unmasked original. `<private>…</private>` spans are stripped to `[REDACTED]` instead (design D14).
 3. Check `findDuplicates` (design §3.4): identical content is idempotent (return existing id); near-duplicates (similarity ≥ 0.8) warn but save — suggest `supersede` when the new content replaces the old.
 4. `writeMemoryFile` first, then `readMemoryFile` + `upsertFromFile` to keep FTS in sync.
+5. Deletion reports honestly (D63): only ENOENT counts as "deleted"; any other unlink failure keeps the index row and returns failure — the file is the source of truth and would otherwise resurrect the memory on next sync.
 
 Capture-time aliases (D61): `memory_add`/`supersede` may carry up to 4
 `aliases` (alternate phrasings) into frontmatter; they index in their own FTS

package/CHANGELOG.md

@@ -9,6 +9,21 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## Correctness fixes from the whole-project review (D63)
+
+Six silent-wrong-answer bugs found by an external three-lens review, each fixed with a regression test:
+
+- `init --client visualstudio` no longer wipes other servers from an existing `.mcp.json` (the parsed config was dropped instead of merged).
+- `memory_forget` / `forget` tell the truth: when the memory file can't be deleted (locked, in use), they report failure and keep the index entry, instead of claiming success while the file — the source of truth — brings the memory back on next sync.
+- Config parsing is string-aware: a redact pattern like `src/**/secrets` is no longer eaten as a block comment and silently disabled. `doctor` and the config loader now share one parser.
+- `loadConfig` enforces the `memoryDir` invariant on hand-edited configs; an escaping value (`../../shared`) falls back to the default with a warning instead of writing project memories outside the repo.
+- `migrate` re-scopes as well as re-keys: migrated files get the destination's `scope`/`visibility`, so personal→project migrations are submittable and project→personal memories stay private in exports. Conflict resolution compares parsed timestamps, not RFC-3339 strings.
+- `import` rejects bundle entries whose paths escape the bundle (`../` or symlinks) instead of reading arbitrary local files into the store; rejected paths are printed.
+
+## Environment variable names (D62)
+
+- The override variables now answer to `OPEN_MEMEX_HOME` (storage root) and `OPEN_MEMEX_CONFIG` (config path). The pre-rename `MY_O_MEMORY_HOME` / `MY_O_MEMORY_CONFIG` names keep working as fallbacks — nothing to migrate, the data root itself does not move. `doctor` notes when the storage root came from the legacy variable.
+
 ## Proactive capture: checkpoint proposals and aliases (D61)
 
 - At task checkpoints the agent now proposes instead of waiting to be asked: when a task wraps up, it offers 1–3 short candidate memories distilled from the session (decisions and their reasons, conventions, gotchas, approaches tried and abandoned) and saves only the ones you approve — approved inferences are marked `source: "inference"`. One memorability rubric and one search discipline (break the question into concepts, try several phrasings, check both scopes) are written into every guidance surface — the bundled skill, the AGENTS.md memory-hygiene footer, the MCP handshake, and the tool descriptions — so behavior is consistent across editors. Nothing is auto-drafted in the background; that posture waits on memory visibility.

package/README.md

@@ -578,8 +578,9 @@ branches and PRs like any other file.
 
 Settings live in `~/.config/opencode/open-memex.jsonc` — the `opencode` in the
 path is historical; this one file is shared by every client. Override the config
-path with `MY_O_MEMORY_CONFIG` and the storage root with `MY_O_MEMORY_HOME`
-(legacy environment names from before the rename, still honored).
+path with `OPEN_MEMEX_CONFIG` and the storage root with `OPEN_MEMEX_HOME`
+(the pre-rename `MY_O_MEMORY_CONFIG` / `MY_O_MEMORY_HOME` names are still
+honored as fallbacks).
 
 Defaults:
 

package/README.zh-CN.md

@@ -391,7 +391,7 @@ npm install -g open-memex@latest   # 或 @alpha
 
 ## 配置
 
-设置放在 `~/.config/opencode/open-memex.jsonc`——路径里的 `opencode` 是历史名；这一个文件由所有客户端共享。用 `MY_O_MEMORY_CONFIG` 覆盖配置路径，用 `MY_O_MEMORY_HOME` 覆盖存储根目录（改名之前留下的旧环境变量名，仍然有效）。
+设置放在 `~/.config/opencode/open-memex.jsonc`——路径里的 `opencode` 是历史名；这一个文件由所有客户端共享。用 `OPEN_MEMEX_CONFIG` 覆盖配置路径，用 `OPEN_MEMEX_HOME` 覆盖存储根目录（改名之前的旧变量名 `MY_O_MEMORY_CONFIG` / `MY_O_MEMORY_HOME` 仍然有效，作为回退）。
 
 默认值：
 

package/dist/cli.js

@@ -954,12 +954,18 @@ async function main() {
             process.exit(1);
         }
         // Delete by indexed file_path — location-agnostic (appdata or in-repo, 2B/D24).
+        // Only ENOENT = success; anything else means the file survives and
+        // would be re-indexed — fail loudly (P0 review, 2026-10-03).
         if (row.file_path) {
             try {
                 fs.unlinkSync(row.file_path);
             }
-            catch {
-                /* already gone */
+            catch (e) {
+                const code = e.code;
+                if (code !== "ENOENT") {
+                    console.error(`could not delete ${row.file_path} (${code ?? "error"}) — memory not forgotten`);
+                    process.exit(1);
+                }
             }
         }
         deleteFromIndex(id);
@@ -1176,6 +1182,9 @@ async function main() {
                 syncScope(PERSONAL_SCOPE.key, "cli");
             }
             console.log(`${dryRun ? "DRY RUN: " : ""}imported ${r.imported}, skipped ${r.skippedIdentical} identical`);
+            for (const rp of r.rejectedPaths) {
+                console.log(`  rejected: ${rp} (path outside the bundle)`);
+            }
             for (const c of r.skippedConflict) {
                 console.log(`  conflict (kept existing): ${c.id} from ${c.file}`);
             }

package/dist/config.js

@@ -37,18 +37,73 @@ export const DEFAULT_CONFIG = {
     memoryDir: ".ai/open-memex",
     sync: { autoPull: false },
 };
-function stripJsonComments(raw) {
-    // Line comments
-    let out = raw.replace(/^\s*\/\/.*$/gm, "");
-    // Block comments (non-greedy)
-    out = out.replace(/\/\*[\s\S]*?\*\//g, "");
-    // Trailing commas before closing brackets
-    out = out.replace(/,(\s*[}\]])/g, "$1");
+/**
+ * Strip JSONC comments and trailing commas with a string-aware scanner.
+ * The previous regex version was not string-aware: a config value like
+ * "src/**\/secrets" had its `/**…*\/` eaten as a block comment, silently
+ * corrupting the user's redact pattern (P0 review, 2026-10-03). Shared
+ * with doctor.ts — one parser, not two.
+ */
+export function stripJsonComments(raw) {
+    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;
+        }
+        if (c === ",") {
+            // Trailing comma: drop it when the next significant char closes a
+            // container. Whitespace/comments between are tolerated.
+            let j = i + 1;
+            while (j < raw.length && /\s/.test(raw[j]))
+                j++;
+            if (raw[j] === "}" || raw[j] === "]") {
+                i++;
+                continue;
+            }
+        }
+        out += c;
+        i++;
+    }
     return out;
 }
-/** Where `config set` / interactive `init` persist. Respects MY_O_MEMORY_CONFIG. */
+/**
+ * Where `config set` / interactive `init` persist. Respects OPEN_MEMEX_CONFIG
+ * (D62); MY_O_MEMORY_CONFIG is the pre-rename fallback, still honored.
+ */
 export function configFilePath() {
-    return (process.env.MY_O_MEMORY_CONFIG ??
+    return (process.env.OPEN_MEMEX_CONFIG ??
+        process.env.MY_O_MEMORY_CONFIG ??
         path.join(os.homedir(), ".config", "opencode", "open-memex.jsonc"));
 }
 function toBool(v) {
@@ -111,6 +166,7 @@ export function saveConfig(patch) {
 /** Path of the config file in effect, or null when using built-in defaults. */
 export function configSource() {
     const candidates = [
+        process.env.OPEN_MEMEX_CONFIG,
         process.env.MY_O_MEMORY_CONFIG,
         path.join(os.homedir(), ".config", "opencode", "open-memex.jsonc"),
         path.join(os.homedir(), ".config", "opencode", "open-memex.json"),
@@ -127,7 +183,19 @@ export function loadConfig() {
         try {
             const raw = fs.readFileSync(p, "utf8");
             const parsed = JSON.parse(stripJsonComments(raw));
-            return { ...DEFAULT_CONFIG, ...parsed };
+            const merged = { ...DEFAULT_CONFIG, ...parsed };
+            // The config file is hand-editable, so the load path must enforce
+            // the same invariants `config set` does (P0 review, 2026-10-03):
+            // an unvalidated memoryDir like "../../shared" would put
+            // committed project memories outside the repo.
+            try {
+                merged.memoryDir = toRelativeDir(merged.memoryDir);
+            }
+            catch {
+                console.error(`[open-memex] invalid memoryDir "${merged.memoryDir}" in ${p} — using default "${DEFAULT_CONFIG.memoryDir}"`);
+                merged.memoryDir = DEFAULT_CONFIG.memoryDir;
+            }
+            return merged;
         }
         catch (err) {
             console.error(`[open-memex] failed to parse ${p}:`, err);

package/dist/doctor.js

@@ -7,8 +7,8 @@ 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";
@@ -54,7 +54,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 +407,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 +416,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,9 +526,11 @@ 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())

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/init.js

@@ -470,6 +470,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.

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

package/dist/store/migrate.js

@@ -2,8 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { memoriesDirFor, memoriesDirPath } from "../paths.js";
 import { db } from "./db.js";
-import { iterMemoryFiles, readMemoryFile, serialize, } from "./markdown.js";
+import { iterMemoryFiles, readMemoryFile, serialize, timeToMs, } from "./markdown.js";
 import { syncScope } from "./sync.js";
+import { PERSONAL_SCOPE } from "../scope.js";
 /** True if this scope has at least one `.md` file on disk. Does not create
  *  the directory if it doesn't already exist. */
 export function scopeHasFiles(scopeKey) {
@@ -60,7 +61,10 @@ export function migrateScope(fromKey, toKey, opts = {}) {
             else if (strategy === "overwrite") {
                 log(`conflict: overwriting destination (--on-conflict=overwrite): ${dstPath}`);
             }
-            else if (dst.fm.updated_at >= mf.fm.updated_at) {
+            else if (timeToMs(dst.fm.updated_at) >= timeToMs(mf.fm.updated_at)) {
+                // Compare parsed instants, not RFC-3339 strings: lexicographic
+                // order breaks around fractional seconds ("…:00Z" > "…:00.005Z"),
+                // letting the older file win.
                 action = "skip";
                 log(`conflict: kept destination (newer updated_at): ${dstPath}`);
             }
@@ -72,9 +76,16 @@ export function migrateScope(fromKey, toKey, opts = {}) {
             stats.skipped++;
             continue;
         }
+        // Re-key AND re-scope: scope/visibility must follow the destination
+        // (P0 review, 2026-10-03). Rewriting only scope_key produced files
+        // submit rejects ("scope is personal") or personal memories carrying
+        // visibility: internal into exports.
+        const toPersonal = toKey === PERSONAL_SCOPE.key;
         const newFm = {
             ...mf.fm,
             scope_key: toKey,
+            scope: toPersonal ? "personal" : "project",
+            visibility: toPersonal ? "private" : "internal",
             project_name: opts.toProjectName ?? mf.fm.project_name,
         };
         const raw = serialize(newFm, mf.body);

package/dist/tools/ops.js

@@ -273,12 +273,21 @@ export async function forgetMemory(args) {
         return { title: "memory: not found", output: `No memory with id ${args.id}.` };
     }
     // Delete by indexed file_path — location-agnostic (appdata or in-repo, 2B/D24).
+    // Only ENOENT counts as "deleted": on any other unlink failure the file
+    // is still the source of truth and would be re-indexed on next sync, so
+    // report failure instead of lying (P0 review, 2026-10-03).
     if (row.file_path) {
         try {
             fs.unlinkSync(row.file_path);
         }
-        catch {
-            /* already gone */
+        catch (e) {
+            const code = e.code;
+            if (code !== "ENOENT") {
+                return {
+                    title: "memory: forget failed",
+                    output: `Could not delete ${row.file_path} (${code ?? "error"}) — the memory was NOT forgotten and is still in the index. Close anything holding the file and retry.`,
+                };
+            }
         }
     }
     deleteFromIndex(args.id);

package/docs/V2-DESIGN.md

@@ -1304,13 +1304,42 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   distillation over host transcripts stays its own group; it will
   reuse this rubric.
 
+- **D62 — environment variable names grow current-name aliases.** The
+  data-root and config-path overrides predate the rename and kept the
+  old package's name (`MY_O_MEMORY_HOME`, `MY_O_MEMORY_CONFIG`) — a
+  stale-looking name is a trap for users and agents scripting against
+  the current one. `OPEN_MEMEX_HOME` / `OPEN_MEMEX_CONFIG` are now the
+  preferred names; the legacy names still work as fallbacks (new name
+  wins when both are set), so existing setups and scripts never break.
+  The data root itself does not move — only the variable names change.
+  `doctor`'s storage check notes when the root arrived via the legacy
+  variable, and its pre-rename-dir leftovers check reads whichever
+  variable is in effect.
+
+- **D63 — correctness fixes from a whole-project external review.** Six
+  verified silent-wrong-answer bugs, fixed as one batch: (1) VS init
+  dropped the parsed `.mcp.json` instead of merging it, wiping other
+  servers; (2) forget reported success when unlink failed — only ENOENT
+  is success now, both in the tool op and the CLI; (3) the config
+  loader's regex comment-stripper was not string-aware and corrupted
+  redact patterns (`src/**/secrets` → `srcsecrets`) — replaced with a
+  string-aware scanner now shared with doctor (one parser, not two);
+  (4) `loadConfig` enforces the `memoryDir` no-escape invariant on
+  hand-edited files, falling back to the default with a warning;
+  (5) `migrate` rewrites `scope`/`visibility` with the key, and
+  conflict resolution compares parsed timestamps (lexicographic
+  RFC-3339 order breaks at fractional seconds); (6) bundle import
+  enforces staging-dir containment (resolve + realpath), rejecting
+  `../` and symlink escapes. Rule going forward: any behavior that can
+  fail must fail loudly in its return value; "already gone" is the only
+  swallowed delete error.
+
 ## Open Questions
 
 _All resolved — see D10 (rename), D11 (type/role split), D12 (explicit pull)._
+- **Checkpoint proactivity for capture (open, 2026-10-02):** D53 retired checkpoint *polling* — the server pushes draft counts instead. But agent proactivity at task checkpoints genuinely helps knowledge capture (§3.5 distillation), so the open question is the degree: proactive enough to catch distillable moments, without nagging the user or burning tokens at every checkpoint. Candidate directions (server-pushed hints in tool results, client-side heuristics, or a middle setting) to be evaluated in a later version; default posture TBD. **Update (2026-10-03): decided in D61 — propose posture** (agent proposes 1–3 candidates at task checkpoints, saves only on approval; auto-draft deferred until memory visibility ships, see the MEMORY_VISIBILITY question below).
 
-- **Checkpoint proactivity for capture (open, 2026-10-02):** D53 retired checkpoint *polling* — the server pushes draft counts instead. But agent proactivity at task checkpoints genuinely helps knowledge capture (§3.5 distillation), so the open question is the degree: proactive enough to catch distillable moments, without nagging the user or burning tokens at every checkpoint. Candidate directions (server-pushed hints in tool results, client-side heuristics, or a middle setting) to be evaluated in a later version; default posture TBD.
-
-- **Retrieval robustness: phrasing, synonyms, extra words (open, 2026-10-03):** keyword search matches word forms, not meaning — the asker phrases it differently, adds a word, or uses a synonym and the memory is missed. The current FTS5 setup (porter stemming + pre-tokenized CJK bigrams) already covers morphology and substrings; it cannot bridge semantics. Layered candidate directions, cheapest first: (1) query construction — never feed a raw sentence to FTS; extract content terms, drop stopwords, OR them and let bm25 rank, so extra words hurt ranking instead of killing the match; (2) agent-side query expansion as an explicit protocol in the skill/instructions (decompose the question into concepts, generate 2–3 synonym variants per concept, run several searches before giving up — the LLM is the synonym dictionary, no embedding model needed); (3) capture-time aliasing — when a memory is written, the agent attaches keyword/synonym aliases so future phrasings can hit it. Embeddings are the design's reserved optional capability: real semantic matching, but they require a design decision and a local model to distribute, so they stay deferred unless (1)–(3) prove insufficient. Note (3) pairs naturally with the proactive-capture question below: the same capture pass that proposes a memory can attach its aliases. **Status (2026-10-03): layer (1) shipped (D56, 0.6.1)** — query construction now filters EN/CJK function words, dedupes, and caps terms. Layers (2) agent-side expansion and (3) capture-time aliasing remain open; embeddings stay deferred.
+- **Retrieval robustness: phrasing, synonyms, extra words (open, 2026-10-03):** keyword search matches word forms, not meaning — the asker phrases it differently, adds a word, or uses a synonym and the memory is missed. The current FTS5 setup (porter stemming + pre-tokenized CJK bigrams) already covers morphology and substrings; it cannot bridge semantics. Layered candidate directions, cheapest first: (1) query construction — never feed a raw sentence to FTS; extract content terms, drop stopwords, OR them and let bm25 rank, so extra words hurt ranking instead of killing the match; (2) agent-side query expansion as an explicit protocol in the skill/instructions (decompose the question into concepts, generate 2–3 synonym variants per concept, run several searches before giving up — the LLM is the synonym dictionary, no embedding model needed); (3) capture-time aliasing — when a memory is written, the agent attaches keyword/synonym aliases so future phrasings can hit it. Embeddings are the design's reserved optional capability: real semantic matching, but they require a design decision and a local model to distribute, so they stay deferred unless (1)–(3) prove insufficient. Note (3) pairs naturally with the proactive-capture question below: the same capture pass that proposes a memory can attach its aliases. **Status (2026-10-03): layer (1) shipped (D56, 0.6.1)** — query construction now filters EN/CJK function words, dedupes, and caps terms. Layers (2) agent-side expansion and (3) capture-time aliasing remain open; embeddings stay deferred. **Update (2026-10-03): layers (2) and (3) shipped in D61** — agent-side expansion as guidance text on every surface, capture-time aliases indexed in their own FTS column behind the `captureAliases` flag. Embeddings stay deferred.
 
 - **Proactive capture: agent judgment of what is worth remembering (open, 2026-10-03):** companion to the checkpoint-proactivity question above — that one asks *when* to prompt; this one asks *what qualifies*. Agent hosts with good long-term memory (e.g. Muse) get their results from explicit memorability criteria plus checkpoint consolidation, not from silent background magic; open-memex can adopt both halves. Candidate criteria to teach via the skill/instructions: decisions **and their rationale**, preferences, conventions, gotchas, and abandoned paths ("we tried X, it failed because…") are worth proposing; one-off task details and anything re-derivable from the code are not. Two postures to evaluate: propose-at-checkpoint (agent asks "worth saving?", user vetoes, then `memory_add`) versus auto-draft (agent writes outbox drafts unasked and surfaces them in a batch at the next checkpoint — drafts are git-invisible and deletable, so the cost of a wrong guess is low). Hard boundaries either way: project scope never auto-submits, and no cross-session background consolidation is possible — the plugin lives inside sessions, so consolidation happens at in-session checkpoints and wrap-up passes only. This question also decides how much aliasing (retrieval question above) the capture pass should generate.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.7.0-alpha.2",
+  "version": "0.7.0-alpha.4",
   "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/smoke-pure.ts

@@ -12,6 +12,42 @@ import { contentHash, similarity, NEAR_DUP_THRESHOLD } from "../src/store/lifecy
 import { userMcpConfigPath, mergeServerEntry, detectInstalledClients, mergePluginEntry, mergeV2PluginEntry, removeV2PluginEntry, opencodeGlobalConfigPath, printManualEntryHint, parseJsonConfig, removeServerEntry, removePluginEntry, removeInstructionsSection, LEGACY_PACKAGE_NAME, shouldInstallSkill } from "../src/init.ts";
 import { z } from "zod";
 import { memoryAddArgs } from "../src/tools/ops.ts";
+import { dataRootPath, homeOverride } from "../src/paths.ts";
+import { configFilePath, loadConfig, stripJsonComments } from "../src/config.ts";
+
+console.log("== jsonc parsing + config invariants (P0) ==");
+{
+  // The pre-fix regex stripper ate "src/**/secrets" as a block comment,
+  // silently disabling the user's redact rule.
+  const doc = JSON.parse(stripJsonComments(`{
+    // a line comment with a "quote
+    "redactPatterns": ["src/**/secrets", "a /* not a comment */ b"],
+    /* a real block comment */
+    "memoryDir": ".ai/open-memex",
+  }`)) as { redactPatterns: string[] };
+  ok("redact pattern with ** survives comment stripping",
+    doc.redactPatterns[0] === "src/**/secrets" && doc.redactPatterns[1] === "a /* not a comment */ b",
+    JSON.stringify(doc.redactPatterns));
+}
+{
+  // loadConfig must enforce the memoryDir invariant on hand-edited files.
+  const saved = process.env.OPEN_MEMEX_CONFIG;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "om-cfg-"));
+  const file = path.join(dir, "c.jsonc");
+  fs.writeFileSync(file, JSON.stringify({ memoryDir: "../../shared" }));
+  const errs: unknown[] = [];
+  const origErr = console.error;
+  console.error = (...a: unknown[]) => errs.push(a);
+  try {
+    process.env.OPEN_MEMEX_CONFIG = file;
+    ok("escaping memoryDir falls back to default", loadConfig().memoryDir === ".ai/open-memex");
+  } finally {
+    console.error = origErr;
+    if (saved === undefined) delete process.env.OPEN_MEMEX_CONFIG;
+    else process.env.OPEN_MEMEX_CONFIG = saved;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
 
 let fails = 0;
 function ok(name: string, cond: boolean, info?: unknown) {
@@ -423,6 +459,38 @@ ok("failed backup leaves legacy dir for retry", fs.existsSync(legacyRoot2));
 delete process.env.MY_O_MEMORY_HOME;
 fs.rmSync(tmpHome, { recursive: true, force: true });
 
+console.log("== env var names (D62) ==");
+{
+  const saved = {
+    n: process.env.OPEN_MEMEX_HOME,
+    l: process.env.MY_O_MEMORY_HOME,
+    nc: process.env.OPEN_MEMEX_CONFIG,
+    lc: process.env.MY_O_MEMORY_CONFIG,
+  };
+  const restore = () => {
+    const set = (k: string, v: string | undefined) => (v === undefined ? delete process.env[k] : (process.env[k] = v));
+    set("OPEN_MEMEX_HOME", saved.n);
+    set("MY_O_MEMORY_HOME", saved.l);
+    set("OPEN_MEMEX_CONFIG", saved.nc);
+    set("MY_O_MEMORY_CONFIG", saved.lc);
+  };
+  try {
+    delete process.env.OPEN_MEMEX_HOME;
+    delete process.env.MY_O_MEMORY_HOME;
+    ok("no override -> homeOverride null", homeOverride() === null);
+    process.env.MY_O_MEMORY_HOME = "/tmp/legacy-home";
+    ok("legacy fallback honored", dataRootPath().endsWith("legacy-home") && homeOverride()?.via === "MY_O_MEMORY_HOME");
+    process.env.OPEN_MEMEX_HOME = "/tmp/new-home";
+    ok("new name wins over legacy", dataRootPath().endsWith("new-home") && homeOverride()?.via === "OPEN_MEMEX_HOME");
+    process.env.MY_O_MEMORY_CONFIG = "/tmp/legacy.jsonc";
+    ok("config legacy fallback", configFilePath().endsWith("legacy.jsonc"));
+    process.env.OPEN_MEMEX_CONFIG = "/tmp/new.jsonc";
+    ok("config new name wins", configFilePath().endsWith("new.jsonc"));
+  } finally {
+    restore();
+  }
+}
+
 console.log("== lifecycle pure: contentHash / similarity ==");
 ok("hash deterministic + whitespace-insensitive", contentHash("hello   world\n") === contentHash("hello world"));
 ok("hash differs on content", contentHash("hello world") !== contentHash("hello mars"));

package/scripts/test-full.ts

@@ -176,6 +176,40 @@ ok("forget deletes", r.code === 0 && /delet/i.test(r.out), r.out.slice(0, 120));
 r = cli(["list"], PROJ);
 ok("forgotten id gone from list", !r.out.includes(idDecision));
 
+// P0: forget must not report success when the file cannot be deleted —
+// the file is the source of truth and would be re-indexed on next sync.
+// (Simulated by putting a directory where the file belongs: unlink fails
+// with EISDIR even for root, unlike permission bits.)
+{
+  const idF = addMem(["fulltest forget failure"], PROJ);
+  const memRoot = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories");
+  let memFile = "";
+  const findFile = (d: string) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p2 = path.join(d, e.name);
+      if (e.isDirectory()) findFile(p2);
+      else if (e.name === idF + ".md") memFile = p2;
+    }
+  };
+  findFile(memRoot);
+  ok("forget-failure setup found the file", !!memFile);
+  const backup = fs.readFileSync(memFile, "utf8");
+  fs.rmSync(memFile);
+  fs.mkdirSync(memFile);
+  try {
+    r = cli(["forget", idF], PROJ);
+    ok("forget reports failure when unlink fails",
+      r.code !== 0 && /could not delete/i.test(r.err + r.out),
+      (r.err || r.out).slice(0, 150));
+  } finally {
+    fs.rmSync(memFile, { recursive: true });
+    fs.writeFileSync(memFile, backup);
+  }
+  r = cli(["list"], PROJ);
+  ok("memory survives failed forget", r.out.includes(idF), r.out.slice(0, 150));
+  r = cli(["forget", idF], PROJ);
+  ok("forget succeeds once the file is deletable again", r.code === 0, (r.err || r.out).slice(0, 150));
+}
 // ---------- 4. propose / submit / promote / sync-status ----------
 console.log("== review workflow: propose / submit / promote ==");
 const idProp = addMem(["fulltest proposal candidate", "--scope", "personal"], PROJ);
@@ -231,6 +265,26 @@ const cfile = path.join(T, "conflict.tar.gz");
 execFileSync("tar", ["-czf", cfile, "-C", cstage, "manifest.json", "memories"], { env: TESTENV });
 r = cli2Retry(["import", cfile], PROJ2);
 ok("import conflict reported, never overwritten", /conflict/.test(r.out) && /imported 0/.test(r.out), r.out.slice(0, 160));
+// P0: a bundle manifest pointing outside the bundle must be rejected —
+// it otherwise imports arbitrary local .md files into the store. The
+// secret is planted next to the import staging dir (os.tmpdir()), which
+// is where "../" from a manifest entry lands.
+{
+  const secretName = `outside-secret-${process.pid}.md`;
+  const secretFile = path.join(os.tmpdir(), secretName);
+  const secretId = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
+  fs.writeFileSync(secretFile, `---\nid: ${secretId}\nscope: personal\nscope_key: personal\nvisibility: private\ntype: fact\nstatus: active\ncreated_at: 2026-01-01T00:00:00Z\nupdated_at: 2026-01-01T00:00:00Z\n---\n\nfulltest traversal secret\n`);
+  const tstage = path.join(T, "tstage");
+  fs.mkdirSync(tstage, { recursive: true });
+  fs.writeFileSync(path.join(tstage, "manifest.json"), JSON.stringify({ format: "open-memex-export/1", exported_at: "2026-01-01T00:00:00Z", open_memex_version: "t", include_private: true, filters: {}, memories: [{ id: secretId, scope: "personal", file: `../${secretName}` }] }));
+  const tfile = path.join(T, "traversal.tar.gz");
+  execFileSync("tar", ["-czf", tfile, "-C", tstage, "manifest.json"], { env: TESTENV });
+  r = cli2Retry(["import", tfile], PROJ2);
+  ok("import rejects path outside bundle", /imported 0/.test(r.out) && /rejected/.test(r.out), r.out.slice(0, 160));
+  r = cli2(["search", "traversal", "--scope", "personal"], PROJ2);
+  ok("traversed file never landed in store", !/traversal secret/.test(r.out), r.out.slice(0, 160));
+  fs.rmSync(secretFile, { force: true });
+}
 
 // ---------- 6. distill-agents ----------
 console.log("== distill-agents ==");
@@ -279,6 +333,24 @@ try { dbOk = fs.existsSync(dbPath) && fs.statSync(dbPath).mtimeMs >= beforeReind
 ok("reindex rebuilds", dbOk, `db exists: ${fs.existsSync(dbPath)}`);
 r = cli(["list", "--scope", "personal"], PROJ);
 ok("list works after reindex", r.out.includes(idMig) || r.out.includes(idPersonal));
+// P0: a real migrate must re-scope the file, not just re-key it — a
+// personal memory migrated to the project key must become submittable
+// project memory (scope: project in its frontmatter).
+r = cli(["migrate", "--from", "personal", "--to", "project"], PROJ);
+ok("migrate personal→project runs", r.code === 0, (r.err || r.out).slice(0, 150));
+{
+  const memRoot = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories");
+  let moved = "";
+  const walk = (d: string) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name === idMig + ".md") moved = fs.readFileSync(p, "utf8");
+    }
+  };
+  walk(memRoot);
+  ok("migrated file is now scope: project", /^scope: project$/m.test(moved), moved.slice(0, 200));
+}
 
 // ---------- 9. capture / doctor / mcp --print-config / init ----------
 console.log("== capture / doctor / mcp / init ==");
@@ -290,6 +362,17 @@ for (const c of ["vscode", "cursor", "claude", "opencode", "visualstudio"]) {
 }
 r = cli(["init", "--client", "vscode", "--yes"], PROJ);
 ok("init --client vscode --yes", r.code === 0 && fs.existsSync(path.join(PROJ, ".vscode", "mcp.json")), (r.err || r.out).slice(0, 150));
+// P0: VS init must merge into an existing .mcp.json, not replace it —
+// the parsed doc used to be dropped, wiping other MCP servers.
+{
+  const mcpFile = path.join(PROJ, ".mcp.json");
+  fs.writeFileSync(mcpFile, JSON.stringify({ servers: { "other-server": { type: "stdio", command: "other" } } }));
+  r = cli(["init", "--client", "visualstudio", "--yes"], PROJ);
+  const after = JSON.parse(fs.readFileSync(mcpFile, "utf8")) as { servers?: Record<string, unknown> };
+  ok("VS init preserves other servers in .mcp.json",
+    r.code === 0 && !!after.servers?.["other-server"] && !!after.servers?.["open-memex"],
+    JSON.stringify(after).slice(0, 160));
+}
 r = cliRetry(["doctor"], PROJ);
 ok("doctor", r.code === 0 && /All checks passed/.test(r.out), (r.err || r.out).slice(0, 200));
 

package/src/cli.ts

@@ -1059,11 +1059,17 @@ async function main() {
       process.exit(1);
     }
     // Delete by indexed file_path — location-agnostic (appdata or in-repo, 2B/D24).
+    // Only ENOENT = success; anything else means the file survives and
+    // would be re-indexed — fail loudly (P0 review, 2026-10-03).
     if (row.file_path) {
       try {
         fs.unlinkSync(row.file_path);
-      } catch {
-        /* already gone */
+      } catch (e) {
+        const code = (e as NodeJS.ErrnoException).code;
+        if (code !== "ENOENT") {
+          console.error(`could not delete ${row.file_path} (${code ?? "error"}) — memory not forgotten`);
+          process.exit(1);
+        }
       }
     }
     deleteFromIndex(id);
@@ -1281,6 +1287,9 @@ function positionalArgs(argv: string[]): string[] {
       console.log(
         `${dryRun ? "DRY RUN: " : ""}imported ${r.imported}, skipped ${r.skippedIdentical} identical`,
       );
+      for (const rp of r.rejectedPaths) {
+        console.log(`  rejected: ${rp} (path outside the bundle)`);
+      }
       for (const c of r.skippedConflict) {
         console.log(`  conflict (kept existing): ${c.id} from ${c.file}`);
       }

package/src/config.ts

@@ -74,19 +74,68 @@ export const DEFAULT_CONFIG: MyOMemoryConfig = {
   sync: { autoPull: false },
 };
 
-function stripJsonComments(raw: string): string {
-  // Line comments
-  let out = raw.replace(/^\s*\/\/.*$/gm, "");
-  // Block comments (non-greedy)
-  out = out.replace(/\/\*[\s\S]*?\*\//g, "");
-  // Trailing commas before closing brackets
-  out = out.replace(/,(\s*[}\]])/g, "$1");
+/**
+ * Strip JSONC comments and trailing commas with a string-aware scanner.
+ * The previous regex version was not string-aware: a config value like
+ * "src/**\/secrets" had its `/**…*\/` eaten as a block comment, silently
+ * corrupting the user's redact pattern (P0 review, 2026-10-03). Shared
+ * with doctor.ts — one parser, not two.
+ */
+export function stripJsonComments(raw: string): string {
+  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;
+    }
+    if (c === ",") {
+      // Trailing comma: drop it when the next significant char closes a
+      // container. Whitespace/comments between are tolerated.
+      let j = i + 1;
+      while (j < raw.length && /\s/.test(raw[j]!)) j++;
+      if (raw[j] === "}" || raw[j] === "]") {
+        i++;
+        continue;
+      }
+    }
+    out += c;
+    i++;
+  }
   return out;
 }
 
-/** Where `config set` / interactive `init` persist. Respects MY_O_MEMORY_CONFIG. */
+/**
+ * Where `config set` / interactive `init` persist. Respects OPEN_MEMEX_CONFIG
+ * (D62); MY_O_MEMORY_CONFIG is the pre-rename fallback, still honored.
+ */
 export function configFilePath(): string {
   return (
+    process.env.OPEN_MEMEX_CONFIG ??
     process.env.MY_O_MEMORY_CONFIG ??
     path.join(os.homedir(), ".config", "opencode", "open-memex.jsonc")
   );
@@ -156,6 +205,7 @@ export function saveConfig(patch: Record<string, unknown>): string {
 /** Path of the config file in effect, or null when using built-in defaults. */
 export function configSource(): string | null {
   const candidates = [
+    process.env.OPEN_MEMEX_CONFIG,
     process.env.MY_O_MEMORY_CONFIG,
     path.join(os.homedir(), ".config", "opencode", "open-memex.jsonc"),
     path.join(os.homedir(), ".config", "opencode", "open-memex.json"),
@@ -172,7 +222,20 @@ export function loadConfig(): MyOMemoryConfig {
     try {
       const raw = fs.readFileSync(p, "utf8");
       const parsed = JSON.parse(stripJsonComments(raw)) as Partial<MyOMemoryConfig>;
-      return { ...DEFAULT_CONFIG, ...parsed };
+      const merged = { ...DEFAULT_CONFIG, ...parsed };
+      // The config file is hand-editable, so the load path must enforce
+      // the same invariants `config set` does (P0 review, 2026-10-03):
+      // an unvalidated memoryDir like "../../shared" would put
+      // committed project memories outside the repo.
+      try {
+        merged.memoryDir = toRelativeDir(merged.memoryDir);
+      } catch {
+        console.error(
+          `[open-memex] invalid memoryDir "${merged.memoryDir}" in ${p} — using default "${DEFAULT_CONFIG.memoryDir}"`,
+        );
+        merged.memoryDir = DEFAULT_CONFIG.memoryDir;
+      }
+      return merged;
     } catch (err) {
       console.error(`[open-memex] failed to parse ${p}:`, err);
     }

package/src/doctor.ts

@@ -7,8 +7,8 @@ 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.ts";
-import { paths } from "./paths.ts";
+import { loadConfig, configSource, DEFAULT_CONFIG, stripJsonComments } from "./config.ts";
+import { paths, homeOverride } from "./paths.ts";
 import { resolveCwdScope } from "./scope.ts";
 import { db, backendName } from "./store/db.ts";
 import { LEGACY_PACKAGE_NAME, opencodeGlobalConfigPath, userMcpConfigPath } from "./init.ts";
@@ -66,7 +66,14 @@ function storageCheck(): Check {
   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) };
   }
@@ -422,49 +429,15 @@ function mcpCheck(): Promise<Check> {
 }
 
 /** 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: string): Record<string, unknown> {
   try {
     return JSON.parse(raw) as Record<string, unknown>;
   } 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) as Record<string, unknown>;
+  return JSON.parse(stripJsonComments(raw)) as Record<string, unknown>;
 }
 
 function vscodeSettingsPath(): string | null {
@@ -579,10 +552,12 @@ export async function runDoctor(): Promise<boolean> {
 function legacyCheck(): Check {
   const name = "legacy my-o-memory";
   const found: string[] = [];
-  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\``,
+      `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);

package/src/export.ts

@@ -152,6 +152,8 @@ export interface ImportResult {
   imported: number;
   skippedIdentical: number;
   skippedConflict: { id: string; file: string }[];
+  /** Manifest entries refused for pointing outside the bundle. */
+  rejectedPaths: string[];
 }
 
 export function importBundle(bundlePath: string, opts: ImportOptions): ImportResult {
@@ -172,10 +174,20 @@ export function importBundle(bundlePath: string, opts: ImportOptions): ImportRes
       fail(`unsupported bundle format: ${manifest.format} (expected ${EXPORT_FORMAT})`);
     }
 
-    const result: ImportResult = { imported: 0, skippedIdentical: 0, skippedConflict: [] };
+    const result: ImportResult = { 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;
       const fm = normalizeFrontmatter({ ...mf.fm } as unknown as Record<string, unknown>);

package/src/init.ts

@@ -508,6 +508,7 @@ function writeVisualStudioMcpJson(root: string, force: boolean): string | null {
       });
       return null;
     }
+    doc = parsed;
   }
   const section = ((doc["servers"] ??= {}) as Record<string, unknown>);
   // F30: drop the pre-rename server entry — it points at the OLD data dir.

package/src/paths.ts

@@ -3,8 +3,23 @@ import fs from "node:fs";
 import os from "node:os";
 import { execFileSync } from "node:child_process";
 
+/**
+ * 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(): { dir: string; via: "OPEN_MEMEX_HOME" | "MY_O_MEMORY_HOME" } | null {
+  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 { dir: path.resolve(process.env.MY_O_MEMORY_HOME), via: "MY_O_MEMORY_HOME" };
+  return null;
+}
+
 function dataRoot(): string {
-  if (process.env.MY_O_MEMORY_HOME) return path.resolve(process.env.MY_O_MEMORY_HOME);
+  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");

package/src/store/migrate.ts

@@ -6,9 +6,11 @@ import {
   iterMemoryFiles,
   readMemoryFile,
   serialize,
+  timeToMs,
   type Frontmatter,
 } from "./markdown.ts";
 import { syncScope } from "./sync.ts";
+import { PERSONAL_SCOPE } from "../scope.ts";
 
 export type ConflictStrategy = "newer" | "overwrite" | "skip";
 
@@ -90,7 +92,10 @@ export function migrateScope(
         log(`conflict: kept destination (--on-conflict=skip): ${dstPath}`);
       } else if (strategy === "overwrite") {
         log(`conflict: overwriting destination (--on-conflict=overwrite): ${dstPath}`);
-      } else if (dst.fm.updated_at >= mf.fm.updated_at) {
+      } else if (timeToMs(dst.fm.updated_at) >= timeToMs(mf.fm.updated_at)) {
+        // Compare parsed instants, not RFC-3339 strings: lexicographic
+        // order breaks around fractional seconds ("…:00Z" > "…:00.005Z"),
+        // letting the older file win.
         action = "skip";
         log(`conflict: kept destination (newer updated_at): ${dstPath}`);
       } else {
@@ -103,9 +108,16 @@ export function migrateScope(
       continue;
     }
 
+    // Re-key AND re-scope: scope/visibility must follow the destination
+    // (P0 review, 2026-10-03). Rewriting only scope_key produced files
+    // submit rejects ("scope is personal") or personal memories carrying
+    // visibility: internal into exports.
+    const toPersonal = toKey === PERSONAL_SCOPE.key;
     const newFm: Frontmatter = {
       ...mf.fm,
       scope_key: toKey,
+      scope: toPersonal ? "personal" : "project",
+      visibility: toPersonal ? "private" : "internal",
       project_name: opts.toProjectName ?? mf.fm.project_name,
     };
     const raw = serialize(newFm, mf.body);

package/src/tools/ops.ts

@@ -388,11 +388,20 @@ export async function forgetMemory(args: MemoryForgetArgs): Promise<ToolResult>
     return { title: "memory: not found", output: `No memory with id ${args.id}.` };
   }
   // Delete by indexed file_path — location-agnostic (appdata or in-repo, 2B/D24).
+  // Only ENOENT counts as "deleted": on any other unlink failure the file
+  // is still the source of truth and would be re-indexed on next sync, so
+  // report failure instead of lying (P0 review, 2026-10-03).
   if (row.file_path) {
     try {
       fs.unlinkSync(row.file_path);
-    } catch {
-      /* already gone */
+    } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT") {
+        return {
+          title: "memory: forget failed",
+          output: `Could not delete ${row.file_path} (${code ?? "error"}) — the memory was NOT forgotten and is still in the index. Close anything holding the file and retry.`,
+        };
+      }
     }
   }
   deleteFromIndex(args.id);