@polderlabs/bizar 6.2.4 → 6.3.0

package/cli/commands/validate.test.mjs

@@ -1,344 +0,0 @@
-/**
- * cli/commands/validate.test.mjs
- *
- * v6.2.0 — Unit tests for the new `bizar validate` subcommand.
- *
- * We exercise `runValidate()` directly. CLINE_DIR is mocked via
- * `process.env.CLINE_DIR`; a minimal-but-complete Bizar install is
- * staged inside a tmpdir. We then progressively delete files to
- * verify each check fails with a sensible message.
- */
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, chmodSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Writable } from 'node:stream';
-
-const { runValidate } = await import('./validate.mjs');
-
-const ORIG_CLINE_DIR = process.env.CLINE_DIR;
-const ORIG_HOME = process.env.HOME;
-
-let workDir;
-
-function freshWorkDir() {
-  const root = mkdtempSync(join(tmpdir(), 'bizar-validate-'));
-  process.env.CLINE_DIR = root;
-  return root;
-}
-
-function makeFakeClineInstall(root) {
-  writeFileSync(
-    join(root, 'cline.json'),
-    JSON.stringify({
-      $schema: 'https://docs.cline.bot/config.json',
-      plugin: [[
-        './plugins/bizar',
-        { loopThresholdWarn: 5, loopThresholdEscalate: 8, loopThresholdBlock: 12, loopWindowSize: 10 },
-      ]],
-      default_agent: 'odin',
-      permission: 'allow',
-      snapshot: false,
-      instructions: ['.cline/instructions/bizar-tools.md'],
-      provider: {
-        '9router': {
-          baseUrl: 'http://localhost:20128/v1',
-          apiKey: '${env:NINEROUTER_KEY}',
-          models: { 'minimax/MiniMax-M3': { reasoning: true } },
-        },
-        minimax: { models: {} },
-      },
-    }, null, 2),
-  );
-  const agentsDir = join(root, 'agents');
-  mkdirSync(agentsDir, { recursive: true });
-  for (const f of [
-    'odin.md', 'vor.md', 'frigg.md', 'quick.md',
-    'mimir.md', 'heimdall.md', 'hermod.md', 'thor.md', 'baldr.md',
-    'tyr.md', 'vidarr.md', 'forseti.md',
-    'semble-search.md', 'agent-browser.md',
-  ]) {
-    writeFileSync(join(agentsDir, f), '# fake agent');
-  }
-  writeFileSync(join(agentsDir, 'odin.yaml'), 'name: odin\ndescription: odin\n');
-  const cmdsDir = join(root, 'commands');
-  mkdirSync(cmdsDir, { recursive: true });
-  for (const f of [
-    'audit.md', 'bizar.md', 'explain.md', 'init.md', 'learn.md',
-    'plan.md', 'plow-through.md', 'pr-review.md', 'tailscale-serve.md',
-    'visual-plan.md',
-    'team.md', 'test.md', 'validate.md', 'setup-provider.md',
-  ]) {
-    writeFileSync(join(cmdsDir, f), '# fake command');
-  }
-  const skillsDir = join(root, 'skills');
-  mkdirSync(skillsDir, { recursive: true });
-  for (const skill of ['9router', 'bizar', 'obsidian']) {
-    mkdirSync(join(skillsDir, skill), { recursive: true });
-    writeFileSync(join(skillsDir, skill, 'SKILL.md'), '# fake skill');
-  }
-  const rulesDir = join(root, 'rules');
-  mkdirSync(rulesDir, { recursive: true });
-  for (const r of ['general.md', 'git.md', 'javascript.md', 'python.md', 'testing.md', 'thinking.md', 'uncertainty.md']) {
-    writeFileSync(join(rulesDir, r), '# fake rule');
-  }
-  const hooksDir = join(root, 'hooks');
-  mkdirSync(hooksDir, { recursive: true });
-  for (const h of ['PreToolUse', 'PostToolUse', 'TaskStart', 'TaskResume', 'UserPromptSubmit']) {
-    // Cline hooks must be executable scripts with a shebang line.
-    writeFileSync(join(hooksDir, h), '#!/usr/bin/env node\n// fake hook\n');
-    chmodSync(join(hooksDir, h), 0o755);
-  }
-  const pluginDir = join(root, 'plugins', 'bizar');
-  mkdirSync(pluginDir, { recursive: true });
-  writeFileSync(join(pluginDir, 'index.ts'), '// fake plugin entry — >100 bytes to pass size check\n'.repeat(10));
-  mkdirSync(join(pluginDir, 'src'), { recursive: true });
-  writeFileSync(
-    join(pluginDir, 'src', 'clineruntime.ts'),
-    'export class ClineRuntime { config = { enableAgentTeams: true }; }\n',
-  );
-  // node_modules with the required runtime deps
-  const nmDir = join(pluginDir, 'node_modules');
-  mkdirSync(nmDir, { recursive: true });
-  mkdirSync(join(nmDir, 'zod'), { recursive: true });
-  writeFileSync(join(nmDir, 'zod', 'package.json'), '{}');
-  mkdirSync(join(nmDir, '@cline'), { recursive: true });
-  for (const dep of ['@cline/sdk', '@cline/core', '@cline/shared']) {
-    mkdirSync(join(nmDir, dep), { recursive: true });
-    writeFileSync(join(nmDir, dep, 'package.json'), '{}');
-  }
-}
-
-beforeEach(() => {
-  workDir = freshWorkDir();
-  makeFakeClineInstall(workDir);
-});
-
-afterEach(() => {
-  if (workDir && existsSync(workDir)) rmSync(workDir, { recursive: true, force: true });
-  if (ORIG_CLINE_DIR === undefined) delete process.env.CLINE_DIR;
-  else process.env.CLINE_DIR = ORIG_CLINE_DIR;
-  if (ORIG_HOME === undefined) delete process.env.HOME;
-  else process.env.HOME = ORIG_HOME;
-});
-
-/**
- * Capture stdout + exit code for a single runValidate() call.
- * The test runner writes its own progress to stdout, so we swap
- * process.stdout for a sink Writable during the call.
- */
-async function captureRun(opts) {
-  const captured = [];
-  const sink = new Writable({
-    write(chunk, _enc, cb) {
-      captured.push(Buffer.from(chunk));
-      cb();
-    },
-  });
-  const origStdoutDescriptor = Object.getOwnPropertyDescriptor(process, 'stdout');
-  const origExit = process.exit;
-  let exitCode = null;
-  Object.defineProperty(process, 'stdout', { value: sink, configurable: true, writable: true });
-  process.exit = (code) => { exitCode = code; };
-  try {
-    await runValidate(opts);
-  } finally {
-    if (origStdoutDescriptor) Object.defineProperty(process, 'stdout', origStdoutDescriptor);
-    process.exit = origExit;
-  }
-  return { stdout: Buffer.concat(captured).toString('utf8'), exitCode };
-}
-
-describe('runValidate() — JSON output', () => {
-  test('returns structured JSON with passed/failed/results', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'should exit 0 on success');
-    const parsed = JSON.parse(stdout);
-    assert.equal(typeof parsed.passed, 'number');
-    assert.equal(typeof parsed.failed, 'number');
-    assert.ok(Array.isArray(parsed.results));
-    assert.ok(parsed.results.length >= 18, 'expected at least 18 checks');
-    for (const r of parsed.results) {
-      assert.ok(typeof r.name === 'string');
-      assert.ok(typeof r.ok === 'boolean');
-      assert.ok(typeof r.message === 'string');
-    }
-  });
-
-  test('fails on missing team command', async () => {
-    rmSync(join(workDir, 'commands', 'team.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1, 'should exit 1 on team-command-present failure');
-  });
-
-  test('fails on missing test command', async () => {
-    rmSync(join(workDir, 'commands', 'test.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails on missing validate command', async () => {
-    rmSync(join(workDir, 'commands', 'validate.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails on missing agent file', async () => {
-    rmSync(join(workDir, 'agents', 'mimir.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails when cline.json missing', async () => {
-    rmSync(join(workDir, 'cline.json'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails when enableAgentTeams is false in clineruntime.ts', async () => {
-    writeFileSync(
-      join(workDir, 'plugins', 'bizar', 'src', 'clineruntime.ts'),
-      'export class ClineRuntime { config = { enableAgentTeams: false }; }\n',
-    );
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1, 'should fail when enableAgentTeams is false');
-  });
-
-  test('passes when no provider is configured (v6.2.2+ — user must configure)', async () => {
-    // v6.2.2: the installer no longer touches provider config. The
-    // user must add their own provider. The provider-config check
-    // is therefore ALWAYS lenient — it just reports state.
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.provider;
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'no-provider must not fail validation (v6.2.2+ contract)');
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.ok(p, 'provider-config check should be present');
-    assert.equal(p.ok, true, 'provider-config always returns ok (lenient)');
-    assert.match(p.message, /no provider configured/);
-  });
-
-  test('reports user-configured providers when present', async () => {
-    // User has set up their own provider (anything goes).
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.provider = {
-      'my-custom-provider': {
-        baseUrl: 'https://my-llm.example/v1',
-        apiKey: 'sk-test',
-        models: { 'my-model-1': {}, 'my-model-2': {} },
-      },
-    };
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.match(p.message, /my-custom-provider/);
-    assert.match(p.message, /2 models/);
-  });
-
-  test('reports both providers if user has multiple', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.provider = {
-      'a': { baseUrl: 'https://a.example/v1', models: { 'm1': {} } },
-      'b': { baseUrl: 'https://b.example/v1', models: { 'm2': {}, 'm3': {} } },
-    };
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.match(p.message, /\ba\b/);
-    assert.match(p.message, /\bb\b/);
-  });
-
-  test('default mode is lenient on 9router-unreachable', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true });
-    const parsed = JSON.parse(stdout);
-    const nineR = parsed.results.find((r) => r.name === '9router-reachable');
-    assert.ok(nineR, '9router-reachable check should be present');
-    if (!nineR.ok) {
-      // 9router is not running. Default mode must be lenient.
-      assert.equal(exitCode, 0, 'default mode should be lenient when 9router is down');
-    } else {
-      // 9router is running (some test envs have it). Just confirm the
-      // check is in the list and exit code is sane.
-      assert.equal(exitCode, 0, 'expected exit 0 when all critical checks pass');
-    }
-  });
-
-  test('--strict fails when 9router is unreachable', async () => {
-    // We can't easily kill 9router in a test, but we can prove that
-    // --strict mode would fail if 9router were down: set NINEROUTER_URL
-    // to a port nothing is listening on.
-    const origUrl = process.env.NINEROUTER_URL;
-    process.env.NINEROUTER_URL = 'http://127.0.0.1:1';  // nothing here
-    try {
-      const { exitCode } = await captureRun({ json: true, strict: true });
-      assert.equal(exitCode, 1, 'strict mode should fail when 9router is unreachable');
-    } finally {
-      if (origUrl === undefined) delete process.env.NINEROUTER_URL;
-      else process.env.NINEROUTER_URL = origUrl;
-    }
-  });
-
-  test('--only filters to a single check', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true, only: 'team-command-present' });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    assert.equal(parsed.results.length, 1);
-    assert.equal(parsed.results[0].name, 'team-command-present');
-    assert.equal(parsed.results[0].ok, true);
-  });
-
-  test('--only on a missing file fails with exit 1', async () => {
-    rmSync(join(workDir, 'commands', 'team.md'));
-    const { exitCode } = await captureRun({ json: true, only: 'team-command-present' });
-    assert.equal(exitCode, 1);
-  });
-
-  test('--only with an unknown name exits 2', async () => {
-    const { exitCode } = await captureRun({ json: true, only: 'this-does-not-exist' });
-    assert.equal(exitCode, 2);
-  });
-
-  test('v6.2.4 — mistake-limit-floor warns when clineruntimeMaxConsecutiveMistakes is < 10', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 3 }]];
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'mistake-limit-floor is lenient so exit stays 0');
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.ok(check, 'mistake-limit-floor check should be present');
-    assert.equal(check.ok, false, 'low mistake limit should warn');
-    assert.match(check.message, /BELOW the recommended minimum/);
-    assert.match(check.message, /clineruntimeMaxConsecutiveMistakes=3/);
-  });
-
-  test('v6.2.4 — mistake-limit-floor OK when clineruntimeMaxConsecutiveMistakes >= 10', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 15 }]];
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.equal(check.ok, true);
-    assert.match(check.message, /15/);
-  });
-
-  test('v6.2.4 — mistake-limit-floor OK when no plugin entry (legacy cline.json)', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.plugin;
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout } = await captureRun({ json: true });
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.match(check.message, /no plugin entries/);
-    assert.equal(check.ok, true);
-  });
-});

