@polderlabs/bizar 4.4.13 → 4.5.1

package/bizar-dash/tests/headroom-install.test.mjs

@@ -0,0 +1,173 @@
+/**
+ * tests/headroom-install.test.mjs
+ *
+ * Tests for installHeadroom(), wrapOpencode(), unwrapOpencode(), startProxy(), stopProxy().
+ * Uses real commands when available, mocks when not.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
+import http from 'node:http';
+
+// ── Run command helper ──────────────────────────────────────────────────────
+
+function runCmd(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { timeout: 5000, ...opts });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (d) => { stdout += d.toString(); });
+    child.stderr?.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: code ?? 0 }));
+    child.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+  });
+}
+
+// ── Install tests ────────────────────────────────────────────────────────────
+
+test('installHeadroom returns correct shape', async () => {
+  const { installHeadroom } = await import('../src/server/headroom.mjs');
+  const result = await installHeadroom({ force: false });
+
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(typeof result.installed === 'boolean', 'installed is boolean');
+  assert.ok(typeof result.version === 'string' || result.version === null, 'version is string|null');
+  assert.ok(typeof result.method === 'string', 'method is string');
+});
+
+test('installHeadroom returns already-installed when headroom is on PATH', async () => {
+  const { installed } = await runCmd('headroom', ['--version']);
+  if (installed !== 0) {
+    // headroom not installed — skip
+    return;
+  }
+
+  const { installHeadroom } = await import('../src/server/headroom.mjs');
+  const result = await installHeadroom({ force: false });
+
+  assert.strictEqual(result.installed, true, 'should report already installed');
+  assert.strictEqual(result.method, 'already-installed', 'method should be already-installed');
+});
+
+test('installHeadroom.force reinstalls even when already installed', async () => {
+  const { installHeadroom } = await import('../src/server/headroom.mjs');
+  const result = await installHeadroom({ force: true });
+
+  // Returns the shape regardless of outcome
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(typeof result.installed === 'boolean', 'installed is boolean');
+  assert.ok(typeof result.method === 'string', 'method is string');
+});
+
+// ── Wrap / Unwrap tests ─────────────────────────────────────────────────────
+
+test('wrapOpencode returns correct shape', async () => {
+  const { wrapOpencode } = await import('../src/server/headroom.mjs');
+  const result = await wrapOpencode({ port: 8787 });
+
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(typeof result.port === 'number', 'port is number');
+  assert.ok(typeof result.log === 'string', 'log is string');
+  assert.strictEqual(result.port, 8787, 'port is 8787');
+});
+
+test('unwrapOpencode returns correct shape', async () => {
+  const { unwrapOpencode } = await import('../src/server/headroom.mjs');
+  const result = await unwrapOpencode();
+
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(typeof result.log === 'string', 'log is string');
+});
+
+// ── Proxy tests ─────────────────────────────────────────────────────────────
+
+test('startProxy returns correct shape', async () => {
+  const { startProxy } = await import('../src/server/headroom.mjs');
+  const result = await startProxy({ port: 18787, host: '127.0.0.1' });
+
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(typeof result.pid === 'number' || result.pid === null, 'pid is number|null');
+  assert.ok(typeof result.port === 'number', 'port is number');
+  assert.ok(typeof result.logPath === 'string', 'logPath is string');
+});
+
+test('stopProxy returns correct shape', async () => {
+  const { stopProxy } = await import('../src/server/headroom.mjs');
+  const result = await stopProxy();
+
+  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
+  assert.ok(Array.isArray(result.killed), 'killed is array');
+});
+
+// ── getOpencodeConfig tests ──────────────────────────────────────────────────
+
+test('getOpencodeConfig returns correct shape', async () => {
+  const { getOpencodeConfig } = await import('../src/server/headroom.mjs');
+  const result = await getOpencodeConfig();
+
+  assert.ok(typeof result.configPath === 'string', 'configPath is string');
+  assert.ok(typeof result.hasHeadroomProvider === 'boolean', 'hasHeadroomProvider is boolean');
+  assert.ok(result.configPath.includes('opencode.json'), 'configPath points to opencode.json');
+});
+
+// ── withHeadroomProxy tests ──────────────────────────────────────────────────
+
+test('withHeadroomProxy returns URL unchanged when disabled', async () => {
+  const { withHeadroomProxy } = await import('../src/server/headroom.mjs');
+  const url = 'https://api.anthropic.com/v1/messages';
+  // When headroom is not in settings (default), returns URL unchanged
+  const result = withHeadroomProxy(url, { port: 8787 });
+  // Result depends on settings — just verify it's a string
+  assert.ok(typeof result === 'string', 'result is string');
+  assert.ok(result.length > 0, 'result is non-empty');
+});
+
+// ── /api/headroom/install endpoint ──────────────────────────────────────────
+
+async function buildApp() {
+  const { createHeadroomRouter } = await import('../src/server/routes/headroom.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  // Mount at /api/headroom so routes like /status become /api/headroom/status
+  app.use('/api/headroom', await createHeadroomRouter());
+  return app;
+}
+
+test('POST /api/headroom/install returns result', async () => {
+  const app = await buildApp();
+  const server = app.listen(0);
+  const { port } = server.address();
+
+  const httpPost = () =>
+    new Promise((resolve, reject) => {
+      const data = JSON.stringify({ force: false });
+      const req = http.request(
+        { hostname: 'localhost', port, path: '/api/headroom/install', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+        (res) => {
+          let body = '';
+          res.on('data', (c) => (body += c));
+          res.on('end', () => {
+            try { resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }); }
+            catch { resolve({ status: res.statusCode, body }); }
+          });
+        },
+      );
+      req.on('error', reject);
+      req.write(data);
+      req.end();
+    });
+
+  try {
+    const res = await httpPost();
+    assert.strictEqual(res.status, 200, 'status should be 200');
+    assert.ok(typeof res.body.ok === 'boolean', 'ok is boolean');
+    assert.ok(typeof res.body.installed === 'boolean', 'installed is boolean');
+  } finally {
+    server.close();
+  }
+});

package/bizar-dash/tests/headroom-settings.test.mjs

@@ -0,0 +1,126 @@
+/**
+ * tests/headroom-settings.test.mjs
+ *
+ * Tests for DEFAULT_SETTINGS.headroom and mergeSettings() headroom merging.
+ */
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+
+// We need to import the actual module — we test the _shared.mjs exports
+
+test('DEFAULT_SETTINGS has headroom key', async () => {
+  const { DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+  assert.ok('headroom' in DEFAULT_SETTINGS, 'headroom key exists in DEFAULT_SETTINGS');
+});
+
+test('DEFAULT_SETTINGS.headroom has all required fields', async () => {
+  const { DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+  const h = DEFAULT_SETTINGS.headroom;
+
+  assert.strictEqual(typeof h.enabled, 'boolean', 'enabled is boolean');
+  assert.strictEqual(typeof h.autoInstall, 'boolean', 'autoInstall is boolean');
+  assert.strictEqual(typeof h.port, 'number', 'port is number');
+  assert.strictEqual(typeof h.host, 'string', 'host is string');
+  assert.strictEqual(typeof h.outputShaper, 'boolean', 'outputShaper is boolean');
+  assert.strictEqual(typeof h.telemetry, 'boolean', 'telemetry is boolean');
+  assert.strictEqual(typeof h.budget, 'number', 'budget is number');
+  assert.strictEqual(typeof h.backend, 'string', 'backend is string');
+  assert.strictEqual(typeof h.autoStart, 'boolean', 'autoStart is boolean');
+  assert.strictEqual(typeof h.autoWrap, 'boolean', 'autoWrap is boolean');
+  assert.strictEqual(typeof h.routeAllProviders, 'boolean', 'routeAllProviders is boolean');
+});
+
+test('DEFAULT_SETTINGS.headroom has correct defaults', async () => {
+  const { DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+  const h = DEFAULT_SETTINGS.headroom;
+
+  assert.strictEqual(h.enabled, true, 'enabled defaults to true');
+  assert.strictEqual(h.autoInstall, true, 'autoInstall defaults to true');
+  assert.strictEqual(h.port, 8787, 'port defaults to 8787');
+  assert.strictEqual(h.host, '127.0.0.1', 'host defaults to 127.0.0.1');
+  assert.strictEqual(h.outputShaper, false, 'outputShaper defaults to false');
+  assert.strictEqual(h.telemetry, false, 'telemetry defaults to false');
+  assert.strictEqual(h.budget, 0, 'budget defaults to 0 (unlimited)');
+  assert.strictEqual(h.backend, 'anthropic', 'backend defaults to anthropic');
+  assert.strictEqual(h.autoStart, true, 'autoStart defaults to true');
+  assert.strictEqual(h.autoWrap, true, 'autoWrap defaults to true');
+  assert.strictEqual(h.routeAllProviders, true, 'routeAllProviders defaults to true');
+});
+
+test('mergeSettings preserves headroom sub-object', async () => {
+  const { mergeSettings, DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+
+  const existing = {
+    theme: { mode: 'light' },
+    headroom: { port: 9999, enabled: false },
+  };
+
+  const merged = mergeSettings(existing);
+
+  assert.ok('headroom' in merged, 'headroom preserved in merged');
+  assert.strictEqual(merged.headroom.port, 9999, 'headroom.port is overridden');
+  assert.strictEqual(merged.headroom.enabled, false, 'headroom.enabled is overridden');
+  // Non-overridden fields should fall back to defaults
+  assert.strictEqual(merged.headroom.host, DEFAULT_SETTINGS.headroom.host, 'headroom.host falls back to default');
+  assert.strictEqual(merged.headroom.autoInstall, DEFAULT_SETTINGS.headroom.autoInstall, 'headroom.autoInstall falls back to default');
+});
+
+test('mergeSettings handles missing headroom in existing', async () => {
+  const { mergeSettings, DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+
+  const existing = { theme: { mode: 'light' } };
+  const merged = mergeSettings(existing);
+
+  assert.ok('headroom' in merged, 'headroom present in merged');
+  assert.deepStrictEqual(merged.headroom, DEFAULT_SETTINGS.headroom, 'headroom matches default when not in existing');
+});
+
+test('mergeSettings handles null existing', async () => {
+  const { mergeSettings, DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+
+  const merged = mergeSettings(null);
+
+  assert.ok('headroom' in merged, 'headroom present in merged');
+  assert.deepStrictEqual(merged.headroom, DEFAULT_SETTINGS.headroom, 'headroom matches default when existing is null');
+});
+
+test('mergeSettings handles undefined existing', async () => {
+  const { mergeSettings, DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+
+  const merged = mergeSettings(undefined);
+
+  assert.ok('headroom' in merged, 'headroom present in merged');
+  assert.deepStrictEqual(merged.headroom, DEFAULT_SETTINGS.headroom, 'headroom matches default when existing is undefined');
+});
+
+// ── HeadroomSettings TypeScript type validation ────────────────────────────────
+// This is validated by `tsc --noEmit`. We just verify the JS shape here.
+
+test('HeadroomSettings type shape matches DEFAULT_SETTINGS.headroom', async () => {
+  const { DEFAULT_SETTINGS } = await import('../src/server/routes/_shared.mjs');
+  const h = DEFAULT_SETTINGS.headroom;
+
+  // All fields must be present
+  const requiredKeys = [
+    'enabled', 'autoInstall', 'port', 'host', 'outputShaper',
+    'telemetry', 'budget', 'backend', 'autoStart', 'autoWrap', 'routeAllProviders',
+  ];
+
+  for (const key of requiredKeys) {
+    assert.ok(key in h, `headroom.${key} is present`);
+  }
+
+  // All values must be the correct type
+  assert.strictEqual(typeof h.enabled, 'boolean');
+  assert.strictEqual(typeof h.autoInstall, 'boolean');
+  assert.strictEqual(typeof h.port, 'number');
+  assert.strictEqual(typeof h.host, 'string');
+  assert.strictEqual(typeof h.outputShaper, 'boolean');
+  assert.strictEqual(typeof h.telemetry, 'boolean');
+  assert.strictEqual(typeof h.budget, 'number');
+  assert.strictEqual(typeof h.backend, 'string');
+  assert.strictEqual(typeof h.autoStart, 'boolean');
+  assert.strictEqual(typeof h.autoWrap, 'boolean');
+  assert.strictEqual(typeof h.routeAllProviders, 'boolean');
+});

package/bizar-dash/tests/headroom-status.test.mjs

@@ -0,0 +1,117 @@
+/**
+ * tests/headroom-status.test.mjs
+ *
+ * Tests for getHeadroomStatus() and the /api/headroom/status endpoint.
+ * Uses real headroom binary when available, mocked when not.
+ */
+
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync, unlinkSync } from 'node:fs';
+import http from 'node:http';
+
+const HEADROOM_PORT_FILE = join(tmpdir(), `headroom-port-test-${Date.now()}.txt`);
+
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+const httpGet = (port, path) =>
+  new Promise((resolve, reject) => {
+    const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }); }
+        catch { resolve({ status: res.statusCode, body }); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+
+// ── Status shape validation ──────────────────────────────────────────────────
+
+test('getHeadroomStatus returns correct shape', async () => {
+  const { getHeadroomStatus } = await import('../src/server/headroom.mjs');
+  const status = await getHeadroomStatus();
+
+  assert.ok(typeof status.installed === 'boolean', 'installed is boolean');
+  assert.ok(typeof status.version === 'string' || status.version === null, 'version is string|null');
+  assert.ok(typeof status.proxyRunning === 'boolean', 'proxyRunning is boolean');
+  assert.ok(typeof status.proxyPort === 'number' || status.proxyPort === null, 'proxyPort is number|null');
+  assert.ok(typeof status.proxyPid === 'number' || status.proxyPid === null, 'proxyPid is number|null');
+  assert.ok(typeof status.wrapped === 'boolean', 'wrapped is boolean');
+  assert.ok(typeof status.configPath === 'string' || status.configPath === null, 'configPath is string|null');
+  assert.ok(['ok', 'warn', 'fail'].includes(status.healthy), 'healthy is ok|warn|fail');
+  assert.ok(Array.isArray(status.messages), 'messages is array');
+});
+
+test('getHeadroomStatus.healthy is warn when not installed', async () => {
+  const { getHeadroomStatus } = await import('../src/server/headroom.mjs');
+  const status = await getHeadroomStatus();
+
+  if (!status.installed) {
+    assert.strictEqual(status.healthy, 'warn', 'healthy should be warn when not installed');
+  }
+});
+
+test('getHeadroomStatus.healthy is warn when not wrapped but installed', async () => {
+  const { getHeadroomStatus } = await import('../src/server/headroom.mjs');
+  const status = await getHeadroomStatus();
+
+  if (status.installed && !status.wrapped) {
+    assert.strictEqual(status.healthy, 'warn', 'healthy should be warn when not wrapped but installed');
+  }
+});
+
+// ── /api/headroom/status endpoint ───────────────────────────────────────────
+
+async function buildApp() {
+  const { createHeadroomRouter } = await import('../src/server/routes/headroom.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  // Mount at /api/headroom so routes like /status become /api/headroom/status
+  app.use('/api/headroom', await createHeadroomRouter());
+  return app;
+}
+
+test('GET /api/headroom/status returns status object', async () => {
+  const app = await buildApp();
+  const server = app.listen(0);
+  const { port } = server.address();
+
+  try {
+    const res = await httpGet(port, '/api/headroom/status');
+    assert.strictEqual(res.status, 200, 'status should be 200');
+    assert.ok(typeof res.body.installed === 'boolean', 'installed is boolean');
+    assert.ok(['ok', 'warn', 'fail'].includes(res.body.healthy), 'healthy is ok|warn|fail');
+    assert.ok(Array.isArray(res.body.messages), 'messages is array');
+  } finally {
+    server.close();
+  }
+});
+
+test('GET /api/headroom/status includes version when installed', async () => {
+  const { getHeadroomStatus } = await import('../src/server/headroom.mjs');
+  const status = await getHeadroomStatus();
+
+  if (status.installed && status.version) {
+    assert.ok(status.version.length > 0, 'version is non-empty string');
+  }
+});
+
+test('GET /api/headroom/status includes proxyPort from cached file', async () => {
+  // Write a fake port file
+  writeFileSync(HEADROOM_PORT_FILE, '9999', 'utf8');
+
+  // Override the module's port file path temporarily by mocking the fs access
+  const { getHeadroomStatus } = await import('../src/server/headroom.mjs');
+  // Note: in a real scenario you'd override via the import.meta trick or env var
+  // Here we just verify the status structure is correct
+  const status = await getHeadroomStatus();
+  assert.ok(typeof status.proxyPort === 'number' || status.proxyPort === null, 'proxyPort is number|null');
+
+  try { unlinkSync(HEADROOM_PORT_FILE); } catch { /* ignore */ }
+});

package/bizar-dash/tests/lightrag-defaults.node.test.mjs

@@ -0,0 +1,118 @@
+/**
+ * lightrag-defaults.node.test.mjs — regression tests for the v4.6.0
+ * LightRAG defaults.
+ *
+ * The memory service's lightrag subsystem starts with the free opencode
+ * Zen models by default (no API key required). Operators can override
+ * via env vars `BIZAR_LIGHTRAG_LLM` and `BIZAR_LIGHTRAG_EMBEDDING`.
+ *
+ * The defaults surface:
+ *   - GET /api/lightrag/defaults   (lightrag settings view)
+ *   - GET /api/memory/lightrag/status (existing memory surface)
+ *
+ * Run with: node --test tests/lightrag-defaults.node.test.mjs
+ */
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve } from 'node:path';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let memoryStore;
+let memoryLightrag;
+let ORIGINAL_ENV;
+
+before(async () => {
+  const cb = '?cb=' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  memoryStore = await import(join(REPO, 'bizar-dash/src/server/memory-store.mjs') + cb);
+  memoryLightrag = await import(join(REPO, 'bizar-dash/src/server/memory-lightrag.mjs') + cb);
+  ORIGINAL_ENV = {
+    BIZAR_LIGHTRAG_LLM: process.env.BIZAR_LIGHTRAG_LLM,
+    BIZAR_LIGHTRAG_EMBEDDING: process.env.BIZAR_LIGHTRAG_EMBEDDING,
+  };
+  delete process.env.BIZAR_LIGHTRAG_LLM;
+  delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+});
+
+after(() => {
+  for (const [k, v] of Object.entries(ORIGINAL_ENV)) {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  }
+});
+
+import { join } from 'node:path';
+
+describe('LIGHTRAG_DEFAULT_* constants (v4.6.0)', () => {
+  it('default LLM is opencode/gpt-5-nano', () => {
+    assert.equal(memoryStore.LIGHTRAG_DEFAULT_LLM, 'opencode/gpt-5-nano');
+  });
+  it('default embedding is opencode/text-embedding-3-small', () => {
+    assert.equal(memoryStore.LIGHTRAG_DEFAULT_EMBEDDING, 'opencode/text-embedding-3-small');
+  });
+});
+
+describe('getDefaultLightRAGConfig()', () => {
+  it('returns opencode-free defaults when no env overrides', () => {
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    assert.equal(cfg.source, 'opencode-free');
+    assert.equal(cfg.llmSource, 'default');
+    assert.equal(cfg.embeddingSource, 'default');
+  });
+
+  it('env BIZAR_LIGHTRAG_LLM overrides the default LLM', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = 'anthropic/claude-haiku-4-5';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'anthropic/claude-haiku-4-5');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    assert.equal(cfg.source, 'env');
+    assert.equal(cfg.llmSource, 'env');
+    assert.equal(cfg.embeddingSource, 'default');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+  });
+
+  it('env BIZAR_LIGHTRAG_EMBEDDING overrides the default embedding', () => {
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = 'openai/text-embedding-3-large';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'openai/text-embedding-3-large');
+    assert.equal(cfg.embeddingSource, 'env');
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+
+  it('both env vars override together', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = 'minimax/MiniMax-M3';
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = 'openai/text-embedding-3-small';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'minimax/MiniMax-M3');
+    assert.equal(cfg.embedding, 'openai/text-embedding-3-small');
+    assert.equal(cfg.source, 'env');
+    assert.equal(cfg.llmSource, 'env');
+    assert.equal(cfg.embeddingSource, 'env');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+
+  it('treats empty env vars as unset (falls back to defaults)', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = '';
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = '   ';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+});
+
+describe('memory-lightrag.mjs LIGHTRAG_DEFAULTS (v4.6.0)', () => {
+  it('default llmModel matches the opencode-Zen-free default', () => {
+    assert.equal(memoryLightrag.LIGHTRAG_DEFAULTS.llmModel, 'opencode/gpt-5-nano');
+  });
+  it('default embeddingModel matches the opencode-Zen-free default', () => {
+    assert.equal(memoryLightrag.LIGHTRAG_DEFAULTS.embeddingModel, 'opencode/text-embedding-3-small');
+  });
+});