@polderlabs/bizar 4.2.0 → 4.2.2

package/bizar-dash/src/server/memory-git.mjs

@@ -327,3 +327,65 @@ export function lsRemote(repoDir, remoteName, { timeoutMs = 5000 } = {}) {
     return '';
   }
 }
+
+/**
+ * Ensure the current branch tracks `<remote>/<branch>`. Idempotent.
+ *
+ * Some workflows create a managed vault before `origin` exists (or before
+ * the user pushes for the first time). Without an upstream, `git pull`
+ * fails with "There is no tracking information for the current branch."
+ * This helper detects that case and sets the upstream, or returns a
+ * structured result if it can't.
+ *
+ * Behaviour:
+ *   - Upstream already set to <remote>/<branch>  → { ok: true, action: 'unchanged' }
+ *   - Upstream missing                           → set it, return { ok: true, action: 'set' }
+ *   - Upstream set to a DIFFERENT remote/branch  → set it to the requested one,
+ *                                                  return { ok: true, action: 'set' }
+ *   - <remote> does not exist                    → { ok: false, error: 'remote "<remote>" does not exist' }
+ *   - git not installed                          → { ok: false, error: 'git not installed' }
+ *
+ * @param {string} cwd — git working directory
+ * @param {string} branch — local branch name (e.g. 'main')
+ * @param {string} [remote='origin'] — remote name
+ * @returns {{ ok: boolean, action?: 'unchanged'|'set', error?: string }}
+ */
+export function ensureUpstream(cwd, branch, remote = 'origin') {
+  if (!isGitInstalled()) return { ok: false, error: 'git not installed' };
+
+  // Current upstream — empty string means none configured.
+  let current = '';
+  try {
+    current = execFileSync('git', ['rev-parse', '--abbrev-ref', '@{upstream}'], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    // No upstream set — fall through.
+  }
+
+  if (current && current === `${remote}/${branch}`) {
+    return { ok: true, action: 'unchanged' };
+  }
+
+  // Verify the remote exists before trying to set upstream to it.
+  try {
+    execFileSync('git', ['rev-parse', '--verify', remote], {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch {
+    return { ok: false, error: `remote '${remote}' does not exist` };
+  }
+
+  try {
+    execFileSync('git', ['branch', '--set-upstream-to', `${remote}/${branch}`], {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, action: 'set' };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}

package/bizar-dash/src/server/memory-store.mjs

@@ -11,7 +11,7 @@
  * initVault time (F7 invariant).
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, lstatSync, unlinkSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, dirname, relative, resolve as pathResolve, sep } from 'node:path';
 import { homedir } from 'node:os';
@@ -27,15 +27,51 @@ const BIZAR_MEMORY_ROOT = join(HOME, '.local', 'share', 'bizar', 'memory');
 /**
  * Path safety: reject any relPath that would escape the vault root.
  *
+ * Defenses (in order):
+ *   1. Empty / null-byte injection → reject.
+ *   2. Explicit segment check for `..` and absolute path prefixes → reject
+ *      before path.resolve normalizes them away. The check is on SEGMENTS
+ *      (`..` separated by `/` or `\`), so filenames like `my..note.md` are
+ *      still allowed.
+ *   3. Post-resolve check: the resulting absolute path must be inside
+ *      vaultRoot (relative path must not start with `..`).
+ *   4. Symlink guard: if the resolved path is a pre-existing symlink, refuse.
+ *      This blocks an attacker who placed a symlink inside the vault pointing
+ *      outside from writing/reading through it.
+ *
+ * Known limitation: the symlink guard is not TOCTOU-safe. A swap between
+ * lstatSync and the subsequent read/write/delete is still possible. For a
+ * full TOCTOU fix the read/write/delete would need to use O_NOFOLLOW and
+ * operate on an open fd, not a path. This is acceptable for the current
+ * threat model (the vault is a per-user directory, not a multi-tenant FS).
+ *
  * @param {string} vaultRoot
  * @param {string} relPath
  * @returns {string | null} — resolved absolute path, or null if unsafe
  */
 function resolveSafe(vaultRoot, relPath) {
   if (!relPath || relPath.includes('\0')) return null;
+  // Segment-level check: reject any `..` segment or absolute-path prefix
+  // BEFORE path.resolve normalizes them away. This explicitly rejects
+  // paths like `notes/../escape.md`, while still allowing filenames like
+  // `my..note.md` (the substring `..` inside a single segment is fine).
+  const segments = relPath.split(/[\\/]+/);
+  if (segments.includes('..') || segments[0] === '') return null;
   const abs = pathResolve(vaultRoot, relPath);
   const rel = relative(vaultRoot, abs);
   if (rel.startsWith('..') || abs !== pathResolve(abs)) return null;
+  // Symlink guard (see note above re: TOCTOU). Note: existsSync follows
+  // symlinks, so we MUST use lstatSync directly — existsSync + isSymbolicLink
+  // misses dangling symlinks (target doesn't exist). lstatSync returns a
+  // Stats object even for dangling symlinks; catch only unexpected errors
+  // (e.g. EACCES on the parent directory).
+  try {
+    if (lstatSync(abs).isSymbolicLink()) return null;
+  } catch {
+    // Path doesn't exist or parent dir inaccessible — not a symlink,
+    // proceed. (A fresh write won't traverse a symlink because the
+    // symlink itself doesn't exist yet at write time.)
+  }
   return abs;
 }
 
@@ -120,6 +156,31 @@ export function resolveVault(projectRoot) {
   return { mode, projectId, vaultRoot, repoPath, configDir, gitRemote, branch, lightragDir, namespaces };
 }
 
+/**
+ * Resolve the absolute path of a namespace root.
+ *
+ * For `project`, returns vaultRoot (the existing default). For `global` and
+ * `user`, returns `<vaultRoot>/<namespaces.global|user>` in both modes —
+ * `writeNote('global/bizar/foo.md', …)` already places files there in both
+ * local-only and managed mode, so this matches the on-disk layout that
+ * existing callers rely on.
+ *
+ * (Note: an earlier draft distinguished local-only vs managed, putting
+ * global under `<repoPath>/global/bizar` in managed mode. That diverged from
+ * where writeNote actually creates the file, which is always under
+ * vaultRoot. This implementation matches the on-disk reality.)
+ *
+ * @param {{ mode: string, vaultRoot: string, namespaces: object }} vaultInfo
+ * @param {'project'|'global'|'user'} namespace
+ * @returns {string|null} absolute path, or null if the namespace is unknown
+ */
+export function resolveNamespaceRoot(vaultInfo, namespace) {
+  if (namespace === 'project') return vaultInfo.vaultRoot;
+  const ns = vaultInfo.namespaces?.[namespace];
+  if (!ns) return null;
+  return join(vaultInfo.vaultRoot, ns);
+}
+
 /**
  * Initialize the vault for a project. In local-only mode, creates .obsidian/
  * and standard subdirectories. In managed mode, the shared repo is assumed to
@@ -226,15 +287,20 @@ export function initVault(projectRoot) {
  * List all notes in the vault. Returns enriched note metadata.
  *
  * @param {string} projectRoot
- * @param {{ namespace?: string }} [opts]
+ * @param {{ namespace?: string, root?: string }} [opts]
+ *   `namespace`: subdirectory under `root` to walk (e.g. `projects/<id>`).
+ *   `root`:      override the root used as the walking base. Defaults to
+ *                `vaultRoot` from resolveVault. Used by namespace helpers
+ *                in cli/memory.mjs to list global / user notes.
  * @returns {Array<{ relPath: string, mtime: number, size: number, frontmatter: Record<string, unknown>, body: string, schemaValid: boolean }>}
  */
 export function listNotes(projectRoot, opts = {}) {
   const { vaultRoot } = resolveVault(projectRoot);
-  if (!existsSync(vaultRoot)) return [];
+  const root = opts.root || vaultRoot;
+  if (!existsSync(root)) return [];
 
   const namespace = opts.namespace || '';
-  const searchRoot = namespace ? join(vaultRoot, namespace) : vaultRoot;
+  const searchRoot = namespace ? join(root, namespace) : root;
   if (!existsSync(searchRoot)) return [];
 
   const out = [];
@@ -268,11 +334,14 @@ export function listNotes(projectRoot, opts = {}) {
  *
  * @param {string} projectRoot
  * @param {string} relPath
+ * @param {{ root?: string }} [opts]  optional override for the root used by
+ *                                    resolveSafe; defaults to vaultRoot
  * @returns {{ relPath: string, frontmatter: Record<string, unknown>, body: string, raw: string, mtime: number, size: number, schemaValid: boolean } | null}
  */
-export function readNote(projectRoot, relPath) {
-  const { vaultRoot } = resolveVault(projectRoot);
-  const filePath = resolveSafe(vaultRoot, relPath);
+export function readNote(projectRoot, relPath, opts = {}) {
+  const vaultInfo = resolveVault(projectRoot);
+  const root = opts.root || vaultInfo.vaultRoot;
+  const filePath = resolveSafe(root, relPath);
   if (!filePath || !existsSync(filePath)) return null;
   try {
     const raw = readFileSync(filePath, 'utf8');
@@ -378,11 +447,14 @@ export function writeNote(projectRoot, relPath, { frontmatter, body }) {
  *
  * @param {string} projectRoot
  * @param {string} relPath
+ * @param {{ root?: string }} [opts]  optional override for the root used by
+ *                                    resolveSafe; defaults to vaultRoot
  * @returns {boolean}
  */
-export function deleteNote(projectRoot, relPath) {
-  const { vaultRoot } = resolveVault(projectRoot);
-  const filePath = resolveSafe(vaultRoot, relPath);
+export function deleteNote(projectRoot, relPath, opts = {}) {
+  const vaultInfo = resolveVault(projectRoot);
+  const root = opts.root || vaultInfo.vaultRoot;
+  const filePath = resolveSafe(root, relPath);
   if (!filePath || !existsSync(filePath)) return false;
   unlinkSync(filePath);
   return true;

package/bizar-dash/tests/memory-cli-readlistdelete.test.mjs

@@ -0,0 +1,405 @@
+/**
+ * tests/memory-cli-readlistdelete.test.mjs
+ *
+ * Integration tests for the `bizar memory read`, `bizar memory list`, and
+ * `bizar memory delete` CLI subcommands.
+ *
+ * The CLI calls `process.exit(1)` on errors, so we spawn the `bizar` binary
+ * as a subprocess in a temp dir, assert on exit code + stdout/stderr, and
+ * clean up after.
+ *
+ * These tests are designed to pass once Tyr lands the cmdRead / cmdList /
+ * cmdDelete implementations. They validate the expected CLI interface
+ * (exit codes, output shapes, and file-system side-effects) rather than
+ * the internal store API directly.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve path to the `bizar` CLI bin — invoke via `node <absolute path>`
+// so the test does not depend on PATH.
+const CLI_BIN = join(__dirname, '..', '..', 'cli', 'bin.mjs');
+
+/**
+ * Spawn `bizar memory <subcommand> …` in the given cwd and capture exit
+ * code, stdout, and stderr. Returns `{ code, stdout, stderr }`.
+ */
+function runBizarMemory(subcmd, args, cwd) {
+  try {
+    const stdout = execFileSync('node', [CLI_BIN, 'memory', subcmd, ...args], {
+      cwd,
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 15_000,
+    });
+    return { code: 0, stdout, stderr: '' };
+  } catch (err) {
+    return {
+      code: err.status ?? 1,
+      stdout: err.stdout ? err.stdout.toString() : '',
+      stderr: err.stderr ? err.stderr.toString() : (err.message ?? ''),
+    };
+  }
+}
+
+/**
+ * Write a minimal `.bizar/memory.json` for local-only operation.
+ */
+function writeMemoryConfig(cwd, overrides = {}) {
+  const projectId = overrides.projectId ?? `rlt-${Date.now()}`;
+  const config = {
+    version: 1,
+    backend: 'bizar-local',
+    projectId,
+    memoryRepo: {
+      mode: 'local-only',
+      path: join(cwd, '.obsidian'),
+      remote: null,
+      branch: 'main',
+      namespace: null,
+    },
+    namespaces: {
+      project: `projects/${projectId}`,
+      global: 'global/bizar',
+      user: 'users/tester',
+    },
+    lightrag: {
+      enabled: false,
+      host: '127.0.0.1',
+      port: 9621,
+      workingDir: join(cwd, '.bizar', 'lightrag'),
+    },
+    git: {
+      autoPullOnSessionStart: false,
+      autoCommitOnMemoryWrite: false,
+      autoPushOnSessionEnd: false,
+      commitAuthor: 'Bizar Memory <bizar-memory@local>',
+      commitMessageTemplate: `memory(${projectId}): {summary}`,
+    },
+  };
+  mkdirSync(join(cwd, '.bizar'), { recursive: true });
+  writeFileSync(join(cwd, '.bizar', 'memory.json'), JSON.stringify(config, null, 2));
+}
+
+// ─── bizar memory read ────────────────────────────────────────────────────────
+
+describe('bizar memory read', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(
+      tmpdir(),
+      `bizar-memread-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    mkdirSync(join(projectRoot, '.obsidian'), { recursive: true });
+    writeMemoryConfig(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('happy path — prints frontmatter + body to stdout and exits 0', () => {
+    // First write a note via the CLI (validates the full chain)
+    const relPath = 'decisions/0001-read-test.md';
+    const writeRes = runBizarMemory(
+      'write',
+      [
+        relPath,
+        '--type', 'architecture_decision',
+        '--status', 'active',
+        '--confidence', 'verified',
+        '--title', 'Read test note',
+        '--body', '# Read test note\n\nBody content here.',
+      ],
+      projectRoot,
+    );
+    assert.strictEqual(
+      writeRes.code,
+      0,
+      `write failed: ${writeRes.stderr}`,
+    );
+
+    // Now read it back
+    const r = runBizarMemory('read', [relPath], projectRoot);
+    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
+    assert.ok(r.stdout.includes('Body content here.'), 'body should appear in stdout');
+    assert.ok(
+      r.stdout.includes('Read test note') || r.stdout.includes('architecture_decision'),
+      'stdout should include title or type from frontmatter',
+    );
+  });
+
+  test('not found — exits 1 and reports the missing path', () => {
+    const r = runBizarMemory('read', ['does-not-exist.md'], projectRoot);
+    assert.strictEqual(r.code, 1, `expected exit 1, got ${r.code}`);
+    const out = `${r.stdout}\n${r.stderr}`;
+    assert.ok(
+      /not found|does.not.exist|no such file/i.test(out),
+      `expected a "not found" message, got: ${out}`,
+    );
+  });
+});
+
+// ─── bizar memory list ─────────────────────────────────────────────────────────
+
+describe('bizar memory list', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(
+      tmpdir(),
+      `bizar-memlist-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    mkdirSync(join(projectRoot, '.obsidian'), { recursive: true });
+    writeMemoryConfig(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('empty vault — exits 0 and prints nothing (or a zero count)', () => {
+    const r = runBizarMemory('list', [], projectRoot);
+    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
+    // stdout may be empty or show "0 notes" — either is acceptable
+    const out = r.stdout.trim();
+    // If non-empty it should not contain any .md paths
+    if (out.length > 0) {
+      assert.ok(
+        !/\.md/.test(out),
+        `empty vault should not list .md files; got: ${out}`,
+      );
+    }
+  });
+
+  test('with notes — lists all top-level notes', () => {
+    const notes = [
+      'decisions/0001-list-test-a.md',
+      'decisions/0001-list-test-b.md',
+      'decisions/0001-list-test-c.md',
+    ];
+    for (const relPath of notes) {
+      const r = runBizarMemory(
+        'write',
+        [relPath, '--type', 'architecture_decision', '--body', `# ${relPath}`],
+        projectRoot,
+      );
+      assert.strictEqual(r.code, 0, `write failed for ${relPath}: ${r.stderr}`);
+    }
+
+    const listRes = runBizarMemory('list', [], projectRoot);
+    assert.strictEqual(listRes.code, 0, `list failed: ${listRes.stderr}`);
+    for (const relPath of notes) {
+      assert.ok(
+        listRes.stdout.includes(relPath),
+        `list output should contain ${relPath}; got: ${listRes.stdout}`,
+      );
+    }
+  });
+
+  test('with subdir filter — only lists notes under the specified directory', () => {
+    // Write notes in two different directories
+    const decisionsNotes = [
+      'decisions/0001-subdir-test.md',
+      'decisions/0002-subdir-test.md',
+    ];
+    const tasksNotes = ['tasks/0001-subdir-test.md'];
+
+    for (const relPath of [...decisionsNotes, ...tasksNotes]) {
+      const r = runBizarMemory(
+        'write',
+        [relPath, '--type', relPath.startsWith('decisions') ? 'architecture_decision' : 'session_summary', '--body', `# ${relPath}`],
+        projectRoot,
+      );
+      assert.strictEqual(r.code, 0, `write failed for ${relPath}: ${r.stderr}`);
+    }
+
+    // List only decisions/
+    const listRes = runBizarMemory('list', ['decisions/'], projectRoot);
+    assert.strictEqual(listRes.code, 0, `list failed: ${listRes.stderr}`);
+    for (const relPath of decisionsNotes) {
+      assert.ok(
+        listRes.stdout.includes(relPath),
+        `list decisions/ output should contain ${relPath}; got: ${listRes.stdout}`,
+      );
+    }
+    for (const relPath of tasksNotes) {
+      assert.ok(
+        !listRes.stdout.includes(relPath),
+        `list decisions/ output should NOT contain ${relPath}; got: ${listRes.stdout}`,
+      );
+    }
+  });
+});
+
+// ─── bizar memory delete ───────────────────────────────────────────────────────
+
+describe('bizar memory delete', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(
+      tmpdir(),
+      `bizar-memdel-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    mkdirSync(join(projectRoot, '.obsidian'), { recursive: true });
+    writeMemoryConfig(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('happy path — deletes the note and exits 0', () => {
+    const relPath = 'decisions/0001-delete-test.md';
+    // First write
+    const writeRes = runBizarMemory(
+      'write',
+      [relPath, '--type', 'architecture_decision', '--body', '# To be deleted'],
+      projectRoot,
+    );
+    assert.strictEqual(writeRes.code, 0, `write failed: ${writeRes.stderr}`);
+
+    const filePath = join(projectRoot, '.obsidian', relPath);
+    assert.ok(
+      existsSync(filePath),
+      `file should exist before delete: ${filePath}`,
+    );
+
+    // Delete
+    const r = runBizarMemory('delete', [relPath], projectRoot);
+    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
+
+    // File should be gone
+    assert.ok(
+      !existsSync(filePath),
+      `file should NOT exist after delete: ${filePath}`,
+    );
+  });
+
+  test('not found — exits 1 and reports the missing path', () => {
+    const r = runBizarMemory('delete', ['nonexistent-note.md'], projectRoot);
+    assert.strictEqual(r.code, 1, `expected exit 1, got ${r.code}`);
+    const out = `${r.stdout}\n${r.stderr}`;
+    assert.ok(
+      /not found|no such file|does.not.exist/i.test(out),
+      `expected a "not found" message, got: ${out}`,
+    );
+  });
+
+  test('nested path — deletes a note in a subdirectory', () => {
+    const relPath = 'decisions/nested/deeply/note.md';
+    // Write
+    const writeRes = runBizarMemory(
+      'write',
+      [relPath, '--type', 'architecture_decision', '--body', '# Nested note'],
+      projectRoot,
+    );
+    assert.strictEqual(writeRes.code, 0, `write failed: ${writeRes.stderr}`);
+
+    const filePath = join(projectRoot, '.obsidian', relPath);
+    assert.ok(existsSync(filePath), `file should exist before delete: ${filePath}`);
+
+    // Delete
+    const r = runBizarMemory('delete', [relPath], projectRoot);
+    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
+
+    // File should be gone
+    assert.ok(
+      !existsSync(filePath),
+      `file should NOT exist after delete: ${filePath}`,
+    );
+  });
+});
+
+// ─── end-to-end: write → read → list → delete → list → read ──────────────────
+
+describe('bizar memory E2E — write → read → list → delete → list → read', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(
+      tmpdir(),
+      `bizar-meme2e-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+    mkdirSync(join(projectRoot, '.obsidian'), { recursive: true });
+    writeMemoryConfig(projectRoot);
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('full round-trip through the CLI', () => {
+    const relPath = 'decisions/0001-e2e.md';
+    const bodyText = `# E2E test note
+
+This body should survive the full round-trip through the CLI.`;
+
+    // Step 1: write
+    const writeRes = runBizarMemory('write', [
+      relPath,
+      '--type', 'architecture_decision',
+      '--status', 'active',
+      '--confidence', 'verified',
+      '--title', 'E2E test note',
+      '--body', bodyText,
+    ], projectRoot);
+    assert.strictEqual(writeRes.code, 0, `write failed: ${writeRes.stderr}`);
+
+    // Step 2: read — should succeed and contain the body
+    const readRes = runBizarMemory('read', [relPath], projectRoot);
+    assert.strictEqual(readRes.code, 0, `read failed: ${readRes.stderr}`);
+    assert.ok(
+      readRes.stdout.includes('round-trip'),
+      `read output should contain body text; got: ${readRes.stdout}`,
+    );
+
+    // Step 3: list — should show the note
+    const listRes = runBizarMemory('list', [], projectRoot);
+    assert.strictEqual(listRes.code, 0, `list failed: ${listRes.stderr}`);
+    assert.ok(
+      listRes.stdout.includes(relPath),
+      `list should contain ${relPath}; got: ${listRes.stdout}`,
+    );
+
+    // Step 4: delete
+    const deleteRes = runBizarMemory('delete', [relPath], projectRoot);
+    assert.strictEqual(deleteRes.code, 0, `delete failed: ${deleteRes.stderr}`);
+
+    // Step 5: list again — should NOT show the note
+    const listAfterRes = runBizarMemory('list', [], projectRoot);
+    assert.strictEqual(listAfterRes.code, 0, `list after delete failed: ${listAfterRes.stderr}`);
+    assert.ok(
+      !listAfterRes.stdout.includes(relPath),
+      `list after delete should NOT contain ${relPath}; got: ${listAfterRes.stdout}`,
+    );
+
+    // Step 6: read — should fail with not-found
+    const readAfterRes = runBizarMemory('read', [relPath], projectRoot);
+    assert.strictEqual(readAfterRes.code, 1, `read after delete should exit 1, got ${readAfterRes.code}`);
+    const out = `${readAfterRes.stdout}\n${readAfterRes.stderr}`;
+    assert.ok(
+      /not found|no such file|does.not.exist/i.test(out),
+      `read after delete should report not found; got: ${out}`,
+    );
+  });
+});