@polderlabs/bizar 4.9.0 → 5.0.1

package/bizar-dash/tests/eval/runner.test.mjs

@@ -0,0 +1,471 @@
+/**
+ * tests/eval/runner.test.mjs
+ *
+ * v5.0.0 — Tests for the eval runner.
+ *
+ * Verifies:
+ *   - runFixture returns correct shape
+ *   - All check types work (contains, notContains, regex, jsonSchema, maxTokens, maxLatencyMs)
+ *   - Latency tracking
+ *   - Timeout enforcement
+ *   - Suite parallelism
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const EVAL = await import('../../src/server/eval.mjs');
+
+// ── Mock LLM call helpers ──────────────────────────────────────────────────────
+
+function mockLlmCall({ content = 'ok', latencyMs = 10, tokens = 100 } = {}) {
+  return async (prompt, opts) => {
+    await new Promise((r) => setTimeout(r, latencyMs));
+    return {
+      content,
+      usage: {
+        inputTokens: tokens,
+        outputTokens: tokens,
+        totalTokens: tokens * 2,
+      },
+    };
+  };
+}
+
+function failingLlmCall() {
+  return async (prompt, opts) => {
+    throw new Error('LLM error');
+  };
+}
+
+// ── Fixtures ───────────────────────────────────────────────────────────────────
+
+describe('eval runner', () => {
+
+  describe('runFixture', () => {
+
+    it('returns correct shape', async () => {
+      const fixture = {
+        id: 'test-fixture',
+        name: 'Test',
+        description: 'Test fixture',
+        agent: 'thor',
+        prompt: 'Say hello',
+        expected: {},
+      };
+
+      const result = await EVAL.runFixture(fixture, {
+        llmCall: mockLlmCall({ content: 'hello world' }),
+      });
+
+      assert.strictEqual(result.fixtureId, 'test-fixture');
+      assert.strictEqual(typeof result.ok, 'boolean');
+      assert.ok(Array.isArray(result.checks));
+      assert.ok(typeof result.latencyMs === 'number');
+      assert.strictEqual(result.content, 'hello world');
+      assert.ok(result.usage);
+      assert.strictEqual(result.usage.totalTokens, 200);
+    });
+
+    describe('contains check', () => {
+      it('passes when content includes expected substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { contains: ['hello', 'world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const containsCheck = result.checks.find((c) => c.kind === 'contains');
+        assert.ok(containsCheck);
+        assert.strictEqual(containsCheck.ok, true);
+      });
+
+      it('fails when content does not include expected substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { contains: ['goodbye'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const containsCheck = result.checks.find((c) => c.kind === 'contains');
+        assert.ok(containsCheck);
+        assert.strictEqual(containsCheck.ok, false);
+        assert.ok(containsCheck.message.includes('goodbye'));
+      });
+    });
+
+    describe('notContains check', () => {
+      it('passes when content does NOT include forbidden substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { notContains: ['error', 'fail'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
+        assert.ok(notContainsCheck);
+        assert.strictEqual(notContainsCheck.ok, true);
+      });
+
+      it('fails when content includes forbidden substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { notContains: ['error'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello error world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
+        assert.ok(notContainsCheck);
+        assert.strictEqual(notContainsCheck.ok, false);
+      });
+    });
+
+    describe('regex check', () => {
+      it('passes when regex matches', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['hello\\s+world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, true);
+      });
+
+      it('fails when regex does not match', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['goodbye\\s+world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, false);
+      });
+
+      it('fails gracefully on invalid regex', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['[invalid'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, false);
+        assert.ok(regexCheck.message.includes('invalid regex'));
+      });
+    });
+
+    describe('jsonSchema check', () => {
+      it('passes when response is valid JSON matching schema', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {
+            jsonSchema: {
+              type: 'object',
+              required: ['status'],
+              properties: { status: { type: 'string' } },
+            },
+          },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, true);
+      });
+
+      it('fails when response is not valid JSON', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { jsonSchema: { type: 'object' } },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'not json' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, false);
+      });
+
+      it('fails when required property is missing', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {
+            jsonSchema: {
+              type: 'object',
+              required: ['version'],
+              properties: { version: { type: 'string' } },
+            },
+          },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, false);
+        assert.ok(schemaCheck.message.includes('missing required property'));
+      });
+    });
+
+    describe('maxTokens check', () => {
+      it('passes when token count is under limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxTokens: 1000 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ tokens: 100 }),
+        });
+        assert.strictEqual(result.ok, true);
+        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
+        assert.ok(tokenCheck);
+        assert.strictEqual(tokenCheck.ok, true);
+      });
+
+      it('fails when token count exceeds limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxTokens: 50 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ tokens: 100 }),
+        });
+        assert.strictEqual(result.ok, false);
+        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
+        assert.ok(tokenCheck);
+        assert.strictEqual(tokenCheck.ok, false);
+        assert.ok(tokenCheck.message.includes('exceeds max'));
+      });
+    });
+
+    describe('maxLatencyMs check', () => {
+      it('passes when latency is under limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxLatencyMs: 5000 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ latencyMs: 10 }),
+        });
+        assert.strictEqual(result.ok, true);
+        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
+        assert.ok(latencyCheck);
+        assert.strictEqual(latencyCheck.ok, true);
+      });
+
+      it('fails when latency exceeds limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxLatencyMs: 5 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ latencyMs: 100 }),
+        });
+        assert.strictEqual(result.ok, false);
+        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
+        assert.ok(latencyCheck);
+        assert.strictEqual(latencyCheck.ok, false);
+        assert.ok(latencyCheck.message.includes('exceeds max'));
+      });
+    });
+
+    describe('timeout enforcement', () => {
+      it('returns timeout check on timeout', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {},
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: async () => {
+            await new Promise((r) => setTimeout(r, 200));
+            return { content: 'ok', usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } };
+          },
+          timeoutMs: 50,
+        });
+        assert.strictEqual(result.ok, false);
+        const timeoutCheck = result.checks.find((c) => c.kind === 'timeout');
+        assert.ok(timeoutCheck);
+        assert.strictEqual(timeoutCheck.ok, false);
+      });
+    });
+
+    describe('error handling', () => {
+      it('returns error check when LLM call throws', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {},
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: failingLlmCall(),
+        });
+        assert.strictEqual(result.ok, false);
+        const errorCheck = result.checks.find((c) => c.kind === 'error');
+        assert.ok(errorCheck);
+        assert.strictEqual(errorCheck.ok, false);
+        assert.ok(errorCheck.message.includes('LLM error'));
+      });
+    });
+  });
+
+  describe('runSuite', () => {
+    const suiteDir = join(tmpdir(), `eval-suite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+    beforeEach(() => {
+      mkdirSync(suiteDir, { recursive: true });
+      writeFileSync(join(suiteDir, 'fix1.json'), JSON.stringify({
+        id: 'fix1',
+        name: 'Fix 1',
+        description: 'First fixture',
+        agent: 'thor',
+        prompt: 'Say hello',
+        expected: { contains: ['hello'] },
+      }));
+      writeFileSync(join(suiteDir, 'fix2.json'), JSON.stringify({
+        id: 'fix2',
+        name: 'Fix 2',
+        description: 'Second fixture',
+        agent: 'thor',
+        prompt: 'Say goodbye',
+        expected: { contains: ['goodbye'] },
+      }));
+    });
+
+    afterEach(() => {
+      rmSync(suiteDir, { recursive: true, force: true });
+    });
+
+    it('runs all fixtures in a directory', async () => {
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hello and goodbye' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 2);
+      assert.strictEqual(result.passed, 2);
+      assert.strictEqual(result.failed, 0);
+      assert.strictEqual(result.results.length, 2);
+    });
+
+    it('reports failures correctly', async () => {
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hello only' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 2);
+      assert.strictEqual(result.passed, 1);
+      assert.strictEqual(result.failed, 1);
+    });
+
+    it('runs fixtures in parallel batches', async () => {
+      const start = Date.now();
+      // Create 6 fixtures with unique IDs to test batching
+      for (let i = 0; i < 6; i++) {
+        writeFileSync(join(suiteDir, `batch${i}.json`), JSON.stringify({
+          id: `batch${i}`,
+          name: `Batch ${i}`,
+          description: 'Test fixture',
+          agent: 'thor',
+          prompt: 'Say hello',
+          expected: { contains: ['hello'] },
+        }));
+      }
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ latencyMs: 50 }),
+        concurrency: 3,
+      });
+      // 2 original (fix1, fix2) + 6 new (batch0-5) = 8
+      assert.ok(result.total >= 8, `Expected at least 8 fixtures, got ${result.total}`);
+      // Parallel batches should complete faster than sequential
+      const elapsed = Date.now() - start;
+      assert.ok(elapsed < 500, `Should complete quickly, took ${elapsed}ms`);
+    });
+
+    it('handles suite with no fixtures', async () => {
+      const emptyDir = join(tmpdir(), `eval-empty-${Date.now()}`);
+      mkdirSync(emptyDir, { recursive: true });
+      const result = await EVAL.runSuite(emptyDir, {
+        llmCall: mockLlmCall(),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 0);
+      assert.strictEqual(result.passed, 0);
+      assert.strictEqual(result.failed, 0);
+      rmSync(emptyDir, { recursive: true, force: true });
+    });
+
+    it('loads suite JSON with array of fixtures', async () => {
+      const suiteFile = join(suiteDir, 'suite.json');
+      writeFileSync(suiteFile, JSON.stringify({
+        id: 'my-suite',
+        fixtures: [
+          { id: 'f1', name: 'F1', description: 'F1', agent: 'thor', prompt: 'hi', expected: { contains: ['hi'] } },
+          { id: 'f2', name: 'F2', description: 'F2', agent: 'thor', prompt: 'bye', expected: { contains: ['bye'] } },
+        ],
+      }));
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hi and bye' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 4); // 2 individual + 2 in suite
+    });
+  });
+});

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/);
+  });
+});