@polderlabs/bizar 4.2.0 → 4.2.2

package/bizar-dash/tests/memory-path-safety.test.mjs

@@ -0,0 +1,427 @@
+/**
+ * tests/memory-path-safety.test.mjs
+ *
+ * Tests for path traversal and injection attacks against resolveSafe() and
+ * the writeNote / readNote / deleteNote surface.
+ *
+ * Gap closed: memory-system-map §8.2 HIGH gap #9 "Path traversal safety" and
+ * §9 Layer 1 "resolveSafe() path traversal — ../, null bytes, absolute paths,
+ * symlink escapes".
+ *
+ * Each attack vector is tested against writeNote (should throw), readNote
+ * (should return null), and deleteNote (should return false).
+ *
+ * NOTE: If any of these paths are NOT rejected by the current implementation,
+ * that IS a finding — document it here (do NOT fix it; the test documents
+ * expected behaviour vs actual behaviour).
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, symlinkSync, writeFileSync, readFileSync, existsSync, lstatSync } from 'node:fs';
+
+const TEST_MEMORY_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
+
+const uid = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+/** Returns a valid minimal note for passing schema validation. */
+function validNote(overrides = {}) {
+  return {
+    frontmatter: {
+      memory_id: `path-safety-${uid().slice(0, 8)}`,
+      type: 'session_summary',
+      project_id: 'path-safety-test',
+      status: 'active',
+      confidence: 'verified',
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      tags: [],
+      title: 'Path safety test',
+      ...overrides.frontmatter,
+    },
+    body: 'path safety body content',
+  };
+}
+
+describe('memory-path-safety: resolveSafe() via writeNote', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `path-safety-${uid()}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'path-safety-test',
+      memoryRepo: {
+        mode: 'local-only',
+        path: join(projectRoot, '.obsidian'),
+        remote: null,
+        branch: 'main',
+        namespace: null,
+      },
+      namespaces: {
+        project: 'projects/path-safety-test',
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(path-safety): {summary}' },
+    });
+    TEST_MEMORY_STORE.initVault(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  // Each entry: path, whether resolveSafe rejects it (true=rejected/throws),
+  // and a note explaining the finding if it's not rejected as expected.
+  const attackPaths = [
+    {
+      label: '../../../etc/passwd',
+      path: '../../../etc/passwd',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: '/etc/passwd (absolute)',
+      path: '/etc/passwd',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: 'notes/../escape.md (mid-path dotdot — now rejected by segment check)',
+      path: 'notes/../escape.md',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: 'notes\\x00null.md (null byte — correctly rejected)',
+      path: 'notes\x00null.md',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: 'notes/../../global/bizar/secret.md (cross-namespace)',
+      path: 'notes/../../global/bizar/secret.md',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: '../projects/other/escape.md',
+      path: '../projects/other/escape.md',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: '..\\..\\etc\\passwd (backslash variant)',
+      path: '..\\..\\etc\\passwd',
+      shouldReject: true,
+      finding: null,
+    },
+    {
+      label: 'global/../../etc/passwd',
+      path: 'global/../../etc/passwd',
+      shouldReject: true,
+      finding: null,
+    },
+  ];
+
+  for (const { label, path, shouldReject, finding } of attackPaths) {
+    if (shouldReject) {
+      it(`writeNote REJECTS: ${label}`, () => {
+        assert.throws(
+          () => TEST_MEMORY_STORE.writeNote(projectRoot, path, validNote()),
+          /Invalid note path/i,
+          `[${label}] writeNote should throw for path: ${path}`,
+        );
+      });
+    } else {
+      // Document the finding: path is NOT rejected
+      it(`FINDING — writeNote ACCEPTS: ${label}`, () => {
+        let thrown = false;
+        let result;
+        try {
+          result = TEST_MEMORY_STORE.writeNote(projectRoot, path, validNote());
+        } catch (e) {
+          thrown = true;
+        }
+        // This documents the ACTUAL behaviour (not the desired behaviour)
+        assert.strictEqual(
+          thrown,
+          false,
+          `[FINDING] ${label}: path was unexpectedly rejected. Update this test if the behaviour changes.`,
+        );
+        assert.ok(
+          result?.relPath,
+          `[FINDING] ${label}: writeNote accepted this path; relPath=${result?.relPath}. ${finding}`,
+        );
+      });
+    }
+  }
+});
+
+describe('memory-path-safety: resolveSafe() via readNote', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `path-safety-read-${uid()}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'path-safety-test',
+      memoryRepo: {
+        mode: 'local-only',
+        path: join(projectRoot, '.obsidian'),
+        remote: null,
+        branch: 'main',
+        namespace: null,
+      },
+      namespaces: {
+        project: 'projects/path-safety-test',
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(path-safety): {summary}' },
+    });
+    TEST_MEMORY_STORE.initVault(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  const attackPaths = [
+    { label: '../etc/passwd', path: '../../../etc/passwd' },
+    { label: '/etc/passwd absolute', path: '/etc/passwd' },
+    { label: 'notes/../escape.md', path: 'notes/../escape.md' },
+    { label: 'null byte injection', path: 'notes\x00null.md' },
+    { label: 'cross-namespace escape', path: 'notes/../../global/bizar/secret.md' },
+  ];
+
+  for (const { label, path } of attackPaths) {
+    it(`readNote returns null for: ${label}`, () => {
+      const result = TEST_MEMORY_STORE.readNote(projectRoot, path);
+      assert.strictEqual(result, null, `[${label}] readNote should return null for path: ${path}`);
+    });
+  }
+});
+
+describe('memory-path-safety: resolveSafe() via deleteNote', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `path-safety-del-${uid()}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'path-safety-test',
+      memoryRepo: {
+        mode: 'local-only',
+        path: join(projectRoot, '.obsidian'),
+        remote: null,
+        branch: 'main',
+        namespace: null,
+      },
+      namespaces: {
+        project: 'projects/path-safety-test',
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(path-safety): {summary}' },
+    });
+    TEST_MEMORY_STORE.initVault(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  const attackPaths = [
+    { label: '../etc/passwd', path: '../../../etc/passwd' },
+    { label: '/etc/passwd absolute', path: '/etc/passwd' },
+    { label: 'notes/../escape.md', path: 'notes/../escape.md' },
+    { label: 'null byte injection', path: 'notes\x00null.md' },
+    { label: 'cross-namespace escape', path: 'notes/../../global/bizar/secret.md' },
+  ];
+
+  for (const { label, path } of attackPaths) {
+    it(`deleteNote returns false for: ${label}`, () => {
+      const result = TEST_MEMORY_STORE.deleteNote(projectRoot, path);
+      assert.strictEqual(result, false, `[${label}] deleteNote should return false for path: ${path}`);
+    });
+  }
+});
+
+describe('memory-path-safety: symlink traversal', () => {
+  let projectRoot;
+  let vaultRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `path-safety-sym-${uid()}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    vaultRoot = join(projectRoot, '.obsidian');
+    mkdirSync(vaultRoot, { recursive: true });
+
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'path-safety-test',
+      memoryRepo: {
+        mode: 'local-only',
+        path: vaultRoot,
+        remote: null,
+        branch: 'main',
+        namespace: null,
+      },
+      namespaces: {
+        project: 'projects/path-safety-test',
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(path-safety): {summary}' },
+    });
+    TEST_MEMORY_STORE.initVault(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    try { rmSync(join(tmpdir(), `symlink-outside-${uid().slice(0, 8)}.md`), { force: true }); } catch { /* ignore */ }
+  });
+
+  it('REGRESSION: symlink inside vault pointing to outside file — writeNote now REJECTS (symlink guard)', () => {
+    // Symlink guard (Fix 2): resolveSafe() now refuses to write through a
+    // pre-existing symlink inside the vault. The previous behaviour followed
+    // the symlink, allowing the outside file to be overwritten.
+
+    const outsideFile = join(tmpdir(), `symlink-outside-${uid()}.md`);
+    writeFileSync(outsideFile, 'ORIGINAL CONTENT — should not be overwritten', 'utf8');
+
+    const symlinkPath = join(vaultRoot, 'escape-symlink.md');
+    symlinkSync(outsideFile, symlinkPath);
+
+    try {
+      assert.throws(
+        () => TEST_MEMORY_STORE.writeNote(projectRoot, 'escape-symlink.md', validNote()),
+        /Invalid note path/i,
+        'writeNote should refuse to follow a pre-existing symlink',
+      );
+
+      // Verify: the outside file is UNTOUCHED
+      const content = readFileSync(outsideFile, 'utf8');
+      assert.ok(
+        !content.includes('memory_id:'),
+        'Outside file should NOT be overwritten — symlink guard prevented write through symlink',
+      );
+      assert.strictEqual(
+        content,
+        'ORIGINAL CONTENT — should not be overwritten',
+        'Outside file content should be exactly what we wrote',
+      );
+    } finally {
+      try { rmSync(outsideFile, { force: true }); } catch { /* ignore */ }
+      try { rmSync(symlinkPath, { force: true }); } catch { /* ignore */ }
+    }
+  });
+
+  it('REGRESSION: readNote via symlink returns null (symlink guard blocks info disclosure)', () => {
+    // Symlink guard (Fix 2): readNote now refuses to follow a pre-existing
+    // symlink, so the outside file's content is NOT returned.
+
+    const outsideFile = join(tmpdir(), `symlink-read-outside-${uid()}.md`);
+    const secretContent = 'SECRET FROM OUTSIDE THE VAULT — information disclosure';
+    writeFileSync(outsideFile, secretContent, 'utf8');
+
+    const symlinkPath = join(vaultRoot, 'disclose-symlink.md');
+    symlinkSync(outsideFile, symlinkPath);
+
+    try {
+      const result = TEST_MEMORY_STORE.readNote(projectRoot, 'disclose-symlink.md');
+      assert.strictEqual(
+        result,
+        null,
+        'readNote should return null for a symlink path (symlink guard)',
+      );
+    } finally {
+      try { rmSync(outsideFile, { force: true }); } catch { /* ignore */ }
+      try { rmSync(symlinkPath, { force: true }); } catch { /* ignore */ }
+    }
+  });
+
+  it('REGRESSION: filenames containing `..` as a substring (not as a segment) are still accepted', () => {
+    // Fix 3: segment-level check rejects `..` SEGMENTS but allows substrings.
+    // `my..note.md` is a valid filename.
+
+    const note = validNote();
+    const relPath = 'decisions/my..note.md';
+    const result = TEST_MEMORY_STORE.writeNote(projectRoot, relPath, note);
+    assert.strictEqual(result.relPath, relPath, 'filename with `..` substring should be accepted');
+
+    const readBack = TEST_MEMORY_STORE.readNote(projectRoot, relPath);
+    assert.ok(readBack, 'readBack should succeed');
+    assert.strictEqual(readBack.relPath, relPath, 'readBack relPath should match');
+
+    // Cleanup
+    TEST_MEMORY_STORE.deleteNote(projectRoot, relPath);
+  });
+
+  it('REGRESSION: dangling symlink (target does not exist) is also rejected by symlink guard', () => {
+    // The symlink guard must use lstatSync directly — existsSync follows
+    // symlinks and returns false for dangling ones, which would have
+    // bypassed the original guard. This test ensures the dangling case
+    // is covered too.
+
+    const danglingTarget = join(tmpdir(), `dangling-symlink-target-${uid()}.md`);
+    // Do NOT create danglingTarget — it should remain non-existent.
+
+    const symlinkPath = join(vaultRoot, 'dangling-symlink.md');
+    symlinkSync(danglingTarget, symlinkPath);
+
+    try {
+      // Sanity: existsSync says false (follows the symlink), lstatSync says
+      // true (does not follow).
+      assert.strictEqual(
+        existsSync(symlinkPath),
+        false,
+        'precondition: existsSync returns false for dangling symlink',
+      );
+      assert.strictEqual(
+        lstatSync(symlinkPath).isSymbolicLink(),
+        true,
+        'precondition: lstatSync identifies the symlink correctly',
+      );
+
+      assert.throws(
+        () => TEST_MEMORY_STORE.writeNote(projectRoot, 'dangling-symlink.md', validNote()),
+        /Invalid note path/i,
+        'writeNote should refuse dangling symlinks too (uses lstatSync directly)',
+      );
+
+      assert.strictEqual(
+        TEST_MEMORY_STORE.readNote(projectRoot, 'dangling-symlink.md'),
+        null,
+        'readNote should return null for dangling symlinks',
+      );
+
+      assert.strictEqual(
+        TEST_MEMORY_STORE.deleteNote(projectRoot, 'dangling-symlink.md'),
+        false,
+        'deleteNote should refuse dangling symlinks',
+      );
+    } finally {
+      try { rmSync(symlinkPath, { force: true }); } catch { /* ignore */ }
+    }
+  });
+});

