@polderlabs/bizar 5.0.0 → 5.0.2

package/bizar-dash/tests/minimax-bar.test.tsx

@@ -0,0 +1,113 @@
+/**
+ * bizar-dash/tests/minimax-bar.test.ts
+ *
+ * Tests for MiniMax quota bar in the dashboard.
+ * Verifies bar width = consumedPct (not remainingPct).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+
+// ── Minimal QuotaBar clone for testing ──────────────────────────────────────
+// This mirrors the logic in MiniMaxUsage.tsx QuotaBar component.
+
+function clamp(n: number, lo: number, hi: number): number {
+  return Math.max(lo, Math.min(hi, n));
+}
+
+function QuotaBarTest({ remainingPct, consumedPct }: { remainingPct: number; consumedPct: number }) {
+  return (
+    <div data-testid="quota-row">
+      <div data-testid="remaining-label">{remainingPct}% remaining</div>
+      <div data-testid="consumed-label">· {consumedPct}% used</div>
+      <div
+        data-testid="bar-fill"
+        style={{ width: `${consumedPct}%` }}
+        aria-label={`${consumedPct}% consumed`}
+      />
+    </div>
+  );
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('QuotaBar width logic', () => {
+
+  it('bar width equals consumedPct, not remainingPct', () => {
+    const remainingPct = 91;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    const styleWidth = barFill.getAttribute('style');
+
+    // Bar width should be 9% (consumed), not 91% (remaining)
+    expect(styleWidth).toMatch(/width: 9%/);
+    expect(barFill.getAttribute('aria-label')).toBe('9% consumed');
+  });
+
+  it('100% remaining → 0% consumed → 0% bar width', () => {
+    const remainingPct = 100;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 0%/);
+  });
+
+  it('0% remaining → 100% consumed → 100% bar width', () => {
+    const remainingPct = 0;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 100%/);
+  });
+
+  it('75% remaining → 25% consumed → 25% bar width', () => {
+    const remainingPct = 75;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 25%/);
+  });
+
+  it('consumedPct = 100 - remainingPct', () => {
+    const testCases = [
+      { remaining: 100, expectedConsumed: 0 },
+      { remaining: 91, expectedConsumed: 9 },
+      { remaining: 75, expectedConsumed: 25 },
+      { remaining: 50, expectedConsumed: 50 },
+      { remaining: 25, expectedConsumed: 75 },
+      { remaining: 9, expectedConsumed: 91 },
+      { remaining: 0, expectedConsumed: 100 },
+    ];
+
+    for (const { remaining, expectedConsumed } of testCases) {
+      const consumed = clamp(100 - remaining, 0, 100);
+      expect(consumed).toBe(expectedConsumed);
+    }
+  });
+
+  it('clamp keeps values within 0-100 range', () => {
+    expect(clamp(-10, 0, 100)).toBe(0);
+    expect(clamp(110, 0, 100)).toBe(100);
+    expect(clamp(50, 0, 100)).toBe(50);
+  });
+
+  it('labels show both remaining and consumed', () => {
+    const remainingPct = 91;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    expect(screen.getByTestId('remaining-label').textContent).toBe('91% remaining');
+    expect(screen.getByTestId('consumed-label').textContent).toBe('· 9% used');
+  });
+});

package/bizar-dash/tests/minimax-models.test.mjs

@@ -0,0 +1,123 @@
+/**
+ * minimax-models.test.mjs — verify MiniMax is the default/primary provider
+ * and that the catalog, constants, and agent configs all agree.
+ *
+ * Run with: node --test tests/minimax-models.test.mjs
+ */
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve, join } from 'node:path';
+import { readFileSync, readdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let mod;
+let AGENTS_DIR;
+
+before(async () => {
+  const cacheBust = '?cb=' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + cacheBust);
+  AGENTS_DIR = join(REPO, 'config', 'agents');
+});
+
+describe('MiniMax model constants', () => {
+  it('MINIMAX_DEFAULT is MiniMax-M2.7', () => {
+    assert.equal(mod.MINIMAX_DEFAULT, 'MiniMax-M2.7');
+  });
+});
+
+describe('PROVIDER_CATALOG MiniMax entry', () => {
+  it('minimax is present in the catalog', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    assert.ok(minimax, 'minimax provider not found in PROVIDER_CATALOG');
+  });
+
+  it('has at least 4 models', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    assert.ok(minimax.models.length >= 4,
+      `expected at least 4 MiniMax models, got ${minimax.models.length}`);
+  });
+
+  it('includes MiniMax-M2.7-Flash as recommended cheap model', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const flash = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M2.7-Flash';
+    });
+    assert.ok(flash, 'MiniMax-M2.7-Flash not found in catalog');
+    if (typeof flash === 'object') {
+      assert.equal(flash.tier, 'cheap');
+      assert.equal(flash.recommended, true);
+    }
+  });
+
+  it('includes MiniMax-M2.7 (default cheap)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m27 = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M2.7';
+    });
+    assert.ok(m27, 'MiniMax-M2.7 not found in catalog');
+  });
+
+  it('includes MiniMax-M3 (mid tier)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m3 = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M3';
+    });
+    assert.ok(m3, 'MiniMax-M3 not found in catalog');
+  });
+
+  it('includes MiniMax-M3-Reasoning (premium)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m3r = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M3-Reasoning';
+    });
+    assert.ok(m3r, 'MiniMax-M3-Reasoning not found in catalog');
+  });
+});
+
+describe('Agent .md files use MiniMax models', () => {
+  // Agents that should be on minimax/MiniMax-M2.7
+  const m27Agents = ['frigg', 'heimdall', 'mimir', 'vor', 'semble-search', 'hermod', 'thor', 'baldr'];
+  // Agents that should be on minimax/MiniMax-M3
+  const m3Agents = ['tyr', 'vidarr', 'forseti', 'odin'];
+  // Agents that should be on minimax/MiniMax-M2.7-Flash
+  const flashAgents = ['quick'];
+
+  for (const agent of m27Agents) {
+    it(`${agent} uses minimax/MiniMax-M2.7`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M2.7', `${agent} should use MiniMax-M2.7, got ${match[1]}`);
+    });
+  }
+
+  for (const agent of m3Agents) {
+    it(`${agent} uses minimax/MiniMax-M3`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M3', `${agent} should use MiniMax-M3, got ${match[1]}`);
+    });
+  }
+
+  for (const agent of flashAgents) {
+    it(`${agent} uses minimax/MiniMax-M2.7-Flash`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M2.7-Flash', `${agent} should use MiniMax-M2.7-Flash, got ${match[1]}`);
+    });
+  }
+});

