@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/__tests__/sharing.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for Session Sharing
  */
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import {
   shareSession,
   getSharedSession,
@@ -39,7 +39,58 @@ const mockMessages = [
 // Inject test dependencies (no module-level mocks — avoids cross-file leaks)
 // ---------------------------------------------------------------------------
 
+/** Minimal in-memory DB that mimics the SQLite API used by sharing/sync.ts */
+function makeInMemoryDb() {
+  const rows = new Map<string, any>();
+
+  return {
+    run(sql: string, params: any[]) {
+      if (/INSERT INTO shares/.test(sql)) {
+        const [id, session_id, name, messages, model, mode, cost_usd, token_count, is_live, write_token, created_at, expires_at] = params;
+        rows.set(id, { id, session_id, name, messages, model, mode, cost_usd, token_count, is_live, write_token, created_at, expires_at });
+        return { changes: 1 };
+      } else if (/UPDATE shares SET messages/.test(sql)) {
+        const [messages, id] = params;
+        const row = rows.get(id);
+        if (row) { row.messages = messages; return { changes: 1 }; }
+        return { changes: 0 };
+      } else if (/DELETE FROM shares WHERE expires_at/.test(sql)) {
+        const [now] = params;
+        let count = 0;
+        for (const [id, row] of rows) {
+          if (row.expires_at <= now) { rows.delete(id); count++; }
+        }
+        return { changes: count };
+      } else if (/DELETE FROM shares WHERE id/.test(sql)) {
+        const [id] = params;
+        const existed = rows.has(id);
+        rows.delete(id);
+        return { changes: existed ? 1 : 0 };
+      }
+      return { changes: 0 };
+    },
+    query(sql: string) {
+      return {
+        get(...params: any[]) {
+          if (/WHERE id = \? AND expires_at/.test(sql)) {
+            const [id, now] = params;
+            const row = rows.get(id);
+            return row && row.expires_at > now ? row : undefined;
+          }
+          return undefined;
+        },
+        all(..._params: any[]) {
+          // listShares uses DELETE first then SELECT with ORDER BY (no WHERE params)
+          return [...rows.values()];
+        },
+      };
+    },
+  };
+}
+
 beforeEach(() => {
+  const db = makeInMemoryDb();
+  _deps.getDb = () => db;
   _deps.getConversation = (id: string) =>
     id === 'test-session-id' ? { messages: mockMessages } : null;
   _deps.getSessionManager = () => ({
@@ -48,6 +99,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  _deps.getDb = undefined;
   _deps.getConversation = undefined;
   _deps.getSessionManager = undefined;
 });

package/src/__tests__/snapshots.test.ts

@@ -9,7 +9,7 @@
  * git write-tree / read-tree / checkout-index workflow.
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';

package/src/__tests__/standalone-migration.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Standalone Migration Tests
+ *
+ * Source-level checks verifying that microservice-dependent commands
+ * (RestClient, CoreEngineClient, localhost:300X) have been replaced
+ * with standalone CLI/SQLite/generator implementations.
+ *
+ * These are intentionally static — no runtime startup needed.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+
+const ROOT = join(__dirname, '..', '..');
+
+function src(relativePath: string): string {
+  return readFileSync(join(ROOT, relativePath), 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// C1 — generate-terraform: standalone
+// ---------------------------------------------------------------------------
+describe('C1 — generate-terraform standalone', () => {
+  it('has no new RestClient call', () => {
+    expect(src('src/commands/generate-terraform.ts')).not.toContain('new RestClient');
+  });
+  it('imports generateTerraformProject from generator', () => {
+    expect(src('src/commands/generate-terraform.ts')).toContain('generateTerraformProject');
+  });
+  it('has no localhost:300 reference', () => {
+    expect(src('src/commands/generate-terraform.ts')).not.toMatch(/localhost:300\d/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C2 — generate-k8s: standalone
+// ---------------------------------------------------------------------------
+describe('C2 — generate-k8s standalone', () => {
+  it('has no new RestClient call', () => {
+    expect(src('src/commands/generate-k8s.ts')).not.toContain('new RestClient');
+  });
+  it('uses generateManifestsLocally or kubernetes generator', () => {
+    expect(src('src/commands/generate-k8s.ts')).toMatch(/generateManifestsLocally|generateK8sManifests|K8sGeneratorConfig/);
+  });
+  it('has no localhost:300 reference', () => {
+    expect(src('src/commands/generate-k8s.ts')).not.toMatch(/localhost:300\d/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C3 — aws-discover: standalone
+// ---------------------------------------------------------------------------
+describe('C3 — aws-discover standalone', () => {
+  it('has no new RestClient call', () => {
+    expect(src('src/commands/aws-discover.ts')).not.toContain('new RestClient');
+  });
+  it('uses aws configure or execFile for profiles', () => {
+    expect(src('src/commands/aws-discover.ts')).toMatch(/configure|execFile|execFileSync|cliGetAwsProfiles/);
+  });
+  it('has no localhost:300 reference', () => {
+    expect(src('src/commands/aws-discover.ts')).not.toMatch(/localhost:300\d/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C4 — aws-terraform: standalone
+// ---------------------------------------------------------------------------
+describe('C4 — aws-terraform standalone', () => {
+  it('has no new RestClient call', () => {
+    expect(src('src/commands/aws-terraform.ts')).not.toContain('new RestClient');
+  });
+  it('imports generateTerraformProject from generator', () => {
+    expect(src('src/commands/aws-terraform.ts')).toContain('generateTerraformProject');
+  });
+  it('has no localhost:300 reference', () => {
+    expect(src('src/commands/aws-terraform.ts')).not.toMatch(/localhost:300\d/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C5 — resume: standalone
+// ---------------------------------------------------------------------------
+describe('C5 — resume command standalone', () => {
+  it('has no CoreEngineClient import', () => {
+    expect(src('src/commands/resume.ts')).not.toContain('CoreEngineClient');
+  });
+  it('references chatCommand or getDb for session lookup', () => {
+    expect(src('src/commands/resume.ts')).toMatch(/chatCommand|getDb|SessionManager/);
+  });
+  it('has no localhost:300 reference', () => {
+    expect(src('src/commands/resume.ts')).not.toMatch(/localhost:300\d/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C6 — version: DevOps CLI tools (not localhost services)
+// ---------------------------------------------------------------------------
+describe('C6 — version command DevOps tools', () => {
+  it('has no localhost:300 references in fetchComponentVersions', () => {
+    expect(src('src/commands/version.ts')).not.toMatch(/localhost:300\d/);
+  });
+  it('includes terraform version check', () => {
+    expect(src('src/commands/version.ts')).toContain('terraform');
+  });
+  it('includes kubectl version check', () => {
+    expect(src('src/commands/version.ts')).toContain('kubectl');
+  });
+  it('includes helm version check', () => {
+    expect(src('src/commands/version.ts')).toContain('helm');
+  });
+  it('shows [+] / [-] icon format', () => {
+    expect(src('src/commands/version.ts')).toMatch(/\[\+\]|\[-\]/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C7 — drift: no CoreEngineClient
+// ---------------------------------------------------------------------------
+describe('C7 — drift no CoreEngineClient', () => {
+  it('drift/index.ts has no CoreEngineClient import', () => {
+    const content = src('src/commands/drift/index.ts');
+    // Must not have an import statement (comments are fine)
+    expect(content).not.toMatch(/^import.*CoreEngineClient/m);
+  });
+  it('drift/index.ts uses execFileSync or execFile for terraform', () => {
+    expect(src('src/commands/drift/index.ts')).toMatch(/execFileSync|execFile|spawnExec/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C8 — dead client code deleted/stubbed
+// ---------------------------------------------------------------------------
+describe('C8 — dead client code', () => {
+  it('service-discovery.ts is either deleted or a stub without ghost URLs', () => {
+    try {
+      const content = src('src/clients/service-discovery.ts');
+      // If it exists, it must not contain the old ghost localhost service URLs
+      expect(content).not.toContain('localhost:3001');
+      expect(content).not.toContain('localhost:3003');
+      expect(content).not.toContain('localhost:3009');
+    } catch {
+      // File deleted — that's fine
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H1 — Emoji removed, replaced with ASCII icons
+// ---------------------------------------------------------------------------
+describe('H1 — emoji removed from UI', () => {
+  it('TreePane.tsx has no folder emoji', () => {
+    expect(src('src/ui/TreePane.tsx')).not.toContain('\u{1F4C1}'); // 📁
+  });
+  it('TreePane.tsx uses [/] for directories', () => {
+    expect(src('src/ui/TreePane.tsx')).toContain('[/]');
+  });
+  it('TerminalPane.tsx has no right-pointing triangle', () => {
+    expect(src('src/ui/TerminalPane.tsx')).not.toContain('\u25B6'); // ▶
+  });
+  it('TerminalPane.tsx uses [>] icon', () => {
+    expect(src('src/ui/TerminalPane.tsx')).toContain('[>]');
+  });
+  it('StatusBar.tsx has no Greek capital delta (Δ)', () => {
+    expect(src('src/ui/StatusBar.tsx')).not.toContain('\u0394'); // Δ
+  });
+  it('StatusBar.tsx uses delta: text', () => {
+    expect(src('src/ui/StatusBar.tsx')).toContain('delta:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M1 — Secret redaction in spawn-exec
+// ---------------------------------------------------------------------------
+describe('M1 — secret redaction in spawn-exec', () => {
+  it('spawn-exec.ts has SECRET_PATTERNS constant', () => {
+    expect(src('src/tools/spawn-exec.ts')).toContain('SECRET_PATTERNS');
+  });
+  it('spawn-exec.ts has redactSecrets function', () => {
+    expect(src('src/tools/spawn-exec.ts')).toContain('redactSecrets');
+  });
+  it('spawn-exec.ts redacts AKIA keys', () => {
+    expect(src('src/tools/spawn-exec.ts')).toContain('AKIA');
+  });
+  it('spawn-exec.ts redacts Bearer tokens', () => {
+    expect(src('src/tools/spawn-exec.ts')).toContain('Bearer');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M2 — Doctor shows inline versions
+// ---------------------------------------------------------------------------
+describe('M2 — doctor inline versions', () => {
+  it('doctor.ts references version in available tools output', () => {
+    // The available list should include t.version or similar version string
+    const content = src('src/commands/doctor.ts');
+    expect(content).toMatch(/t\.version|tool\.version|\.version\b/);
+  });
+});

package/src/__tests__/state-db.test.ts

@@ -10,7 +10,7 @@
  * is never touched, and tests are fully isolated and fast.
  */
 
-import { describe, it, expect, beforeEach } from 'bun:test';
+import { describe, it, expect, beforeEach } from 'vitest';
 import type { Database } from '../compat/sqlite';
 import { getTestDb } from '../state/db';
 import {

package/src/__tests__/status.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for the nimbus status command (G18).
+ *
+ * The statusCommand runs concurrent CLI checks. We test the module structure
+ * and basic argument parsing rather than the actual CLI calls to avoid
+ * platform dependencies.
+ */
+
+import { describe, test, expect } from 'vitest';
+import { statusCommand, type StatusOptions } from '../commands/status';
+
+describe('statusCommand (G18)', () => {
+  test('exports statusCommand function', () => {
+    expect(typeof statusCommand).toBe('function');
+  });
+
+  test('StatusOptions accepts json flag', () => {
+    const opts: StatusOptions = { json: true };
+    expect(opts.json).toBe(true);
+  });
+
+  test('StatusOptions json defaults to undefined', () => {
+    const opts: StatusOptions = {};
+    expect(opts.json).toBeUndefined();
+  });
+
+  test('statusCommand resolves without throwing when CLIs are unavailable', async () => {
+    // Mock console.log to suppress output in test
+    const original = console.log;
+    const logs: string[] = [];
+    console.log = (msg: string) => logs.push(msg);
+
+    try {
+      // Should not throw even if kubectl/terraform/aws/gcloud are not installed
+      // (the command catches errors gracefully)
+      await expect(statusCommand({ json: true })).resolves.toBeUndefined();
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('statusCommand with json option outputs valid JSON', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      // Should produce valid JSON
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed).toBeTypeOf('object');
+      // Should have an errors array
+      expect(Array.isArray(parsed.errors)).toBe(true);
+    } finally {
+      console.log = original;
+    }
+  });
+});
+
+describe('statusCommand C2 enhancements', () => {
+  test('JSON output includes model field with default fallback', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      // model should be set (either from config.json or default 'claude-sonnet-4-6')
+      expect(typeof parsed.model).toBe('string');
+      expect((parsed.model as string).length).toBeGreaterThan(0);
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('JSON output includes provider field with default fallback', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      // provider should be set (either from config.json or default 'anthropic')
+      expect(typeof parsed.provider).toBe('string');
+      expect((parsed.provider as string).length).toBeGreaterThan(0);
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('JSON output includes nimbusMdFound field', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      // nimbusMdFound should be a boolean (true or undefined/false)
+      expect(
+        parsed.nimbusMdFound === undefined || typeof parsed.nimbusMdFound === 'boolean'
+      ).toBe(true);
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('JSON output includes sessionCount field', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      // sessionCount should be a number or 'N/A'
+      expect(
+        typeof parsed.sessionCount === 'number' || parsed.sessionCount === 'N/A'
+      ).toBe(true);
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('default model is claude-sonnet-4-6 when config.json is absent', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    // We can test this by verifying the model is never empty
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      // Model should be a non-empty string
+      expect(typeof parsed.model).toBe('string');
+      expect((parsed.model as string).length).toBeGreaterThan(0);
+    } finally {
+      console.log = original;
+    }
+  });
+
+  test('default provider is anthropic when config.json is absent', async () => {
+    const original = console.log;
+    let jsonOutput = '';
+    console.log = (msg: string) => { jsonOutput = msg; };
+
+    try {
+      await statusCommand({ json: true });
+      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
+      expect(typeof parsed.provider).toBe('string');
+      expect((parsed.provider as string).length).toBeGreaterThan(0);
+    } finally {
+      console.log = original;
+    }
+  });
+});

package/src/__tests__/stream-with-tools.test.ts

@@ -14,7 +14,7 @@
  * All tests use mocks -- no real API calls are made.
  */
 
-import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { describe, test, it, expect, vi, beforeEach } from 'vitest';
 import type { ToolCompletionRequest, StreamChunk } from '../llm/types';
 
 // ---------------------------------------------------------------------------
@@ -120,7 +120,7 @@ describe('OllamaProvider.streamWithTools', () => {
       'data: [DONE]\n\n',
     ];
 
-    globalThis.fetch = mock(() =>
+    globalThis.fetch = vi.fn(() =>
       Promise.resolve(
         new Response(buildReadableStream(sseLines), {
           status: 200,
@@ -170,7 +170,7 @@ describe('OllamaProvider.streamWithTools', () => {
       'data: [DONE]\n\n',
     ];
 
-    globalThis.fetch = mock(() =>
+    globalThis.fetch = vi.fn(() =>
       Promise.resolve(
         new Response(buildReadableStream(sseLines), {
           status: 200,
@@ -202,7 +202,7 @@ describe('OllamaProvider.streamWithTools', () => {
   test('fallback: when native streaming fails, falls back to completeWithTools', async () => {
     let _callCount = 0;
 
-    globalThis.fetch = mock((url: string | URL | Request) => {
+    globalThis.fetch = vi.fn((url: string | URL | Request) => {
       _callCount++;
       const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
 
@@ -268,7 +268,7 @@ describe('OllamaProvider.streamWithTools', () => {
       'data: [DONE]\n\n',
     ];
 
-    globalThis.fetch = mock(() =>
+    globalThis.fetch = vi.fn(() =>
       Promise.resolve(
         new Response(buildReadableStream(sseLines), {
           status: 200,
@@ -311,7 +311,7 @@ describe('OpenRouterProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
     const { OpenRouterProvider } = await import('../llm/providers/openrouter');
     const provider = new OpenRouterProvider('test-api-key');
@@ -392,7 +392,7 @@ describe('OpenRouterProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
     const { OpenRouterProvider } = await import('../llm/providers/openrouter');
     const provider = new OpenRouterProvider('test-api-key');
@@ -415,7 +415,7 @@ describe('OpenRouterProvider.streamWithTools', () => {
   });
 
   test('fallback: when SDK stream creation throws, the generator yields nothing', async () => {
-    const mockCreate = mock(() => Promise.reject(new Error('API unavailable')));
+    const mockCreate = vi.fn(() => Promise.reject(new Error('API unavailable')));
 
     const { OpenRouterProvider } = await import('../llm/providers/openrouter');
     const provider = new OpenRouterProvider('test-api-key');
@@ -462,7 +462,7 @@ describe('OpenRouterProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
     const { OpenRouterProvider } = await import('../llm/providers/openrouter');
     const provider = new OpenRouterProvider('test-api-key');
@@ -495,10 +495,8 @@ describe('OpenRouterProvider.streamWithTools', () => {
 // ===========================================================================
 
 describe('OpenAICompatibleProvider.streamWithTools', () => {
-  function createProvider() {
-    // Dynamic import to avoid module-level side effects
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { OpenAICompatibleProvider } = require('../llm/providers/openai-compatible');
+  async function createProvider() {
+    const { OpenAICompatibleProvider } = await import('../llm/providers/openai-compatible');
     return new OpenAICompatibleProvider({
       name: 'test-compat',
       apiKey: 'test-key',
@@ -517,9 +515,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -578,9 +576,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -600,9 +598,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
   });
 
   test('fallback: when SDK stream creation throws, the error propagates', async () => {
-    const mockCreate = mock(() => Promise.reject(new Error('Provider down')));
+    const mockCreate = vi.fn(() => Promise.reject(new Error('Provider down')));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -655,9 +653,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -686,9 +684,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
       },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -709,9 +707,9 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
       { choices: [{ delta: { content: 'done' }, finish_reason: 'stop' }] },
     ]);
 
-    const mockCreate = mock(() => Promise.resolve(streamChunks));
+    const mockCreate = vi.fn(() => Promise.resolve(streamChunks));
 
-    const provider = createProvider();
+    const provider = await createProvider();
     (provider as any).client = {
       chat: { completions: { create: mockCreate } },
     };
@@ -730,3 +728,51 @@ describe('OpenAICompatibleProvider.streamWithTools', () => {
     expect(createArg.max_tokens).toBe(1024);
   });
 });
+
+// ---------------------------------------------------------------------------
+// PERF-2c: Unbuffered streaming in LLMRouter fallback branch
+// ---------------------------------------------------------------------------
+
+describe('PERF-2c: LLMRouter unbuffered streaming', () => {
+  it('streamWithTools fallback loop no longer buffers chunks before yielding', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/llm/router.ts'), 'utf-8');
+    // Extract only the streamWithTools section (between the streamWithTools guards)
+    const swStart = src.indexOf('Use native streaming-with-tools if providers support it');
+    const swEnd = src.indexOf('If all providers with streamWithTools failed', swStart);
+    const swSection = swStart > 0 && swEnd > swStart ? src.slice(swStart, swEnd) : '';
+    // The streamWithTools fallback section should NOT contain buffering
+    expect(swSection).not.toContain('bufferedChunks');
+    // It should contain yield chunk directly
+    expect(swSection).toContain('yield chunk;');
+  });
+
+  it('router.ts yields each chunk immediately inside the for-await loop', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/llm/router.ts'), 'utf-8');
+    // The yield statement should appear inside the for-await (before circuitBreaker.recordSuccess)
+    expect(src).toContain('yield chunk;');
+    // circuitBreaker.recordSuccess comes after the loop ends (done chunk received)
+    expect(src).toContain('circuitBreaker.recordSuccess(p.name);');
+  });
+
+  it('circuitBreaker.recordSuccess is called after stream ends (not before yield)', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/llm/router.ts'), 'utf-8');
+    // Find the fallback for-loop block that has yield chunk
+    const yieldIdx = src.indexOf('yield chunk;');
+    const recordSuccessIdx = src.indexOf('circuitBreaker.recordSuccess(p.name);');
+    // recordSuccess should appear AFTER the yield in the source
+    expect(recordSuccessIdx).toBeGreaterThan(yieldIdx);
+  });
+
+  it('stream error path still calls circuitBreaker.recordFailure', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/llm/router.ts'), 'utf-8');
+    expect(src).toContain('circuitBreaker.recordFailure(p.name);');
+  });
+});

package/src/__tests__/subagents.test.ts

@@ -5,7 +5,7 @@
  * the @agent mention parser.
  */
 
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect } from 'vitest';
 import {
   createSubagent,
   parseAgentMention,