@polderlabs/bizar 5.4.0 → 5.5.0

package/bizar-dash/tests/lightrag-startup-hook.test.mjs

@@ -0,0 +1,206 @@
+/**
+ * tests/lightrag-startup-hook.test.mjs
+ *
+ * v5.x — Tests for the lightragStartupHook() introduced in issue #6.
+ *
+ * Strategy: drive lightragStartupHook() against a temp project root that
+ * has a `.bizar/memory.json` (or no config at all). The hook is async
+ * and must:
+ *   - resolve the project's lightrag config
+ *   - honour `lightrag.enabled: false` → return ok=true, reason='disabled'
+ *   - honour BIZAR_LIGHTRAG_AUTOSTART=0 → return ok=true, reason='env-disabled'
+ *   - return ok=false, reason='no-project' when no projectRoot is passed
+ *   - gracefully handle missing binary / errors → return ok=false, error=...
+ *   - return ok=true, reason='already-running' when the server is up
+ *
+ * Tests do NOT require `lightrag-server` to be installed. When it isn't,
+ * the "auto-start" paths return ok=false with a clear error, which is
+ * exactly the contract the dashboard relies on.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const {
+  lightragStartupHook,
+  findLightragBinary,
+  resolveLightRAGConfig,
+} = await import('../src/server/memory-lightrag.mjs');
+
+let tmpRoot;
+const ORIG_AUTOSTART = process.env.BIZAR_LIGHTRAG_AUTOSTART;
+const ORIG_VAULT = process.env.BIZAR_MEMORY_VAULT;
+
+beforeEach(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), 'bizar-lrh-'));
+  mkdirSync(join(tmpRoot, '.bizar'), { recursive: true });
+  delete process.env.BIZAR_LIGHTRAG_AUTOSTART;
+});
+
+afterEach(() => {
+  if (tmpRoot && existsSync(tmpRoot)) rmSync(tmpRoot, { recursive: true, force: true });
+  if (ORIG_AUTOSTART === undefined) delete process.env.BIZAR_LIGHTRAG_AUTOSTART;
+  else process.env.BIZAR_LIGHTRAG_AUTOSTART = ORIG_AUTOSTART;
+  if (ORIG_VAULT === undefined) delete process.env.BIZAR_MEMORY_VAULT;
+  else process.env.BIZAR_MEMORY_VAULT = ORIG_VAULT;
+});
+
+function writeMemoryJson(root, patch = {}) {
+  const cfg = { ...patch };
+  writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify(cfg));
+}
+
+describe('lightragStartupHook — no project', () => {
+  test('returns ok=false, reason=no-project when projectRoot is missing', async () => {
+    const r = await lightragStartupHook(null);
+    assert.equal(r.ok, false);
+    assert.equal(r.started, false);
+    assert.equal(r.reason, 'no-project');
+  });
+
+  test('returns ok=false, reason=no-project when projectRoot is empty string', async () => {
+    const r = await lightragStartupHook('');
+    assert.equal(r.ok, false);
+    assert.equal(r.reason, 'no-project');
+  });
+});
+
+describe('lightragStartupHook — disabled paths', () => {
+  test('returns ok=true, reason=disabled when lightrag.enabled is false', async () => {
+    writeMemoryJson(tmpRoot, { lightrag: { enabled: false, port: 9621 } });
+    const r = await lightragStartupHook(tmpRoot);
+    assert.equal(r.ok, true, 'hook succeeds (skips) when explicitly disabled');
+    assert.equal(r.started, false);
+    assert.equal(r.reason, 'disabled');
+  });
+
+  test('BIZAR_LIGHTRAG_AUTOSTART=0 short-circuits the hook', async () => {
+    writeMemoryJson(tmpRoot, {}); // lightrag.enabled defaults to true
+    process.env.BIZAR_LIGHTRAG_AUTOSTART = '0';
+    const r = await lightragStartupHook(tmpRoot);
+    assert.equal(r.ok, true);
+    assert.equal(r.started, false);
+    assert.equal(r.reason, 'env-disabled');
+  });
+
+  test('BIZAR_LIGHTRAG_AUTOSTART=false short-circuits the hook', async () => {
+    writeMemoryJson(tmpRoot, {});
+    process.env.BIZAR_LIGHTRAG_AUTOSTART = 'false';
+    const r = await lightragStartupHook(tmpRoot);
+    assert.equal(r.ok, true);
+    assert.equal(r.reason, 'env-disabled');
+  });
+});
+
+describe('lightragStartupHook — start path', () => {
+  test('returns a structured result without throwing', async () => {
+    // Use a config that points at a bogus port. If lightrag-server is
+    // installed locally, the hook may start it; if not, it will fail
+    // with a clean error. Either way, the contract is: the hook
+    // returns a structured result and never throws. We don't run the
+    // full 30s startup probe here — that's covered by the live
+    // memory-lightrag.test.mjs.
+    writeMemoryJson(tmpRoot, {
+      lightrag: {
+        enabled: true,
+        host: '127.0.0.1',
+        // Use a high port that's very unlikely to be open. The
+        // startup probe is bounded by resolveLightRAGConfig's
+        // startupTimeoutMs which defaults to 30s — too long for a
+        // unit test. We instead pre-create a "running" PID file to
+        // short-circuit the probe to "already-running" and assert
+        // the hook returns ok=true, reason='already-running'.
+        port: 29999,
+        workingDir: join(tmpRoot, '.bizar', 'lightrag'),
+      },
+    });
+    // Pre-create a fake PID file pointing at a live parent PID.
+    // The hook's readPidAlive() will return alive=true, so the hook
+    // short-circuits to "already-running" without spawning a process.
+    mkdirSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'lightrag', 'lightrag.pid'), String(process.pid));
+
+    try {
+      const r = await lightragStartupHook(tmpRoot);
+      assert.equal(r.ok, true, `hook should not error when server is already running`);
+      assert.equal(r.started, false);
+      assert.equal(r.reason, 'already-running');
+    } finally {
+      rmSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true, force: true });
+    }
+  });
+
+  test('never throws even when the config is corrupt', async () => {
+    // Write a memory.json that is not valid JSON.
+    writeFileSync(join(tmpRoot, '.bizar', 'memory.json'), '{ not valid json');
+    // Pre-create a "running" PID file to short-circuit the start
+    // probe. Without this, the hook would attempt a real start.
+    mkdirSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'lightrag', 'lightrag.pid'), String(process.pid));
+    try {
+      const r = await lightragStartupHook(tmpRoot);
+      // resolveLightRAGConfig falls back to defaults on parse error, so
+      // the hook will see the running PID and return already-running.
+      assert.ok(r);
+      assert.equal(typeof r.ok, 'boolean');
+      // We don't assert on r.reason — depends on whether the corrupt
+      // config parse happens before the PID check.
+    } finally {
+      rmSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true, force: true });
+    }
+  });
+});
+
+describe('lightragStartupHook — env var override', () => {
+  test('BIZAR_LIGHTRAG_AUTOSTART=1 / empty does NOT block (default behaviour)', async () => {
+    // Without an explicit "disable" value, env should not block startup.
+    // We pre-create a PID file so the hook short-circuits to
+    // "already-running" without spawning a process.
+    writeMemoryJson(tmpRoot, {
+      lightrag: {
+        enabled: true,
+        port: 29998,
+        workingDir: join(tmpRoot, '.bizar', 'lightrag'),
+      },
+    });
+    mkdirSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'lightrag', 'lightrag.pid'), String(process.pid));
+    // Don't set the env var at all (already deleted in beforeEach).
+    delete process.env.BIZAR_LIGHTRAG_AUTOSTART;
+    try {
+      const r = await lightragStartupHook(tmpRoot);
+      assert.notEqual(r.reason, 'env-disabled', 'no env-var override → env-disabled is not the reason');
+    } finally {
+      rmSync(join(tmpRoot, '.bizar', 'lightrag'), { recursive: true, force: true });
+    }
+  });
+});
+
+describe('lightragStartupHook — config resolution', () => {
+  test('resolveLightRAGConfig still works for the temp project', () => {
+    writeMemoryJson(tmpRoot, {
+      lightrag: {
+        enabled: true,
+        port: 12345,
+        host: '0.0.0.0',
+      },
+    });
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    assert.equal(cfg.enabled, true);
+    assert.equal(cfg.port, 12345);
+    assert.equal(cfg.host, '0.0.0.0');
+  });
+
+  test('findLightRAGBinary returns null or a path (does not throw)', () => {
+    const bin = findLightragBinary();
+    // Either we found it or we didn't. We only care that the call
+    // didn't throw — proves the startup hook's "binary missing" path
+    // is well-behaved.
+    assert.ok(bin === null || typeof bin === 'string');
+  });
+});
+
+console.log('  lightrag-startup-hook tests loaded');

package/bizar-dash/tests/memory-auto-reindex.test.mjs

@@ -0,0 +1,196 @@
+/**
+ * tests/memory-auto-reindex.test.mjs
+ *
+ * v5.x — Tests for the auto-reindex-on-write feature.
+ *
+ * POST /memory/notes and PUT /memory/notes/* must return the note response
+ * promptly WITHOUT waiting for reindexSingleNote to complete (fire-and-forget).
+ *
+ * These tests verify:
+ *   1. POST /memory/notes returns 201 and the note is persisted immediately
+ *   2. PUT /memory/notes/* returns 200 and the note is updated immediately
+ *   3. Both handlers are non-blocking (reindex is async, fire-and-forget)
+ */
+
+import { test, describe, 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, existsSync, readFileSync } from 'node:fs';
+import http from 'node:http';
+
+const httpPost = (port, path, body) =>
+  new Promise((resolve) => {
+    const data = JSON.stringify(body);
+    const req = http.request(
+      { hostname: 'localhost', port, path, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+      (res) => {
+        let respBody = '';
+        res.on('data', (c) => (respBody += c));
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }); }
+          catch { resolve({ status: res.statusCode, body: respBody }); }
+        });
+      },
+    );
+    req.write(data);
+    req.end();
+  });
+
+const httpPut = (port, path, body) =>
+  new Promise((resolve) => {
+    const data = JSON.stringify(body);
+    const req = http.request(
+      { hostname: 'localhost', port, path, method: 'PUT', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+      (res) => {
+        let respBody = '';
+        res.on('data', (c) => (respBody += c));
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }); }
+          catch { resolve({ status: res.statusCode, body: respBody }); }
+        });
+      },
+    );
+    req.write(data);
+    req.end();
+  });
+
+async function buildApp(projectRoot) {
+  const { createMemoryRouter } = await import('../src/server/routes/memory.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  app.use('/api', createMemoryRouter({ projectRoot }));
+  return app;
+}
+
+async function withApp(projectRoot, fn) {
+  const app = await buildApp(projectRoot);
+  const server = app.listen(0);
+  const port = server.address().port;
+  try {
+    return await fn(port);
+  } finally {
+    server.close();
+  }
+}
+
+function makeTmp() {
+  const root = join(tmpdir(), `bizar-auto-reindex-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(root, { recursive: true });
+  mkdirSync(join(root, '.bizar'), { recursive: true });
+  // Write a minimal memory.json so the router doesn't fail on init.
+  writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+    version: 1,
+    backend: 'bizar-local',
+    projectId: 'reindex-test',
+    memoryRepo: { mode: 'local-only', path: join(root, '.obsidian') },
+    namespaces: { project: 'projects/reindex-test', global: 'global/bizar', user: 'users/tester' },
+    lightrag: { enabled: false },
+    git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false },
+  }));
+  return root;
+}
+
+let tmpRoot;
+
+beforeEach(() => {
+  tmpRoot = makeTmp();
+});
+
+afterEach(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe('POST /memory/notes — auto-reindex', () => {
+  test('returns 201 and the written note immediately', async () => {
+    const result = await withApp(tmpRoot, async (port) => {
+      const start = Date.now();
+      const r = await httpPost(port, '/api/memory/notes', {
+        path: 'sessions/test-post.md',
+        frontmatter: {
+          memory_id: 'test-mid-001',
+          type: 'session_summary',
+          project_id: 'reindex-test',
+          status: 'active',
+          confidence: 'verified',
+          created: '2026-07-06T00:00:00Z',
+          updated: '2026-07-06T00:00:00Z',
+          tags: ['auto-generated'],
+        },
+        body: '# Test note\n\nContent here.',
+      });
+      const elapsed = Date.now() - start;
+      return { r, elapsed };
+    });
+
+    assert.equal(result.r.status, 201, `expected 201, got ${result.r.status}: ${JSON.stringify(result.r.body)}`);
+    assert.equal(result.r.body.relPath, 'sessions/test-post.md');
+    // Response must be fast — reindex is fire-and-forget (no lightrag-server in tests).
+    assert.ok(result.elapsed < 2000, `expected <2s response, got ${result.elapsed}ms`);
+    // Note must be persisted on disk.
+    const notePath = join(tmpRoot, '.obsidian', 'sessions', 'test-post.md');
+    assert.ok(existsSync(notePath), 'note should be written to disk immediately');
+    const content = readFileSync(notePath, 'utf8');
+    assert.ok(content.includes('Test note'));
+  });
+
+  test('rejects notes not ending in .md', async () => {
+    const result = await withApp(tmpRoot, async (port) =>
+      httpPost(port, '/api/memory/notes', {
+        path: 'sessions/test.txt',
+        frontmatter: {
+          memory_id: 'test-mid-002',
+          type: 'task_summary',
+          project_id: 'reindex-test',
+          status: 'active',
+          confidence: 'verified',
+          created: '2026-07-06T00:00:00Z',
+          updated: '2026-07-06T00:00:00Z',
+          tags: [],
+        },
+        body: 'content',
+      }),
+    );
+    assert.equal(result.status, 400);
+  });
+});
+
+describe('PUT /memory/notes/* — auto-reindex', () => {
+  test('returns 200 and the updated note immediately', async () => {
+    // Pre-create the note with valid frontmatter.
+    mkdirSync(join(tmpRoot, '.obsidian', 'sessions'), { recursive: true });
+    writeFileSync(
+      join(tmpRoot, '.obsidian', 'sessions', 'test-put.md'),
+      '---\nmemory_id: test-mid-put\ntype: session_summary\nproject_id: reindex-test\nstatus: active\nconfidence: verified\ncreated: "2026-07-06T00:00:00Z"\nupdated: "2026-07-06T00:00:00Z"\ntags: []\n---\n\nOriginal content.',
+    );
+
+    const result = await withApp(tmpRoot, async (port) => {
+      const start = Date.now();
+      const r = await httpPut(port, '/api/memory/notes/sessions/test-put.md', {
+        frontmatter: {
+          memory_id: 'test-mid-put',
+          type: 'session_summary',
+          project_id: 'reindex-test',
+          status: 'active',
+          confidence: 'verified',
+          created: '2026-07-06T00:00:00Z',
+          updated: '2026-07-06T00:00:00Z',
+          tags: ['auto-generated'],
+        },
+        body: '# Updated note\n\nNew content.',
+      });
+      const elapsed = Date.now() - start;
+      return { r, elapsed };
+    });
+
+    assert.equal(result.r.status, 200, `expected 200, got ${result.r.status}: ${JSON.stringify(result.r.body)}`);
+    assert.equal(result.r.body.relPath, 'sessions/test-put.md');
+    assert.ok(result.elapsed < 2000, `expected <2s response, got ${result.elapsed}ms`);
+    // Note must be updated on disk.
+    const notePath = join(tmpRoot, '.obsidian', 'sessions', 'test-put.md');
+    const content = readFileSync(notePath, 'utf8');
+    assert.ok(content.includes('Updated note'));
+    assert.ok(!content.includes('Original content'));
+  });
+});

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

@@ -390,7 +390,7 @@ describe('bizar memory setup CLI', () => {
       `memoryRepo.remote should match the requested URL — got ${cfg.memoryRepo.remote}`);
     assert.strictEqual(cfg.gitRemote, remote,
       `top-level gitRemote should also be set so cmdPush works — got ${cfg.gitRemote}`);
-    // Vault path lives under ~/.local/share/bizar/memory/<repo-name>
+    // Vault path lives under ~/.bizar_memory/<repo-name> (v5.x — was ~/.local/share/bizar/memory)
     assert.ok(cfg.memoryRepo.path.endsWith(repo), `vault path should end with ${repo}`);
   });
 

package/bizar-dash/tests/memory-default-vault.test.mjs

@@ -2,21 +2,34 @@
  * tests/memory-default-vault.test.mjs
  *
  * Tests for the default vault location, currentVault(), and ensureVaultExists().
+ *
+ * v5.x — DEFAULT_MEMORY_VAULT relocated from `~/.local/share/bizar/memory` to
+ * `~/.bizar_memory` (issue #5). The legacy path is exported as
+ * `LEGACY_MEMORY_VAULT` for migration detection.
  */
 
 import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert';
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
-import { rmSync, existsSync, readFileSync } from 'node:fs';
+import { rmSync, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 
 const TEST_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
 
 describe('DEFAULT_MEMORY_VAULT', () => {
-  it('is ~/.local/share/bizar/memory', () => {
-    const expected = join(homedir(), '.local', 'share', 'bizar', 'memory');
+  it('is ~/.bizar_memory', () => {
+    const expected = join(homedir(), '.bizar_memory');
     assert.strictEqual(TEST_STORE.DEFAULT_MEMORY_VAULT, expected);
   });
+
+  it('LEGACY_MEMORY_VAULT keeps the previous path for migration detection', () => {
+    const expected = join(homedir(), '.local', 'share', 'bizar', 'memory');
+    assert.strictEqual(TEST_STORE.LEGACY_MEMORY_VAULT, expected);
+  });
+
+  it('default vault differs from legacy vault (relocation confirmed)', () => {
+    assert.notStrictEqual(TEST_STORE.DEFAULT_MEMORY_VAULT, TEST_STORE.LEGACY_MEMORY_VAULT);
+  });
 });
 
 describe('DEFAULT_GIT_REMOTE', () => {
@@ -96,3 +109,77 @@ describe('ensureVaultExists', () => {
     assert.match(content, /bizar@localhost/);
   });
 });
+
+describe('ensureVaultExists — legacy path migration notice (v5.x)', () => {
+  let fakeHome;
+  let legacyPath;
+  let newPath;
+  let origHome;
+  let origVault;
+  let origWarn;
+  const captured = [];
+  const fakeConsole = { ...console, warn: (...args) => captured.push(args.join(' ')), log: () => {} };
+
+  beforeEach(() => {
+    origHome = process.env.HOME;
+    origVault = process.env.BIZAR_MEMORY_VAULT;
+    origWarn = console.warn;
+    console.warn = fakeConsole.warn;
+
+    // Build a synthetic home with both the legacy path (with content) and
+    // a new default path. We can't override `homedir()` in pure JS so we
+    // re-import the module via a fresh dynamic import after setting HOME.
+    fakeHome = join(tmpdir(), `bizar-memlegacy-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    process.env.HOME = fakeHome;
+    delete process.env.BIZAR_MEMORY_VAULT;
+    legacyPath = join(fakeHome, '.local', 'share', 'bizar', 'memory');
+    newPath = join(fakeHome, '.bizar_memory');
+    mkdirSync(legacyPath, { recursive: true });
+    writeFileSync(join(legacyPath, 'marker.md'), '# legacy note');
+  });
+
+  afterEach(() => {
+    console.warn = origWarn;
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+    if (origVault === undefined) delete process.env.BIZAR_MEMORY_VAULT;
+    else process.env.BIZAR_MEMORY_VAULT = origVault;
+    if (fakeHome && existsSync(fakeHome)) rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  it('logs a one-time migration notice when legacy vault exists and new default does not', async () => {
+    // Re-import the module after env change so HOME is picked up.
+    const fresh = await import(`../src/server/memory-store.mjs?v=${Date.now()}`);
+    captured.length = 0;
+    const result = fresh.ensureVaultExists();
+    assert.strictEqual(result, newPath, 'returns new default path');
+    assert.strictEqual(existsSync(newPath), true, 'new vault was created');
+    // The legacy path was NOT touched.
+    assert.strictEqual(existsSync(legacyPath), true, 'legacy path still exists');
+    assert.strictEqual(existsSync(join(legacyPath, 'marker.md')), true, 'legacy contents preserved');
+    // The notice mentions the legacy path + new path + the manual mv command.
+    const all = captured.join('\n');
+    assert.match(all, /legacy memory vault/);
+    assert.match(all, new RegExp(legacyPath.replace(/[/.]/g, '\\$&')));
+    assert.match(all, new RegExp(newPath.replace(/[/.]/g, '\\$&')));
+  });
+
+  it('does not log the notice when BIZAR_MEMORY_VAULT is set (explicit override)', async () => {
+    process.env.BIZAR_MEMORY_VAULT = join(fakeHome, 'explicit-vault');
+    const fresh = await import(`../src/server/memory-store.mjs?v=${Date.now()}-${Math.random()}`);
+    captured.length = 0;
+    const result = fresh.ensureVaultExists();
+    assert.strictEqual(result, process.env.BIZAR_MEMORY_VAULT);
+    assert.strictEqual(captured.length, 0, 'no notice when BIZAR_MEMORY_VAULT is explicit');
+  });
+
+  it('does not log the notice when new default already exists (idempotent)', async () => {
+    // Pre-create the new vault so the migration notice is skipped.
+    mkdirSync(newPath, { recursive: true });
+    const fresh = await import(`../src/server/memory-store.mjs?v=${Date.now()}-${Math.random()}-1`);
+    captured.length = 0;
+    fresh.ensureVaultExists();
+    // Even with legacy present, the new vault already exists → no notice.
+    assert.strictEqual(captured.length, 0, 'no notice when new default already exists');
+  });
+});

package/bizar-dash/tests/memory-lightrag-extended.test.mjs

@@ -19,6 +19,8 @@ const {
   stats,
   recordQuery,
   rebuildGraph,
+  detectAvailableLLM,
+  reindexSingleNote,
 } = await import('../src/server/memory-lightrag.mjs');
 
 let tmpRoot;
@@ -159,4 +161,133 @@ describe('rebuildGraph', () => {
     assert.equal(typeof result.ok, 'boolean');
     // workingDir should have been wiped and re-created (or attempted).
   });
+});
+
+describe('detectAvailableLLM', () => {
+  const ORIG_OPENAI = process.env.OPENAI_API_KEY;
+  const ORIG_ANTHROPIC = process.env.ANTHROPIC_API_KEY;
+  const ORIG_MINIMAX = process.env.MINIMAX_API_KEY;
+
+  afterEach(() => {
+    if (ORIG_OPENAI === undefined) delete process.env.OPENAI_API_KEY;
+    else process.env.OPENAI_API_KEY = ORIG_OPENAI;
+    if (ORIG_ANTHROPIC === undefined) delete process.env.ANTHROPIC_API_KEY;
+    else process.env.ANTHROPIC_API_KEY = ORIG_ANTHROPIC;
+    if (ORIG_MINIMAX === undefined) delete process.env.MINIMAX_API_KEY;
+    else process.env.MINIMAX_API_KEY = ORIG_MINIMAX;
+  });
+
+  test('returns null when llmBinding is ollama, no API keys set, and ollama is unreachable', async () => {
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.MINIMAX_API_KEY;
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    cfg.llmBinding = 'ollama';
+    cfg.llmBindingHost = 'http://localhost:59999'; // nothing listening
+    const result = await detectAvailableLLM(cfg);
+    // When ollama is the binding but unreachable, and no API keys are set, returns null.
+    assert.equal(result, null);
+  });
+
+  test('returns openai-available when llmBinding is ollama but OPENAI_API_KEY is set (ollama fallback)', async () => {
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.MINIMAX_API_KEY;
+    process.env.OPENAI_API_KEY = 'sk-test-key';
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    cfg.llmBinding = 'ollama';
+    cfg.llmBindingHost = 'http://localhost:59999'; // unreachable
+    const result = await detectAvailableLLM(cfg);
+    assert.ok(result);
+    assert.equal(result.provider, 'openai');
+    assert.equal(result.available, true);
+  });
+
+  test('returns anthropic-available when llmBinding is anthropic and ANTHROPIC_API_KEY is set', async () => {
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.MINIMAX_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-test';
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    cfg.llmBinding = 'anthropic';
+    const result = await detectAvailableLLM(cfg);
+    assert.ok(result);
+    assert.equal(result.provider, 'anthropic');
+    assert.equal(result.available, true);
+  });
+
+  test('returns minimax-available when llmBinding is minimax and MINIMAX_API_KEY is set', async () => {
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    process.env.MINIMAX_API_KEY = 'minimax-test-key';
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    cfg.llmBinding = 'minimax';
+    const result = await detectAvailableLLM(cfg);
+    assert.ok(result);
+    assert.equal(result.provider, 'minimax');
+    assert.equal(result.available, true);
+  });
+
+  test('returns null when llmBinding is openai but no API key is set', async () => {
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.MINIMAX_API_KEY;
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    cfg.llmBinding = 'openai';
+    const result = await detectAvailableLLM(cfg);
+    assert.equal(result, null);
+  });
+});
+
+describe('reindexSingleNote', () => {
+  test('returns error when memory not initialized', async () => {
+    mkdirSync(join(tmpRoot, '.bizar'), { recursive: true });
+    // No memory.json
+    const r = await reindexSingleNote(tmpRoot, 'notes/test.md');
+    assert.equal(r.ok, false);
+    assert.ok(r.error.includes('not initialized'));
+  });
+
+  test('returns error when note does not exist', async () => {
+    mkdirSync(join(tmpRoot, '.bizar'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'memory.json'), JSON.stringify({
+      projectId: 'testproj',
+      memoryRepo: { mode: 'local-only' },
+    }));
+    const r = await reindexSingleNote(tmpRoot, 'notes/nonexistent.md');
+    assert.equal(r.ok, false);
+    assert.ok(r.error.includes('not found'));
+  });
+
+  test('returns error on path traversal attempt', async () => {
+    mkdirSync(join(tmpRoot, '.bizar', 'memory', 'projects', 'testproj'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'memory.json'), JSON.stringify({
+      projectId: 'testproj',
+      memoryRepo: {
+        mode: 'managed',
+        path: join(tmpRoot, '.bizar', 'memory'),
+      },
+    }));
+    // Attempt path traversal
+    const r = await reindexSingleNote(tmpRoot, '../../../etc/passwd');
+    assert.equal(r.ok, false);
+    assert.ok(r.error.includes('traversal'));
+  });
+
+  test('returns structured result when note exists and lightrag disabled', async () => {
+    mkdirSync(join(tmpRoot, '.bizar', 'memory', 'projects', 'testproj'), { recursive: true });
+    writeFileSync(join(tmpRoot, '.bizar', 'memory.json'), JSON.stringify({
+      projectId: 'testproj',
+      memoryRepo: {
+        mode: 'managed',
+        path: join(tmpRoot, '.bizar', 'memory'),
+      },
+      lightrag: { enabled: false },
+    }));
+    writeFileSync(
+      join(tmpRoot, '.bizar', 'memory', 'projects', 'testproj', 'test.md'),
+      '---\ntitle: Test\n---\n\nBody.',
+    );
+    const r = await reindexSingleNote(tmpRoot, 'test.md');
+    assert.equal(r.ok, false);
+    assert.ok(r.error.includes('disabled'));
+  });
 });