package/bizar-dash/tests/opencode-sessions-detail.test.mjs

@@ -64,8 +64,32 @@ function startUpstream() {
         res.end(JSON.stringify({ data: [{ id: 'sess-1', title: 'Test', time: { created: 1, updated: 2, archived: null }, location: { directory: '/tmp/session-worktree' } }] }));
         return;
       }
+      // v5.0.0 — bug #4: per-session probe used by `worktreeHasSession`
+      // (resolveSessionDirectory fast-path). Matches `/api/session/{id}`
+      // (no `/message` or `/prompt` suffix). 200 when the session
+      // belongs to the directory in the query string; 404 otherwise.
+      const probeM = url.pathname.match(/^\/api\/session\/([^/]+)$/);
+      if (probeM && req.method === 'GET') {
+        const dir = url.searchParams.get('directory') || '';
+        // The session "lives" in /tmp/session-worktree (matches the
+        // recorded worktree in writeServeJson). All other directories
+        // 404 so we can test the fallback path.
+        if (dir === '/tmp/session-worktree') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ id: probeM[1] }));
+          return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'session not found in directory' }));
+        return;
+      }
       const msgM = url.pathname.match(/^\/api\/session\/([^/]+)\/message$/);
       if (msgM && req.method === 'GET') {
+        if (msgM[1] === 'sess-upstream-500') {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'internal server error for testing' }));
+          return;
+        }
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ data: [
           { info: { id: 'm1', role: 'user', time: { created: 1000 } }, parts: [{ type: 'text', text: 'hello' }] },
@@ -128,6 +152,10 @@ function writeServeJson(worktree) {
   writeFileSync(SERVE_JSON_PATH, JSON.stringify({ port: upstreamPort, password: 'test-pw', worktree, pid: 99999, startedAt: Date.now() }), 'utf8');
 }
 
+function writeServeJsonWithoutWorktree() {
+  writeFileSync(SERVE_JSON_PATH, JSON.stringify({ port: upstreamPort, password: 'test-pw', pid: 99999, startedAt: Date.now() }), 'utf8');
+}
+
 /** Move serve.json aside so readServeInfo() returns null.
  *  Uses copy + unlink because rename across filesystems (e.g.
  *  /home/* → /tmp/*) throws EXDEV on Linux. */
@@ -273,4 +301,134 @@ test('SSE stream unwraps sync envelopes and strips version suffix', async () =>
   const d = JSON.parse(events[0].data);
   assert.equal(d.sessionID, 'our-id');
   assert.equal(d.messageID, 'm3');
+});
+
+// ── Error handling tests ─────────────────────────────────────────────────
+
+test('GET messages returns 503 directory_unknown when worktree missing and session not found', async () => {
+  writeServeJsonWithoutWorktree();
+  try {
+    // Request a non-existent session ID so listOpencodeSessions doesn't find it,
+    // and with no worktree in serve.json, resolveSessionDirectory returns null.
+    const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/no-such-session/messages`);
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'directory_unknown');
+    assert.ok(body.message.length > 0);
+    assert.ok(typeof body.suggestion === 'string');
+  } finally {
+    // Restore worktree for subsequent tests.
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages returns 502 opencode_error when upstream returns 500', async () => {
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/sess-upstream-500/messages`);
+  assert.equal(res.status, 502);
+  const body = await res.json();
+  assert.equal(body.error, 'opencode_error');
+  assert.ok(body.message.length > 0);
+  assert.ok(body.cause === 'unknown' || typeof body.cause === 'string');
+  assert.ok(typeof body.suggestion === 'string');
+});
+
+test('GET messages uses suggestion field in error responses', async () => {
+  // Test that the plugin_offline response includes suggestion.
+  moveServeJsonAside();
+  try {
+    const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`);
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'plugin_offline');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+  } finally {
+    // Restore so the after() cleanup finds the file.
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+// ── v5.0.0 — bug #4 — structured error envelopes + worktree fast-path ──
+
+test('GET messages 502 envelope includes cause/status/suggestion on upstream failure', async () => {
+  // Issue: bug #4 — the user previously saw the raw error string
+  // ("listMessages network error: fetch failed") with no structured
+  // fields. The fix is to surface `cause`, `status`, and `suggestion`
+  // so the front-end ChatInfoPanel can render actionable UI.
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(
+    `${dashboardBaseUrl}/api/opencode-sessions/sess-upstream-500/messages`,
+  );
+  assert.equal(res.status, 502);
+  const body = await res.json();
+  assert.equal(body.error, 'opencode_error');
+  assert.equal(typeof body.message, 'string');
+  assert.ok(body.message.length > 0);
+  // Upstream 500 → cause stays 'unknown' (no network code), and the
+  // route forwards the upstream's HTTP status so the operator can
+  // tell whether it's opencode that's broken vs. the dashboard.
+  assert.ok(typeof body.cause === 'string');
+  assert.equal(body.status, 500);
+  assert.ok(typeof body.suggestion === 'string');
+  assert.ok(body.suggestion.length > 0);
+});
+
+test('GET messages 503 plugin_offline envelope includes suggestion (operator guidance)', async () => {
+  // Defensive: confirm the 503 path also carries a suggestion (some
+  // consumers — including the structured-error path in useChat.ts —
+  // branch on `body.code === 'plugin_offline'`).
+  moveServeJsonAside();
+  try {
+    const res = await fetch(
+      `${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`,
+    );
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'plugin_offline');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+    assert.match(body.suggestion, /bizar doctor|opencode serve/i);
+  } finally {
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages 503 directory_unknown envelope includes suggestion', async () => {
+  writeServeJsonWithoutWorktree();
+  try {
+    const res = await fetch(
+      `${dashboardBaseUrl}/api/opencode-sessions/no-such-session/messages`,
+    );
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'directory_unknown');
+    assert.ok(typeof body.message === 'string');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+  } finally {
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages uses worktree fast-path when session exists in recorded worktree', async () => {
+  // The new resolveSessionDirectory fast-path probes the recorded
+  // worktree first (cheap GET /api/session/{id}?directory=... probe).
+  // When the upstream says yes, the resolver returns the worktree
+  // WITHOUT calling GET /api/session. We assert the latter is NOT
+  // called by checking the upstream.promptHits / request log isn't
+  // touched (only the messages endpoint should fire here).
+  //
+  // Indirect check: request a session whose id is NOT in the
+  // /api/session listing but IS in /tmp/session-worktree per the
+  // probe. The probe handler returns 200 for that directory, so the
+  // route should succeed even though the session isn't in the list.
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(
+    `${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`,
+  );
+  assert.equal(res.status, 200);
+  const body = await res.json();
+  assert.ok(Array.isArray(body.messages));
+  assert.ok(body.messages.length >= 1);
 });

package/bizar-dash/tests/routes-doctor.test.mjs

@@ -0,0 +1,159 @@
+/**
+ * tests/routes-doctor.test.mjs
+ *
+ * v6.0.0 — Tests for the Doctor REST surface:
+ *
+ *   GET  /api/doctor         — full snapshot
+ *   GET  /api/doctor/health  — rolled-up status + groups
+ *   POST /api/doctor/check   — single-check dispatch
+ *
+ * We stand up a minimal express server backed by the real
+ * `routes/doctor.mjs` factory. The store reads `~/.config/bizar/`
+ * on the host, so the tests must not require a pristine install —
+ * any I/O failure path is handled by the store (returns [] / 'warn')
+ * and the test assertions stay loose enough to pass on dev machines
+ * AND on CI with no bizar installed.
+ */
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+
+const DOCTOR_ROUTES = await import('../src/server/routes/doctor.mjs');
+
+let server;
+let baseUrl;
+
+before(async () => {
+  const router = DOCTOR_ROUTES.createDoctorRouter();
+  const app = express();
+  app.use(express.json({ limit: '1mb' }));
+  app.use('/api/doctor', router);
+  await new Promise((resolve) => {
+    server = app.listen(0, () => {
+      const addr = server.address();
+      baseUrl = `http://127.0.0.1:${addr.port}`;
+      resolve();
+    });
+  });
+});
+
+after(() => {
+  try { server?.close?.(); } catch { /* ignore */ }
+});
+
+// ── GET /api/doctor ────────────────────────────────────────────────────────
+
+describe('GET /api/doctor', () => {
+  it('returns 200 + a snapshot with the documented top-level keys', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/`);
+    assert.strictEqual(r.status, 200);
+    const body = await r.json();
+    for (const key of [
+      'timestamp', 'bizarVersion', 'nodeVersion', 'platform', 'arch',
+      'uptime', 'memory', 'disk', 'services', 'counts',
+      'recentErrors', 'configHealth', 'opencode', 'checks', 'health',
+    ]) {
+      assert.ok(key in body, `expected ${key} in snapshot`);
+    }
+    assert.strictEqual(body.nodeVersion, process.version);
+    assert.ok(['ok', 'warn', 'fail'].includes(body.health.status));
+  });
+
+  it('counts include all expected numeric fields', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/`);
+    const body = await r.json();
+    for (const key of [
+      'tasks', 'schedules', 'mods', 'providers', 'mcps', 'agents',
+      'projects', 'workspaces', 'voiceNotes', 'evalRuns', 'backups',
+    ]) {
+      assert.strictEqual(typeof body.counts[key], 'number', `counts.${key}`);
+    }
+  });
+
+  it('health.issues is an array', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/`);
+    const body = await r.json();
+    assert.ok(Array.isArray(body.health.issues));
+  });
+});
+
+// ── GET /api/doctor/health ─────────────────────────────────────────────────
+
+describe('GET /api/doctor/health', () => {
+  it('returns 200 + rolled-up health with groups', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/health`);
+    assert.strictEqual(r.status, 200);
+    const body = await r.json();
+    assert.strictEqual(typeof body.ts, 'string');
+    assert.ok(['ok', 'warn', 'fail'].includes(body.status));
+    assert.ok(Array.isArray(body.issues));
+    assert.ok(body.groups);
+    assert.ok(Array.isArray(body.groups.system));
+    assert.ok(Array.isArray(body.groups.config));
+    assert.ok(Array.isArray(body.groups.services));
+  });
+
+  it('derives status from issues', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/health`);
+    const body = await r.json();
+    const has = (s) => body.issues.some((i) => i.status === s);
+    if (has('fail')) assert.strictEqual(body.status, 'fail');
+    else if (has('warn')) assert.strictEqual(body.status, 'warn');
+    else assert.strictEqual(body.status, 'ok');
+  });
+});
+
+// ── POST /api/doctor/check ─────────────────────────────────────────────────
+
+describe('POST /api/doctor/check', () => {
+  it('returns 200 + the check for a known name', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/check`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ checkName: 'node' }),
+    });
+    assert.strictEqual(r.status, 200);
+    const body = await r.json();
+    assert.strictEqual(body.name, 'node');
+    assert.ok(['ok', 'warn', 'fail'].includes(body.status));
+    assert.strictEqual(typeof body.message, 'string');
+  });
+
+  it('returns 404 for an unknown check name', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/check`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ checkName: 'definitely-not-a-real-check' }),
+    });
+    assert.strictEqual(r.status, 404);
+    const body = await r.json();
+    assert.strictEqual(body.status, 'fail');
+    assert.strictEqual(body.message, 'unknown check');
+    assert.match(body.error, /Available: /);
+  });
+
+  it('returns 400 when checkName is missing', async () => {
+    const r = await fetch(`${baseUrl}/api/doctor/check`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    assert.strictEqual(r.status, 400);
+    const body = await r.json();
+    assert.strictEqual(body.status, 'fail');
+    assert.match(body.message, /checkName required/);
+  });
+
+  it('accepts multiple known check names', async () => {
+    for (const checkName of ['memory', 'opencode-config', 'dashboard']) {
+      const r = await fetch(`${baseUrl}/api/doctor/check`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ checkName }),
+      });
+      assert.strictEqual(r.status, 200);
+      const body = await r.json();
+      assert.strictEqual(body.name, checkName);
+    }
+  });
+});