@polderlabs/bizar 10.7.2 → 10.10.0

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

@@ -1,422 +0,0 @@
-/**
- * tests/memory-config.test.mjs
- *
- * Tests for writeLightRAGConfig, patch-mode POST /memory/config,
- * redact behaviour, and LightRAG lifecycle endpoints.
- */
-
-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, readFileSync, existsSync } from 'node:fs';
-import http from 'node:http';
-
-const httpGet = (port, path) =>
-  new Promise((resolve) => {
-    const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
-      let body = '';
-      res.on('data', (c) => (body += c));
-      res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }));
-    });
-    req.end();
-  });
-
-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', () => resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }));
-      },
-    );
-    req.write(data);
-    req.end();
-  });
-
-const {
-  writeLightRAGConfig,
-  resolveLightRAGConfig,
-} = await import('../src/server/memory-lightrag.mjs');
-
-// ── Helpers ────────────────────────────────────────────────────────────────────
-
-function makeTmp() {
-  const root = join(tmpdir(), `bizar-lightrag-cfg-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(root, { recursive: true });
-  mkdirSync(join(root, '.bizar'), { recursive: true });
-  return root;
-}
-
-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();
-  }
-}
-
-// ── writeLightRAGConfig — unit tests ─────────────────────────────────────────
-
-describe('writeLightRAGConfig', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('deep-merges into existing lightrag block', () => {
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { enabled: false, port: 8000, llmModel: 'gpt-4o' },
-    }));
-
-    const result = writeLightRAGConfig(root, { enabled: true, port: 9000 });
-    assert.equal(result.ok, true);
-
-    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
-    assert.equal(mem.lightrag.enabled, true);
-    assert.equal(mem.lightrag.port, 9000);
-    assert.equal(mem.lightrag.llmModel, 'gpt-4o'); // preserved
-  });
-
-  test('validates llmBinding is in known set', () => {
-    const result = writeLightRAGConfig(root, { llmBinding: 'not-a-binding' });
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes('llmBinding'));
-  });
-
-  test('validates embeddingBinding is in known set', () => {
-    const result = writeLightRAGConfig(root, { embeddingBinding: 'bad-embedding' });
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes('embeddingBinding'));
-  });
-
-  test('rejects port out of range (0)', () => {
-    const result = writeLightRAGConfig(root, { port: 0 });
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes('port'));
-  });
-
-  test('rejects port out of range (66666)', () => {
-    const result = writeLightRAGConfig(root, { port: 66666 });
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes('port'));
-  });
-
-  test('accepts port 1 and 65535', () => {
-    let r = writeLightRAGConfig(root, { port: 1 });
-    assert.equal(r.ok, true);
-    r = writeLightRAGConfig(root, { port: 65535 });
-    assert.equal(r.ok, true);
-  });
-
-  test('canonicalises <empty> to empty string for apiKey', () => {
-    const r = writeLightRAGConfig(root, { apiKey: '<empty>' });
-    assert.equal(r.ok, true);
-    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
-    assert.equal(mem.lightrag.apiKey, '');
-  });
-
-  test('atomic — old or new file present after concurrent writes', () => {
-    writeLightRAGConfig(root, { port: 10000 });
-    for (let i = 0; i < 20; i++) {
-      writeLightRAGConfig(root, { port: i + 1 });
-    }
-    const content = readFileSync(join(root, '.bizar', 'memory.json'), 'utf8');
-    const parsed = JSON.parse(content);
-    assert.equal(parsed.lightrag.port, 20);
-  });
-
-  test('creates .bizar/memory.json if missing', () => {
-    const fresh = join(tmpdir(), `bizar-fresh-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(fresh, { recursive: true });
-    try {
-      const r = writeLightRAGConfig(fresh, { port: 5000 });
-      assert.equal(r.ok, true);
-      assert.ok(existsSync(join(fresh, '.bizar', 'memory.json')));
-      const mem = JSON.parse(readFileSync(join(fresh, '.bizar', 'memory.json'), 'utf8'));
-      assert.equal(mem.lightrag.port, 5000);
-    } finally {
-      rmSync(fresh, { recursive: true, force: true });
-    }
-  });
-
-  test('preserves non-lightrag fields when merging', () => {
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      projectId: 'test-proj',
-      memoryRepo: { mode: 'local-only' },
-      lightrag: { port: 7000 },
-    }));
-    const r = writeLightRAGConfig(root, { llmModel: 'claude-3' });
-    assert.equal(r.ok, true);
-    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
-    assert.equal(mem.projectId, 'test-proj');
-    assert.equal(mem.lightrag.llmModel, 'claude-3');
-    assert.equal(mem.lightrag.port, 7000);
-  });
-});
-
-// ── resolveLightRAGConfig — apiKey defaults ───────────────────────────────────
-
-describe('resolveLightRAGConfig apiKey defaults', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('defaults apiKey to "env" when not set', () => {
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      lightrag: { port: 9621 },
-    }));
-    const cfg = resolveLightRAGConfig(root);
-    assert.equal(cfg.apiKey, 'env');
-    assert.equal(cfg.apiKeySource, 'env');
-  });
-
-  test('reads existing apiKeySource', () => {
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      lightrag: { port: 9621, apiKey: 'sk-123', apiKeySource: 'file' },
-    }));
-    const cfg = resolveLightRAGConfig(root);
-    assert.equal(cfg.apiKey, 'sk-123');
-    assert.equal(cfg.apiKeySource, 'file');
-  });
-});
-
-// ── HTTP route integration tests ─────────────────────────────────────────────
-
-describe('POST /api/memory/config patch mode', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621, llmModel: 'original-model' },
-    }));
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('returns merged config with redacted apiKey', async () => {
-    writeLightRAGConfig(root, { apiKey: 'sk-secret123', apiKeySource: 'file' });
-
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/config', {
-        patch: true,
-        lightrag: { port: 5000 },
-      });
-      assert.equal(res.status, 200);
-      assert.equal(res.body.ok, true);
-      assert.equal(res.body.config.lightrag.port, 5000);
-      assert.equal(res.body.config.lightrag.llmModel, 'original-model');
-      // apiKey must be redacted
-      assert.equal(res.body.config.lightrag.apiKey, '***');
-    });
-  });
-
-  test('rejects patch without lightrag field', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/config', { patch: true, foo: 'bar' });
-      assert.equal(res.status, 400);
-    });
-  });
-
-  test('rejects unknown top-level fields in patch', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 1 }, mode: 'managed' });
-      assert.equal(res.status, 400);
-    });
-  });
-
-  test('validates port range through patch', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 99999 } });
-      assert.equal(res.status, 400);
-      assert.ok(res.body.message.includes('port'));
-    });
-  });
-
-  test('validates llmBinding through patch', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { llmBinding: 'invalid' } });
-      assert.equal(res.status, 400);
-      assert.ok(res.body.message.includes('llmBinding'));
-    });
-  });
-});
-
-describe('GET /api/memory/config — redaction', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621, apiKey: 'sk-abc123', apiKeySource: 'file' },
-    }));
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('GET /memory/config redacts apiKey to ***', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpGet(port, '/api/memory/config');
-      assert.equal(res.status, 200);
-      assert.equal(res.body.config.lightrag.apiKey, '***');
-      assert.equal(res.body.config.lightrag.apiKeySource, 'file');
-    });
-  });
-});
-
-describe('GET /api/memory/lightrag/status', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621, llmBinding: 'ollama', embeddingBinding: 'ollama', llmModel: 'test-model', embeddingModel: 'test-embed' },
-    }));
-    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('returns running:false when server not running', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpGet(port, '/api/memory/lightrag/status');
-      assert.equal(res.status, 200);
-      assert.equal(res.body.running, false);
-      assert.equal(res.body.pid, null);
-      assert.equal(res.body.port, 9621);
-      assert.equal(res.body.llmBinding, 'ollama');
-      assert.equal(res.body.embeddingBinding, 'ollama');
-    });
-  });
-});
-
-describe('POST /api/memory/lightrag/start', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621 },
-    }));
-    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('returns ok:false with error when lightrag-server not installed (or ok:true if it is)', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/lightrag/start', {});
-      assert.equal(res.status, 200);
-      assert.equal(typeof res.body.ok, 'boolean');
-      if (!res.body.ok) {
-        assert.ok(res.body.error != null);
-      }
-    });
-  });
-});
-
-describe('POST /api/memory/lightrag/stop', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621 },
-    }));
-    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('returns ok:true when nothing is running', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpPost(port, '/api/memory/lightrag/stop', {});
-      assert.equal(res.status, 200);
-      assert.equal(res.body.ok, true);
-    });
-  });
-});
-
-describe('GET /api/memory/lightrag/log', () => {
-  let root;
-
-  beforeEach(() => {
-    root = makeTmp();
-    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
-      version: 1,
-      lightrag: { port: 9621 },
-    }));
-    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
-    // Write a log file with 60 lines
-    const lines = Array.from({ length: 60 }, (_, i) => `log line ${i + 1}`).join('\n');
-    writeFileSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), lines);
-  });
-
-  afterEach(() => {
-    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  test('returns last 200 lines', async () => {
-    await withApp(root, async (port) => {
-      const res = await httpGet(port, '/api/memory/lightrag/log');
-      assert.equal(res.status, 200);
-      assert.ok(Array.isArray(res.body.lines));
-      assert.ok(res.body.lines.length <= 200);
-    });
-  });
-
-  test('returns empty lines when no log file', async () => {
-    rmSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), { force: true });
-
-    await withApp(root, async (port) => {
-      const res = await httpGet(port, '/api/memory/lightrag/log');
-      assert.equal(res.status, 200);
-      assert.ok(Array.isArray(res.body.lines));
-      assert.equal(res.body.lines.length, 0);
-    });
-  });
-});

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