package/cli/doctor.test.mjs

@@ -1,350 +0,0 @@
-/**
- * cli/doctor.test.mjs
- *
- * Tests for the `bizar doctor` subcommand. Uses Node's built-in
- * node:test (no external test framework).
- *
- * Strategy: mock HOME so clineConfigDir() resolves inside a
- * tmpdir, and craft the cline.json + agents/ directory to drive
- * specific pass/fail outcomes. For checks that depend on global
- * npm-installed packages or external CLIs (e.g. cline --version,
- * npm root -g, which headroom), we accept that they may pass or fail
- * depending on the test environment and just verify the framework
- * returns the right shape.
- */
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  rmSync,
-  existsSync,
-  utimesSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = join(__dirname, '..');
-
-const { runDoctor } = await import('./doctor.mjs');
-
-// ── HOME mocking ────────────────────────────────────────────────────────────
-
-const ORIG_HOME = process.env.HOME;
-const ORIG_XDG = process.env.XDG_CONFIG_HOME;
-
-/**
- * Mock HOME so clineConfigDir() resolves to `<tmpdir>/.cline`.
- * Returns the tmpdir path.
- *
- * We don't set XDG_CONFIG_HOME here for the same reason as dev-link.test.mjs:
- * the helper treats a set XDG_CONFIG_HOME as the direct parent (so
- * `XDG_CONFIG_HOME=~/.config` → `~/.cline`).
- */
-function freshHome() {
-  const home = mkdtempSync(join(tmpdir(), 'bizar-doctor-'));
-  process.env.HOME = home;
-  delete process.env.CLINE_DIR;
-    delete process.env.BIZAR_LEGACY_CLINE_DIR;
-  return home;
-}
-
-afterEach(() => {
-  if (ORIG_HOME === undefined) delete process.env.HOME;
-  else process.env.HOME = ORIG_HOME;
-  if (ORIG_XDG === undefined) {
-      delete process.env.CLINE_DIR;
-      delete process.env.BIZAR_LEGACY_CLINE_DIR;
-    } else {
-      process.env.XDG_CONFIG_HOME = ORIG_XDG;
-    }
-});
-
-// ── Shape & silent-mode tests ───────────────────────────────────────────────
-
-describe('runDoctor() shape', () => {
-  let home;
-
-  beforeEach(() => {
-    home = freshHome();
-  });
-
-  afterEach(() => {
-    if (home && existsSync(home)) rmSync(home, { recursive: true, force: true });
-  });
-
-  test('returns { passed, failed, results }', async () => {
-    const result = await runDoctor({ silent: true });
-    assert.equal(typeof result.passed, 'number');
-    assert.equal(typeof result.failed, 'number');
-    assert.ok(Array.isArray(result.results));
-    // results should have one entry per check
-    assert.equal(result.results.length, 9);
-    assert.equal(result.passed + result.failed, 9);
-    // Each result has the expected fields
-    for (const r of result.results) {
-      assert.equal(typeof r.name, 'string');
-      assert.equal(typeof r.ok, 'boolean');
-      assert.equal(typeof r.message, 'string');
-    }
-  });
-
-  test('silent mode suppresses per-check output but still prints summary on failure', async () => {
-    // Capture stdout by overriding console.log.
-    const lines = [];
-    const origLog = console.log;
-    console.log = (...args) => {
-      lines.push(args.join(' '));
-    };
-
-    try {
-      // Empty home → many checks will fail → summary should print.
-      const result = await runDoctor({ silent: true });
-      assert.ok(result.failed > 0, 'precondition: some checks should fail');
-    } finally {
-      console.log = origLog;
-    }
-
-    // In silent mode with failures, only the summary line should print
-    // (an empty leading line is also fine — it's a visual separator).
-    const summaryLines = lines.filter((l) => /checks passed.*failed/.test(l));
-    assert.equal(
-      summaryLines.length,
-      1,
-      `expected exactly 1 summary line in silent+failed mode, got ${summaryLines.length}:\n${lines.join('\n')}`,
-    );
-    assert.match(summaryLines[0], /checks passed.*failed/);
-  });
-
-  test('silent mode suppresses ALL output when nothing fails', async () => {
-    // Build a fully healthy environment. We can't make cline reachable
-    // or headroom installed without modifying PATH, so we settle for: no failures
-    // means no output at all. Since we know some checks will fail in a
-    // bare tmpdir, this test is structured to assert the negative case
-    // differently: we verify silent+no-fail produces 0 lines.
-    //
-    // For this we mock nothing — the test just confirms the framework
-    // doesn't print per-check lines when silent is true.
-    const lines = [];
-    const origLog = console.log;
-    console.log = (...args) => {
-      lines.push(args.join(' '));
-    };
-
-    try {
-      await runDoctor({ silent: true });
-      // Some checks failed (because the env isn't fully healthy).
-      // What we want to verify is that per-check lines did NOT print.
-      const perCheckLines = lines.filter((l) =>
-        /^\s+[✓✗]\s/.test(l) // chalk check markers
-      );
-      assert.equal(
-        perCheckLines.length,
-        0,
-        `silent mode should suppress per-check output, got:\n${perCheckLines.join('\n')}`,
-      );
-    } finally {
-      console.log = origLog;
-    }
-  });
-
-  test('non-silent mode prints per-check output', async () => {
-    const lines = [];
-    const origLog = console.log;
-    console.log = (...args) => {
-      lines.push(args.join(' '));
-    };
-
-    try {
-      await runDoctor();
-    } finally {
-      console.log = origLog;
-    }
-
-    // Should have at least 9 per-check lines plus the summary.
-    const perCheckLines = lines.filter((l) => /^\s+[✓✗]\s/.test(l));
-    assert.ok(
-      perCheckLines.length >= 9,
-      `expected ≥9 per-check lines, got ${perCheckLines.length}`,
-    );
-  });
-});
-
-// ── Fixture-driven pass/fail tests ──────────────────────────────────────────
-
-describe('runDoctor() with fixture HOME', () => {
-  let home;
-
-  beforeEach(() => {
-    home = freshHome();
-  });
-
-  afterEach(() => {
-    if (home && existsSync(home)) rmSync(home, { recursive: true, force: true });
-  });
-
-  function writeClineConfig(json) {
-    const cfgDir = join(home, '.cline');
-    mkdirSync(cfgDir, { recursive: true });
-    writeFileSync(join(cfgDir, 'cline.json'), JSON.stringify(json), 'utf8');
-    return cfgDir;
-  }
-
-  function writeAgents(...files) {
-    const agentsDir = join(home, '.cline', 'agents');
-    mkdirSync(agentsDir, { recursive: true });
-    for (const f of files) {
-      writeFileSync(join(agentsDir, f), `# ${f}`, 'utf8');
-    }
-    return agentsDir;
-  }
-
-  function findCheck(result, name) {
-    return result.results.find((r) => r.name === name);
-  }
-
-  test('config-valid passes for parseable JSON', async () => {
-    writeClineConfig({ provider: {} });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'cline-config-valid');
-    assert.equal(r.ok, true, `expected config-valid to pass: ${r.message}`);
-  });
-
-  test('config-valid fails for missing cline.json', async () => {
-    // No cline.json written.
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'cline-config-valid');
-    assert.equal(r.ok, false);
-    assert.match(r.message, /not found/);
-  });
-
-  test('config-valid fails for invalid JSON', async () => {
-    const cfgDir = writeClineConfig({});
-    // Overwrite with garbage
-    writeFileSync(join(cfgDir, 'cline.json'), '{ this is not json', 'utf8');
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'cline-config-valid');
-    assert.equal(r.ok, false);
-    assert.match(r.message, /invalid JSON/);
-  });
-
-  test('plugin-entry-present fails when plugin[] is empty', async () => {
-    writeClineConfig({ plugin: [] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, false);
-  });
-
-  test('plugin-entry-present fails when plugin[] has no bizar', async () => {
-    writeClineConfig({ plugin: ['something-else'] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, false);
-  });
-
-  test('plugin-entry-present passes when plugin[] has bizar string', async () => {
-    writeClineConfig({ plugin: ['bizar'] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, true, r.message);
-  });
-
-  test('plugin-entry-present passes when plugin[] has bizar object', async () => {
-    writeClineConfig({ plugin: [{ name: 'bizar', path: './plugins/bizar' }] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, true, r.message);
-  });
-
-  test('plugin-entry-present passes when plugin[] has [path, options] tuple', async () => {
-    writeClineConfig({ plugin: [['./plugins/bizar/index.ts', { loopThresholdWarn: 5 }]] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, true, r.message);
-  });
-
-  test('plugin-entry-present fails when tuple path does not contain "bizar"', async () => {
-    writeClineConfig({ plugin: [['./plugins/other/index.ts', {}]] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-entry-present');
-    assert.equal(r.ok, false);
-  });
-
-  test('plugin-path-resolves passes when tuple path resolves', async () => {
-    const home = process.env.HOME;
-    const pluginsDir = join(home, '.cline', 'plugins', 'bizar');
-    mkdirSync(pluginsDir, { recursive: true });
-    writeFileSync(join(pluginsDir, 'index.ts'), '// fake plugin\n', 'utf8');
-    writeClineConfig({ plugin: [['./plugins/bizar/index.ts', {}]] });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'plugin-path-resolves');
-    assert.equal(r.ok, true, r.message);
-  });
-
-  test('agent-files-installed fails when core agents missing', async () => {
-    writeClineConfig({});
-    writeAgents('odin.md'); // missing the other 13
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'agent-files-installed');
-    assert.equal(r.ok, false);
-    assert.match(r.message, /missing/);
-  });
-
-  test('agent-files-installed passes when all 14 agents present', async () => {
-    writeClineConfig({});
-    // v3.20.11: doctor now expects all 14 agents (was 4 in v3.20.10).
-    writeAgents(
-      'odin.md', 'vor.md', 'frigg.md', 'quick.md',
-      'mimir.md', 'heimdall.md', 'hermod.md', 'thor.md', 'baldr.md',
-      'tyr.md', 'vidarr.md', 'forseti.md',
-      'semble-search.md', 'agent-browser.md',
-    );
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'agent-files-installed');
-    assert.equal(r.ok, true, r.message);
-  });
-
-  test('provider-config-sanity warns (not fails) without minimax block', async () => {
-    // v5.x: checkProviderConfigSanity warns instead of throwing when the
-    // provider.minimax block is missing, since provision.mjs auto-adds it.
-    writeClineConfig({ provider: {} });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'provider-config-sanity');
-    assert.equal(r.ok, true, 'should pass with warning, not throw');
-    assert.match(r.message, /warn.*minimax|minimax.*missing/i);
-  });
-
-  test('provider-config-sanity fails when models lack interleaved+reasoning', async () => {
-    writeClineConfig({
-      provider: {
-        minimax: {
-          models: { 'some-model': { id: 'foo' } },
-        },
-      },
-    });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'provider-config-sanity');
-    assert.equal(r.ok, false);
-    assert.match(r.message, /interleaved.*reasoning/);
-  });
-
-  test('provider-config-sanity passes with interleaved+reasoning', async () => {
-    writeClineConfig({
-      provider: {
-        minimax: {
-          models: {
-            'MiniMax/MiniMax-M3': { interleaved: true, reasoning: true },
-          },
-        },
-      },
-    });
-    const result = await runDoctor({ silent: true });
-    const r = findCheck(result, 'provider-config-sanity');
-    assert.equal(r.ok, true, r.message);
-  });
-});
-
-console.log('  doctor.mjs tests loaded — run with: node --test cli/doctor.test.mjs');