package/bizar-dash/tests/memory-roundtrip.test.mjs

@@ -0,0 +1,219 @@
+/**
+ * tests/memory-roundtrip.test.mjs
+ *
+ * Rule #42 end-to-end round-trip test: write → read → search → list → delete.
+ * Runs THREE times:
+ *   Mode A: local-only  (vault in project temp dir)
+ *   Mode B: managed     (vault in temp dir simulating ~/.local/share/bizar/...)
+ *   Mode C: namespace variants (project / global / user)
+ *
+ * Gap closed: memory-system-map §8.1 / §9 Layer-4 "Full write/read/search/delete
+ * round-trip — CLI write → CLI status → CLI search → REST read → DELETE".
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const CLI_BIN = join(dirname(__filename), '..', '..', 'cli', 'bin.mjs');
+
+const TEST_MEMORY_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
+
+/** Unique ID to avoid cross-test pollution */
+const uid = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+/**
+ * Full round-trip test helper.
+ * @param {'local-only'|'managed'} mode
+ * @param {'project'|'global'|'user'} namespace
+ */
+async function runRoundtrip(mode, namespace) {
+  const projectRoot = join(tmpdir(), `roundtrip-${mode}-${namespace}-${uid()}`);
+  mkdirSync(projectRoot, { recursive: true });
+  mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+
+  let vaultRoot;
+  let sharedRepo;
+
+  if (mode === 'local-only') {
+    vaultRoot = join(projectRoot, '.obsidian');
+    mkdirSync(vaultRoot, { recursive: true });
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'roundtrip-test',
+      memoryRepo: {
+        mode: 'local-only',
+        path: vaultRoot,
+        remote: null,
+        branch: 'main',
+        namespace: null,
+      },
+      namespaces: {
+        project: 'projects/roundtrip-test',
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(roundtrip): {summary}' },
+    });
+  } else {
+    // managed mode — vault lives in a shared repo under projects/<id>/
+    sharedRepo = join(tmpdir(), `shared-repo-${uid()}`);
+    mkdirSync(sharedRepo, { recursive: true });
+    // Ensure parent namespace dirs exist
+    mkdirSync(join(sharedRepo, 'projects'), { recursive: true });
+    mkdirSync(join(sharedRepo, 'global', 'bizar'), { recursive: true });
+    mkdirSync(join(sharedRepo, 'users', 'tester'), { recursive: true });
+
+    const nsMap = {
+      project: `projects/roundtrip-test`,
+      global: `global/bizar`,
+      user: `users/tester`,
+    };
+    const ns = nsMap[namespace];
+    const vaultPath = join(sharedRepo, ns);
+
+    TEST_MEMORY_STORE.saveConfig(projectRoot, {
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'roundtrip-test',
+      memoryRepo: {
+        mode: 'managed',
+        path: sharedRepo,
+        remote: null,
+        branch: 'main',
+        namespace: ns,
+      },
+      namespaces: {
+        project: `projects/roundtrip-test`,
+        global: 'global/bizar',
+        user: 'users/tester',
+      },
+      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
+      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(roundtrip): {summary}' },
+    });
+
+    vaultRoot = join(sharedRepo, ns);
+    // Ensure the namespace directory exists (writeNote creates it lazily, but
+    // we can pre-create to avoid mkdir in the writeNote path)
+    mkdirSync(vaultRoot, { recursive: true });
+  }
+
+  const noteRelPath = `${namespace}-roundtrip-${uid().slice(0, 8)}.md`;
+  const note = {
+    frontmatter: {
+      memory_id: `roundtrip_${namespace}_${uid().slice(0, 8)}`,
+      type: 'session_summary',
+      project_id: 'roundtrip-test',
+      status: 'active',
+      confidence: 'verified',
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      tags: ['roundtrip', mode, namespace],
+      title: `Roundtrip test — ${mode} / ${namespace}`,
+    },
+    body: `# Roundtrip Test\n\nMode: ${mode}\nNamespace: ${namespace}\nUnique: ${uid()}\n`,
+  };
+
+  // ── Step 1: writeNote ──────────────────────────────────────────────────────
+  const written = TEST_MEMORY_STORE.writeNote(projectRoot, noteRelPath, note);
+  assert.ok(written, `[${mode}/${namespace}] writeNote should return a result`);
+  assert.strictEqual(written.relPath, noteRelPath, `[${mode}/${namespace}] relPath should match`);
+  assert.strictEqual(written.schemaValid, true, `[${mode}/${namespace}] schemaValid should be true`);
+
+  // ── Step 2: readNote ───────────────────────────────────────────────────────
+  const readBack = TEST_MEMORY_STORE.readNote(projectRoot, noteRelPath);
+  assert.ok(readBack, `[${mode}/${namespace}] readNote should find the note`);
+  assert.strictEqual(readBack.relPath, noteRelPath, `[${mode}/${namespace}] readBack relPath should match`);
+  assert.strictEqual(readBack.frontmatter.type, 'session_summary', `[${mode}/${namespace}] frontmatter.type should match`);
+  assert.ok(readBack.body.includes('Roundtrip Test'), `[${mode}/${namespace}] body should contain expected content`);
+  assert.strictEqual(readBack.schemaValid, true, `[${mode}/${namespace}] readBack.schemaValid should be true`);
+
+  // ── Step 3: searchVault ────────────────────────────────────────────────────
+  const searchResults = TEST_MEMORY_STORE.searchVault(projectRoot, 'Roundtrip Test');
+  const found = searchResults.find((r) => r.relPath === noteRelPath);
+  assert.ok(found, `[${mode}/${namespace}] searchVault should find the note (query: 'Roundtrip Test')`);
+  assert.ok(found.snippet.includes('roundtrip test'), `[${mode}/${namespace}] snippet should contain query term`);
+
+  // ── Step 4: listNotes ──────────────────────────────────────────────────────
+  const allNotes = TEST_MEMORY_STORE.listNotes(projectRoot);
+  assert.ok(allNotes.length >= 1, `[${mode}/${namespace}] listNotes should return at least 1 note`);
+  const listed = allNotes.find((n) => n.relPath === noteRelPath);
+  assert.ok(listed, `[${mode}/${namespace}] listNotes should include the written note`);
+  assert.strictEqual(listed.frontmatter.type, 'session_summary', `[${mode}/${namespace}] listed frontmatter.type should match`);
+
+  // ── Step 5: deleteNote ─────────────────────────────────────────────────────
+  const deleted = TEST_MEMORY_STORE.deleteNote(projectRoot, noteRelPath);
+  assert.strictEqual(deleted, true, `[${mode}/${namespace}] deleteNote should return true`);
+
+  // ── Step 6: assert it's gone ───────────────────────────────────────────────
+  const readAfterDelete = TEST_MEMORY_STORE.readNote(projectRoot, noteRelPath);
+  assert.strictEqual(readAfterDelete, null, `[${mode}/${namespace}] readNote should return null after deletion`);
+
+  // Search should also not find it
+  const searchAfterDelete = TEST_MEMORY_STORE.searchVault(projectRoot, 'Roundtrip Test');
+  const foundAfterDelete = searchAfterDelete.find((r) => r.relPath === noteRelPath);
+  assert.ok(!foundAfterDelete, `[${mode}/${namespace}] searchVault should NOT find deleted note`);
+
+  // Clean up
+  try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  if (sharedRepo) {
+    try { rmSync(sharedRepo, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+
+  return true;
+}
+
+// ── Test suites per mode ───────────────────────────────────────────────────────
+
+describe('memory-roundtrip: local-only mode', () => {
+  it('write → read → search → list → delete', async () => {
+    await runRoundtrip('local-only', 'project');
+  });
+});
+
+describe('memory-roundtrip: managed mode / project namespace', () => {
+  it('write → read → search → list → delete', async () => {
+    await runRoundtrip('managed', 'project');
+  });
+});
+
+describe('memory-roundtrip: managed mode / global namespace', () => {
+  it('write → read → search → list → delete', async () => {
+    await runRoundtrip('managed', 'global');
+  });
+});
+
+describe('memory-roundtrip: managed mode / user namespace', () => {
+  it('write → read → search → list → delete', async () => {
+    await runRoundtrip('managed', 'user');
+  });
+});
+
+// ── Three-run variant for rule #42 documentation ─────────────────────────────
+// This test documents that the round-trip runs three times as required.
+
+describe('memory-roundtrip: rule #42 three-run variant', () => {
+  // This test is a meta-test: it runs the roundtrip three times in sequence
+  // to satisfy AGENTS_SELF_IMPROVEMENT rule #42 "run it THREE times" requirement.
+  // Each run uses a different mode.
+
+  it('run 1 of 3: local-only mode roundtrip', async () => {
+    await runRoundtrip('local-only', 'project');
+  });
+
+  it('run 2 of 3: managed project namespace roundtrip', async () => {
+    await runRoundtrip('managed', 'project');
+  });
+
+  it('run 3 of 3: managed global namespace roundtrip', async () => {
+    await runRoundtrip('managed', 'global');
+  });
+});