@@ -1,229 +0,0 @@
-/**
- * tests/memory-conflicts.test.mjs
- *
- * Tests for the `bizar memory conflicts` CLI command — cmdConflicts at
- * cli/memory.mjs:1219-1254.
- *
- * Two conflict detection mechanisms:
- *   1. Frontmatter status=conflict
- *   2. Git conflict markers in body: <<<<<<< HEAD / ======= / >>>>>>> <branch>
- *
- * Gap closed: memory-system-map §8.1 CRITICAL gap #2 "Conflict detection &
- * resolution — cmdConflicts has no test".
- */
-
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { mkdirSync, rmSync, writeFileSync, appendFileSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const CLI_BIN = join(dirname(__filename), '..', '..', 'cli', 'bin.mjs');
-const TEST_MEMORY_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
-
-const uid = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-
-/**
- * Spawn `bizar memory conflicts` in the given cwd.
- * Returns { code, stdout, stderr }.
- */
-function runBizarMemoryConflicts(cwd) {
-  try {
-    const stdout = execFileSync('node', [CLI_BIN, 'memory', 'conflicts'], {
-      cwd,
-      encoding: 'utf8',
-      stdio: 'pipe',
-      timeout: 15_000,
-    });
-    return { code: 0, stdout, stderr: '' };
-  } catch (err) {
-    return {
-      code: err.status ?? 1,
-      stdout: err.stdout ? err.stdout.toString() : '',
-      stderr: err.stderr ? err.stderr.toString() : (err.message ?? ''),
-    };
-  }
-}
-
-describe('bizar memory conflicts CLI', () => {
-  let projectRoot;
-
-  beforeEach(() => {
-    projectRoot = join(tmpdir(), `mem-conflicts-${uid()}`);
-    mkdirSync(projectRoot, { recursive: true });
-    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
-
-    // Write a minimal memory.json config
-    const config = {
-      version: 1,
-      backend: 'bizar-local',
-      projectId: 'conflict-test',
-      memoryRepo: {
-        mode: 'local-only',
-        path: join(projectRoot, '.obsidian'),
-        remote: null,
-        branch: 'main',
-        namespace: null,
-      },
-      namespaces: {
-        project: 'projects/conflict-test',
-        global: 'global/bizar',
-        user: 'users/tester',
-      },
-      lightrag: { enabled: false, host: '127.0.0.1', port: 9621, workingDir: join(projectRoot, '.bizar', 'lightrag') },
-      git: { autoPullOnSessionStart: false, autoCommitOnMemoryWrite: false, autoPushOnSessionEnd: false, commitAuthor: 'Bizar Memory <bizar-memory@local>', commitMessageTemplate: 'memory(conflict-test): {summary}' },
-    };
-    writeFileSync(join(projectRoot, '.bizar', 'memory.json'), JSON.stringify(config));
-    // Init the vault
-    mkdirSync(join(projectRoot, '.obsidian'), { recursive: true });
-  });
-
-  afterEach(() => {
-    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  /**
-   * Write a note directly to disk (bypassing the API) so we can inject
-   * arbitrary frontmatter and body content including conflict markers.
-   *
-   * @param {string} relPath  - relative path inside .obsidian/
-   * @param {object} frontmatter  - key-value pairs
-   * @param {string} body  - body content (actual newlines, not \n escapes)
-   * @param {function|null} [postWrite]  - optional(filePath) callback to modify the file after writing
-   */
-  function writeNoteFile(relPath, frontmatter, body, postWrite = null) {
-    const filePath = join(projectRoot, '.obsidian', relPath);
-    mkdirSync(dirname(filePath), { recursive: true });
-    // Write the note using the store (which handles YAML formatting correctly)
-    TEST_MEMORY_STORE.writeNote(projectRoot, relPath, { frontmatter, body });
-    if (postWrite) postWrite(filePath);
-  }
-
-  it('reports frontmatter status=conflict as a conflict', () => {
-    writeNoteFile('conflict-fm.md',
-      {
-        memory_id: 'conflict_fm',
-        type: 'session_summary',
-        project_id: 'conflict-test',
-        status: 'conflict', // ← the conflict marker
-        confidence: 'verified',
-        created: new Date().toISOString(),
-        updated: new Date().toISOString(),
-        tags: [],
-      },
-      'This note has a frontmatter conflict status.',
-    );
-
-    const r = runBizarMemoryConflicts(projectRoot);
-    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
-    const output = `${r.stdout}\n${r.stderr}`;
-    assert.ok(
-      output.includes('conflict-fm.md'),
-      `output should mention conflict-fm.md; got: ${output}`,
-    );
-    assert.ok(
-      /frontmatter.*conflict|conflict.*frontmatter/i.test(output),
-      `output should mention frontmatter conflict; got: ${output}`,
-    );
-  });
-
-  it('reports git conflict markers in body as a conflict', () => {
-    writeNoteFile('conflict-git.md',
-      {
-        memory_id: 'conflict_git',
-        type: 'session_summary',
-        project_id: 'conflict-test',
-        status: 'active',
-        confidence: 'verified',
-        created: new Date().toISOString(),
-        updated: new Date().toISOString(),
-        tags: [],
-      },
-      'This note has git conflict markers.',
-      (filePath) => {
-        // Append git conflict markers to the file after writing
-        appendFileSync(filePath, '\n<<<<<<< HEAD\nLocal change here.\n=======\nRemote change here.\n>>>>>>> remote-branch\n');
-      },
-    );
-
-    const r = runBizarMemoryConflicts(projectRoot);
-    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
-    const output = `${r.stdout}\n${r.stderr}`;
-    assert.ok(
-      output.includes('conflict-git.md'),
-      `output should mention conflict-git.md; got: ${output}`,
-    );
-    assert.ok(
-      /git conflict|conflict marker/i.test(output),
-      `output should mention git conflict; got: ${output}`,
-    );
-  });
-
-  it('reports both conflict types simultaneously', () => {
-    writeNoteFile('both-conflicts.md',
-      {
-        memory_id: 'both_conflicts',
-        type: 'session_summary',
-        project_id: 'conflict-test',
-        status: 'conflict',
-        confidence: 'verified',
-        created: new Date().toISOString(),
-        updated: new Date().toISOString(),
-        tags: [],
-      },
-      'Body with conflict markers.',
-      (filePath) => {
-        appendFileSync(filePath, '\n<<<<<<< HEAD\nLocal.\n=======\nRemote.\n>>>>>>> branch\n');
-      },
-    );
-
-    const r = runBizarMemoryConflicts(projectRoot);
-    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
-    const output = `${r.stdout}\n${r.stderr}`;
-    assert.ok(
-      output.includes('both-conflicts.md'),
-      `output should mention both-conflicts.md; got: ${output}`,
-    );
-    assert.ok(
-      /frontmatter.*conflict|conflict.*frontmatter/i.test(output),
-      `output should report frontmatter conflict; got: ${output}`,
-    );
-  });
-
-  it('outputs "no conflicts found" when vault is clean', () => {
-    writeNoteFile('clean-note.md',
-      {
-        memory_id: 'clean_note',
-        type: 'session_summary',
-        project_id: 'conflict-test',
-        status: 'active',
-        confidence: 'verified',
-        created: new Date().toISOString(),
-        updated: new Date().toISOString(),
-        tags: [],
-      },
-      'This is a perfectly normal, non-conflicted note.',
-    );
-
-    const r = runBizarMemoryConflicts(projectRoot);
-    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
-    const output = `${r.stdout}\n${r.stderr}`;
-    assert.ok(
-      /no conflicts? found/i.test(output),
-      `output should say "no conflicts found"; got: ${output}`,
-    );
-  });
-
-  it('handles empty vault gracefully', () => {
-    const r = runBizarMemoryConflicts(projectRoot);
-    assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}; stderr=${r.stderr}`);
-    const output = `${r.stdout}\n${r.stderr}`;
-    assert.ok(
-      /no conflicts? found/i.test(output),
-      `empty vault should say "no conflicts found"; got: ${output}`,
-    );
-  });
-});