@polderlabs/bizar 5.0.0 → 5.0.2

package/bizar-dash/tests/diagnostics-store.test.mjs

@@ -0,0 +1,206 @@
+/**
+ * tests/diagnostics-store.test.mjs
+ *
+ * v6.0.0 — Tests for the Doctor surface of the diagnostics store:
+ *   - getRecentErrors({ since })  — timestamp-filtered error feed
+ *   - runCheck(name)               — single-check dispatch
+ *   - health()                     — rolled-up status + groups
+ *   - collectDiagnostics()         — full snapshot shape
+ *   - legacy snapshot() / health() — back-compat with v3 /api/diagnostics
+ *
+ * The store reads from `~/.config/bizar/service.log` and TCP-probes
+ * local services. Tests that exercise I/O use a temporary BIZAR_HOME
+ * so they don't touch the real install.
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+
+let tmpHome;
+
+const STORE = await import('../src/server/diagnostics-store.mjs');
+
+beforeEach(() => {
+  tmpHome = mkdtempSync(join(tmpdir(), 'bizar-doctor-store-'));
+  // The store reads `~/.config/bizar/service.log` via the homedir()
+  // helper. We can't change homedir() at runtime, so we redirect
+  // BIZAR-related env by writing an empty service log to the real
+  // ~/.config/bizar path... actually the store uses homedir()
+  // unconditionally, so tests that need a custom log must write
+  // before each test. We work around by NOT requiring log presence
+  // — getRecentErrors() returns [] on missing files.
+});
+
+afterEach(() => {
+  if (tmpHome) {
+    try { rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+});
+
+// ── getRecentErrors ────────────────────────────────────────────────────────
+
+describe('getRecentErrors', () => {
+  it('returns [] when no service log exists', () => {
+    // The real ~/.config/bizar/service.log may or may not exist;
+    // either way, the function must return an array (possibly empty).
+    const out = STORE.getRecentErrors();
+    assert.ok(Array.isArray(out));
+    // No crash, no throw — that's the contract.
+  });
+
+  it('respects the limit option', () => {
+    const out = STORE.getRecentErrors({ limit: 5 });
+    assert.ok(Array.isArray(out));
+    assert.ok(out.length <= 5);
+  });
+
+  it('returns entries with the documented shape', () => {
+    const out = STORE.getRecentErrors({ limit: 1 });
+    if (out.length === 0) return; // nothing to check
+    const row = out[0];
+    assert.strictEqual(typeof row.line, 'string');
+    assert.ok(row.ts === null || typeof row.ts === 'string');
+    assert.ok(row.tsMs === null || typeof row.tsMs === 'number');
+  });
+
+  it('filters out lines without error keywords', () => {
+    // Drop the result into a sink — we just want to make sure the
+    // function never returns a non-error line.
+    const out = STORE.getRecentErrors({ limit: 200 });
+    for (const row of out) {
+      assert.ok(
+        /\b(failed|error|err)\b/i.test(row.line),
+        `expected an error keyword in: ${row.line}`,
+      );
+    }
+  });
+});
+
+// ── runCheck ───────────────────────────────────────────────────────────────
+
+describe('runCheck', () => {
+  it('returns the named check for a known name', async () => {
+    const result = await STORE.runCheck('node');
+    assert.strictEqual(result.name, 'node');
+    assert.ok(['ok', 'warn', 'fail'].includes(result.status));
+    assert.strictEqual(typeof result.message, 'string');
+  });
+
+  it('returns fail for an unknown check name', async () => {
+    const result = await STORE.runCheck('not-a-real-check');
+    assert.strictEqual(result.status, 'fail');
+    assert.strictEqual(result.message, 'unknown check');
+    assert.match(result.error, /Available: /);
+  });
+
+  it('handles empty / non-string input', async () => {
+    const result = await STORE.runCheck('');
+    assert.strictEqual(result.status, 'fail');
+    assert.match(result.message, /unknown check|checkName required/);
+  });
+
+  it('returns the same set of names registered', async () => {
+    // Smoke test: a system check name (memory) and a config check
+    // name (opencode-config) and a service check name (dashboard)
+    // must all be reachable.
+    for (const name of ['memory', 'opencode-config', 'dashboard']) {
+      const r = await STORE.runCheck(name);
+      assert.notStrictEqual(r.message, 'unknown check', `${name} should be a known check`);
+      assert.ok(['ok', 'warn', 'fail'].includes(r.status));
+    }
+  });
+});
+
+// ── health ─────────────────────────────────────────────────────────────────
+
+describe('health', () => {
+  it('returns the rolled-up status object', async () => {
+    const h = await STORE.health();
+    assert.strictEqual(typeof h.ts, 'string');
+    assert.ok(['ok', 'warn', 'fail'].includes(h.status));
+    assert.ok(Array.isArray(h.issues));
+    assert.ok(h.groups && typeof h.groups === 'object');
+    assert.ok(Array.isArray(h.groups.system));
+    assert.ok(Array.isArray(h.groups.config));
+    assert.ok(Array.isArray(h.groups.services));
+  });
+
+  it('derives status from issues (fail > warn > ok)', async () => {
+    const h = await STORE.health();
+    const has = (s) => h.issues.some((i) => i.status === s);
+    if (has('fail')) assert.strictEqual(h.status, 'fail');
+    else if (has('warn')) assert.strictEqual(h.status, 'warn');
+    else assert.strictEqual(h.status, 'ok');
+  });
+});
+
+// ── collectDiagnostics ─────────────────────────────────────────────────────
+
+describe('collectDiagnostics', () => {
+  it('returns a snapshot with the documented top-level keys', async () => {
+    const snap = await STORE.collectDiagnostics();
+    assert.strictEqual(typeof snap.timestamp, 'string');
+    assert.strictEqual(typeof snap.bizarVersion, 'string');
+    assert.strictEqual(snap.nodeVersion, process.version);
+    assert.strictEqual(snap.platform, process.platform);
+    assert.strictEqual(snap.arch, process.arch);
+    assert.strictEqual(typeof snap.uptime, 'number');
+    assert.ok(snap.memory && typeof snap.memory.rss === 'number');
+    assert.ok(snap.disk && typeof snap.disk.exists === 'boolean');
+    assert.ok(snap.services);
+    assert.ok(snap.services.dashboard);
+    assert.ok(snap.services.headroom);
+    assert.ok(snap.services.lightrag);
+    assert.ok(snap.services.opencode);
+    assert.ok(snap.counts);
+    assert.ok(Array.isArray(snap.recentErrors));
+    assert.ok(Array.isArray(snap.configHealth));
+    assert.ok(snap.opencode);
+    assert.ok(snap.checks);
+    assert.ok(snap.health);
+  });
+
+  it('counts all expected numeric fields', async () => {
+    const snap = await STORE.collectDiagnostics();
+    const c = snap.counts;
+    for (const key of [
+      'tasks', 'schedules', 'mods', 'providers', 'mcps', 'agents',
+      'projects', 'workspaces', 'voiceNotes', 'evalRuns', 'backups',
+    ]) {
+      assert.strictEqual(typeof c[key], 'number', `counts.${key} should be a number`);
+      assert.ok(c[key] >= 0, `counts.${key} should be >= 0`);
+    }
+  });
+
+  it('returns recent errors within the requested window', async () => {
+    const snap = await STORE.collectDiagnostics();
+    for (const err of snap.recentErrors) {
+      assert.ok(err.tsMs === null || err.tsMs >= Date.now() - 3700_000,
+        `recent error outside the last-hour window: ${err.line}`);
+    }
+  });
+});
+
+// ── legacy snapshot / health (back-compat with v3 /api/diagnostics) ───────
+
+describe('diagnosticsStore (legacy v3)', () => {
+  it('snapshot() returns the legacy shape', () => {
+    const snap = STORE.diagnosticsStore.snapshot();
+    assert.strictEqual(typeof snap.version, 'string');
+    assert.strictEqual(typeof snap.uptime, 'number');
+    assert.strictEqual(snap.nodeVersion, process.version);
+    assert.strictEqual(snap.platform, process.platform);
+    assert.ok(snap.memory);
+    assert.ok(snap.counts);
+    assert.ok(Array.isArray(snap.errors));
+    assert.ok(snap.service);
+  });
+
+  it('legacy health() returns checks array', () => {
+    const h = STORE.diagnosticsStore.health();
+    assert.strictEqual(typeof h.ts, 'string');
+    assert.ok(Array.isArray(h.checks));
+  });
+});

package/bizar-dash/tests/env-vars-extended.test.mjs

@@ -0,0 +1,190 @@
+/**
+ * env-vars-extended.test.mjs — tests for bulk-import, export, grouped endpoints.
+ *
+ * Run with: node --test bizar-dash/tests/env-vars-extended.test.mjs
+ */
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = join(import.meta.dirname, '..', '..');
+
+let SANDBOX_HOME;
+let ORIGINAL_HOME;
+let ENV_FILE;
+
+before(() => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-env-vars-ext-${Date.now()}-`));
+  ORIGINAL_HOME = process.env.HOME;
+  process.env.HOME = SANDBOX_HOME;
+  const BIZAR_DIR = join(SANDBOX_HOME, '.config', 'bizar');
+  ENV_FILE = join(BIZAR_DIR, 'env.json');
+});
+
+after(() => {
+  process.env.HOME = ORIGINAL_HOME;
+  for (const k of Object.keys(process.env)) {
+    if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+  }
+  try { rmSync(SANDBOX_HOME, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+async function request(app, method, path, body) {
+  const http = await import('node:http');
+  return new Promise((resolve, reject) => {
+    const server = app.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const bodyStr = body ? JSON.stringify(body) : '';
+      const opts = {
+        hostname: '127.0.0.1', port, path, method,
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(bodyStr) },
+      };
+      const req = http.request(opts, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          server.close();
+          try { resolve({ status: res.statusCode, body: JSON.parse(data), raw: data, headers: res.headers }); }
+          catch { resolve({ status: res.statusCode, body: data, raw: data, headers: res.headers }); }
+        });
+      });
+      req.on('error', (err) => { server.close(); reject(err); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  });
+}
+
+// Track which keys this test file uses so we can clean them up
+const TEST_KEYS = new Set();
+
+describe('env-vars extended endpoints', () => {
+  let app;
+
+  beforeEach(async () => {
+    // Delete env file to start fresh
+    try { rmSync(ENV_FILE); } catch { /* ignore */ }
+    // Import fresh module
+    const express = (await import('express')).default;
+    const { createEnvVarsRouter } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    // Force store re-init
+    const { resetStore } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    resetStore();
+    app = express();
+    app.use(express.json());
+    app.use('/api', createEnvVarsRouter());
+    // Clear test keys from process.env
+    for (const k of Object.keys(process.env)) {
+      if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+    }
+  });
+
+  afterEach(() => {
+    for (const k of Object.keys(process.env)) {
+      if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+    }
+  });
+
+  // ─── POST /api/env-vars/bulk-import ───────────────────────────────────────
+
+  it('bulk-import parses KEY=value lines', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_EXT_A=value1\nBIZAR_EXT_B=value2',
+    });
+    assert.equal(res.status, 200);
+    assert.equal(res.body.ok, true);
+    assert.equal(res.body.imported, 2);
+    assert.equal(res.body.skipped, 0);
+    assert.deepEqual(res.body.errors, []);
+  });
+
+  it('bulk-import skips existing keys', async () => {
+    // Pre-create one
+    const create = await request(app, 'POST', '/api/env-vars', {
+      name: 'BIZAR_EXT_EXISTING', value: 'original',
+    });
+    assert.equal(create.status, 201);
+
+    const bulk = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_EXT_EXISTING=ignored\nBIZAR_EXT_NEWBULK=fresh',
+    });
+    assert.equal(bulk.body.imported, 1, 'should import only the new key');
+    assert.equal(bulk.body.skipped, 1, 'should skip the existing key');
+    assert.ok(bulk.body.errors.some((e) => e.includes('Already exists')));
+  });
+
+  it('bulk-import reports invalid lines in errors', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_ext_invalid=value\nBIZAR_EXT_VALID=good\nBIZAR_EXT_NOEquals\nBOGUS_PREFIX=bad',
+    });
+    assert.equal(res.body.imported, 1, 'only valid entries are imported');
+    assert.ok(res.body.errors.length >= 2, 'should have errors for invalid lines');
+  });
+
+  it('bulk-import skips blank lines and comments', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: '# comment\n\n  \nBIZAR_EXT_TRIMMED=value',
+    });
+    assert.equal(res.body.imported, 1);
+    assert.equal(res.body.skipped, 3, 'comment and two blank/whitespace lines are skipped');
+  });
+
+  it('bulk-import requires envContent string', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {});
+    assert.equal(res.status, 400);
+    assert.equal(res.body.error, 'envContent_required');
+  });
+
+  // ─── GET /api/env-vars/export ─────────────────────────────────────────────
+
+  it('export produces valid .env format', async () => {
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_EXPORT1', value: 'val-one' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_EXPORT2', value: 'val-two' });
+
+    const res = await request(app, 'GET', '/api/env-vars/export');
+    assert.equal(res.status, 200);
+    assert.ok(res.headers['content-type']?.includes('text/plain'), 'should be text/plain');
+    assert.ok(res.headers['content-disposition']?.includes('.env'), 'should have .env content-disposition');
+    const lines = res.raw.split('\n').filter(Boolean);
+    assert.ok(lines.some((l) => l === 'BIZAR_EXT_EXPORT1=val-one'));
+    assert.ok(lines.some((l) => l === 'BIZAR_EXT_EXPORT2=val-two'));
+  });
+
+  it('export returns empty string when no vars', async () => {
+    const res = await request(app, 'GET', '/api/env-vars/export');
+    assert.equal(res.status, 200);
+    assert.equal(res.raw.trim(), '');
+  });
+
+  // ─── GET /api/env-vars/grouped ───────────────────────────────────────────
+
+  it('grouping splits vars by prefix', async () => {
+    // All vars must start with BIZAR_ per NAME_RE
+    // Grouping is by the "prefix" after BIZAR_ (e.g. EXT_, PROVIDER_, MODEL_)
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_A', value: 'v1' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_B', value: 'v2' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_PROVIDER_KEY', value: 'pv' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_MODEL_SETTING', value: 'ms' });
+
+    const res = await request(app, 'GET', '/api/env-vars/grouped');
+    assert.equal(res.status, 200);
+    const groups = res.body;
+    const groupKeys = Object.keys(groups).sort();
+    // BIZAR_EXT_* -> EXT_ prefix, BIZAR_PROVIDER_* -> PROVIDER_, BIZAR_MODEL_* -> MODEL_
+    assert.ok(groupKeys.includes('EXT_'), `should have EXT_ group, got: ${groupKeys.join(',')}`);
+    assert.ok(groupKeys.includes('PROVIDER_'), `should have PROVIDER_ group, got: ${groupKeys.join(',')}`);
+    assert.ok(groupKeys.includes('MODEL_'), `should have MODEL_ group, got: ${groupKeys.join(',')}`);
+    assert.equal(groups['EXT_'].length, 2, 'BIZAR_EXT_* vars');
+    assert.equal(groups['PROVIDER_'].length, 1);
+    assert.equal(groups['MODEL_'].length, 1);
+    assert.ok(groups['EXT_'][0].value.includes('*'), 'values should be masked');
+  });
+
+  it('grouped returns empty object when no vars', async () => {
+    const res = await request(app, 'GET', '/api/env-vars/grouped');
+    assert.equal(res.status, 200);
+    assert.deepEqual(res.body, {});
+  });
+});

package/bizar-dash/tests/layout-spacing.test.mjs

@@ -0,0 +1,101 @@
+/**
+ * tests/layout-spacing.test.mjs
+ *
+ * v4.x.x — Smoke test for page-level CSS spacing.
+ * Parses main.css and verifies the .view class has sufficient top padding
+ * so content isn't squished against the topbar.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const css = readFileSync(
+  resolve(import.meta.dirname, '../src/web/styles/main.css'),
+  'utf8',
+);
+
+// Extract the .view rule's padding value.
+// Handles both `padding: 24px` (shorthand) and `padding: var(--space-6)` (CSS variable).
+// We extract the first token (top padding) and resolve CSS var to its px value.
+const viewPaddingMatch = css.match(/\.view\s*\{[^}]*padding:\s*([^;]+)(?:\s|;)/);
+if (!viewPaddingMatch) throw new Error('Could not find .view { padding: ... } in main.css');
+
+// The padding shorthand may be "var(--space-6) var(--space-6) 0" (top right bottom).
+// We split by whitespace and resolve the first token.
+const paddingTokens = viewPaddingMatch[1].trim().split(/\s+/);
+const paddingValue = paddingTokens[0];
+// CSS var: var(--space-6) = 24px, var(--space-4) = 16px, var(--space-3) = 12px
+const CSS_VAR_MAP = {
+  'var(--space-1)': 4,
+  'var(--space-2)': 8,
+  'var(--space-3)': 12,
+  'var(--space-4)': 16,
+  'var(--space-5)': 20,
+  'var(--space-6)': 24,
+  'var(--space-8)': 32,
+};
+
+let paddingNum;
+if (paddingValue.startsWith('var(')) {
+  paddingNum = CSS_VAR_MAP[paddingValue] ?? NaN;
+} else {
+  paddingNum = parseInt(paddingValue, 10);
+}
+if (isNaN(paddingNum)) throw new Error(`Unexpected padding value: "${paddingValue}"`);
+
+const MIN_PADDING = 16;
+if (paddingNum < MIN_PADDING) {
+  throw new Error(
+    `.view padding-top too small: ${paddingNum}px (expected >= ${MIN_PADDING}px). ` +
+    `Content will be squished against the topbar.`,
+  );
+}
+
+console.log(`✓ .view padding-top: ${paddingNum}px (minimum: ${MIN_PADDING}px)`);
+
+// Also verify .bg-active-view has adequate top padding
+const bgMatch = css.match(/\.bg-active-view\s*\{[^}]*padding:\s*([^;]+)(?:\s|;)/);
+if (bgMatch) {
+  const bgTokens = bgMatch[1].trim().split(/\s+/);
+  const bgVal = bgTokens[0];
+  let bgPadding;
+  if (bgVal.startsWith('var(')) {
+    bgPadding = CSS_VAR_MAP[bgVal] ?? NaN;
+  } else {
+    bgPadding = parseInt(bgVal, 10);
+  }
+  if (!isNaN(bgPadding) && bgPadding < MIN_PADDING) {
+    throw new Error(
+      `.bg-active-view padding-top too small: ${bgPadding}px (expected >= ${MIN_PADDING}px)`,
+    );
+  }
+  if (!isNaN(bgPadding)) console.log(`✓ .bg-active-view padding-top: ${bgPadding}px`);
+}
+
+// Verify .view gap is at least 16px
+const gapMatch = css.match(/\.view\s*\{[^}]*gap:\s*([^;]+)(?:\s|;)/);
+if (gapMatch) {
+  const gapVal = gapMatch[1].trim();
+  let gapNum;
+  if (gapVal.startsWith('var(')) {
+    gapNum = CSS_VAR_MAP[gapVal] ?? NaN;
+  } else {
+    gapNum = parseInt(gapVal, 10);
+  }
+  const MIN_GAP = 16;
+  if (!isNaN(gapNum) && gapNum < MIN_GAP) {
+    throw new Error(`.view gap too small: ${gapNum}px (expected >= ${MIN_GAP}px)`);
+  }
+  if (!isNaN(gapNum)) console.log(`✓ .view gap: ${gapNum}px`);
+}
+
+// Verify .page-header exists (margin-bottom for spacing below page headers)
+if (!css.includes('.page-header')) {
+  throw new Error('.page-header not found in main.css — page header spacing missing');
+}
+console.log('✓ .page-header rule present');
+
+// Verify .card + .card rule for sibling card spacing
+if (!css.includes('.card + .card')) {
+  throw new Error('.card + .card sibling rule not found — card spacing may be cramped');
+}
+console.log('✓ .card + .card sibling rule present');

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

@@ -0,0 +1,98 @@
+/**
+ * tests/memory-default-vault.test.mjs
+ *
+ * Tests for the default vault location, currentVault(), and ensureVaultExists().
+ */
+
+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';
+
+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');
+    assert.strictEqual(TEST_STORE.DEFAULT_MEMORY_VAULT, expected);
+  });
+});
+
+describe('DEFAULT_GIT_REMOTE', () => {
+  it('is null by default', () => {
+    assert.strictEqual(TEST_STORE.DEFAULT_GIT_REMOTE, null);
+  });
+});
+
+describe('currentVault', () => {
+  it('returns DEFAULT_MEMORY_VAULT when no env override', () => {
+    assert.strictEqual(TEST_STORE.currentVault(), TEST_STORE.DEFAULT_MEMORY_VAULT);
+  });
+
+  it('returns BIZAR_MEMORY_VAULT env var when set', () => {
+    const orig = process.env.BIZAR_MEMORY_VAULT;
+    process.env.BIZAR_MEMORY_VAULT = '/tmp/test-current-vault';
+    try {
+      assert.strictEqual(TEST_STORE.currentVault(), '/tmp/test-current-vault');
+    } finally {
+      if (orig === undefined) delete process.env.BIZAR_MEMORY_VAULT;
+      else process.env.BIZAR_MEMORY_VAULT = orig;
+    }
+  });
+});
+
+describe('ensureVaultExists', () => {
+  // Use a real temp path so we actually test the function
+  let testVaultRoot;
+
+  beforeEach(() => {
+    testVaultRoot = join(
+      tmpdir(),
+      `bizar-test-vault-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    // Set env var before importing / calling
+    process.env.BIZAR_MEMORY_VAULT = testVaultRoot;
+  });
+
+  afterEach(() => {
+    delete process.env.BIZAR_MEMORY_VAULT;
+    try { rmSync(testVaultRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('creates the vault directory if missing', () => {
+    assert.strictEqual(existsSync(testVaultRoot), false);
+    const result = TEST_STORE.ensureVaultExists();
+    assert.strictEqual(existsSync(testVaultRoot), true);
+    assert.strictEqual(result, testVaultRoot);
+  });
+
+  it('is idempotent — calling twice does not throw', () => {
+    TEST_STORE.ensureVaultExists();
+    const result = TEST_STORE.ensureVaultExists();
+    assert.strictEqual(result, testVaultRoot);
+    assert.strictEqual(existsSync(testVaultRoot), true);
+  });
+
+  it('inits git repo on first run when .git is absent', () => {
+    assert.strictEqual(existsSync(join(testVaultRoot, '.git')), false);
+    TEST_STORE.ensureVaultExists();
+    assert.strictEqual(existsSync(join(testVaultRoot, '.git')), true);
+  });
+
+  it('skips git init if .git already exists', () => {
+    TEST_STORE.ensureVaultExists();
+    assert.strictEqual(existsSync(join(testVaultRoot, '.git')), true);
+    // second call must not throw
+    TEST_STORE.ensureVaultExists();
+    assert.strictEqual(existsSync(join(testVaultRoot, '.git')), true);
+  });
+
+  it('sets git user.email config', () => {
+    TEST_STORE.ensureVaultExists();
+    const configFile = join(testVaultRoot, '.git', 'config');
+    assert.strictEqual(existsSync(configFile), true);
+    const content = readFileSync(configFile, 'utf8');
+    assert.match(content, /bizar@localhost/);
+  });
+});