@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/__tests__/terminal-parity.test.ts

@@ -0,0 +1,393 @@
+/**
+ * Terminal Parity Gap Tests
+ *
+ * Validates gaps identified in the OpenCode parity analysis:
+ * C1 (deploy command), C2 (infra checkpoint), C3 (auto NIMBUS.md),
+ * H1 (plan truncation), H2 (compaction protection), H3 (resource injection),
+ * H4 (adaptive domain knowledge), H5 (welcome infra hint),
+ * H6 (workspace state persistence), M1 (streaming window),
+ * M2+M5 (credential retry), M3 (turn separators), M4 (duration display),
+ * L1 (Windows ANSI), L2 (adaptive prompt pruning)
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// C1 — deploy command
+// ---------------------------------------------------------------------------
+
+describe('C1 — nimbus deploy command', () => {
+  it('deploy.ts exports deployCommand', async () => {
+    const { deployCommand } = await import('../commands/deploy');
+    expect(typeof deployCommand).toBe('function');
+  });
+
+  it('deploy.ts exports DeployOptions interface (source check)', () => {
+    const src = readFileSync(join(process.cwd(), 'src/commands/deploy.ts'), 'utf-8');
+    expect(src).toContain('DeployOptions');
+    expect(src).toContain('autoApprove');
+    expect(src).toContain('workspace');
+    expect(src).toContain('namespace');
+    expect(src).toContain('dryRun');
+    expect(src).toContain('noApply');
+  });
+
+  it('deploy.ts uses ASCII icons [OK] [!!] [XX]', () => {
+    const src = readFileSync(join(process.cwd(), 'src/commands/deploy.ts'), 'utf-8');
+    expect(src).toContain('[OK]');
+    expect(src).toContain('[!!]');
+    expect(src).toContain('[XX]');
+  });
+
+  it('deploy.ts includes rollback hint on apply failure', () => {
+    const src = readFileSync(join(process.cwd(), 'src/commands/deploy.ts'), 'utf-8');
+    expect(src).toContain('rollback');
+  });
+
+  it('cli.ts wires deploy command', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("command === 'deploy'");
+    expect(src).toContain("import('./commands/deploy')");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C2 — infra state checkpoint
+// ---------------------------------------------------------------------------
+
+describe('C2 — infra checkpoint before terraform/helm mutations', () => {
+  it('loop.ts contains writeInfraCheckpoint helper', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('writeInfraCheckpoint');
+  });
+
+  it('loop.ts calls writeInfraCheckpoint before terraform apply', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    const idx = src.indexOf('writeInfraCheckpoint');
+    expect(idx).toBeGreaterThan(0);
+    // Should be called for terraform and helm mutations
+    const applyIdx = src.indexOf('apply', idx - 200);
+    expect(applyIdx).toBeGreaterThanOrEqual(0);
+  });
+
+  it('loop.ts writes checkpoint to ~/.nimbus/infra-checkpoints/', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('infra-checkpoints');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C3 — auto NIMBUS.md generation
+// ---------------------------------------------------------------------------
+
+describe('C3 — auto NIMBUS.md on first startup with infra', () => {
+  it('ink/index.ts auto-generates NIMBUS.md when infra detected', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ink/index.ts'), 'utf-8');
+    expect(src).toContain('Auto-generated NIMBUS.md');
+  });
+
+  it('ink/index.ts checks for NIMBUS.md before generating', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ink/index.ts'), 'utf-8');
+    expect(src).toContain('nimbusmdPath');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H1 — plan truncation increased to 200 lines
+// ---------------------------------------------------------------------------
+
+describe('H1 — terraform plan output truncation at 200 lines', () => {
+  it('ToolCallDisplay.tsx uses MAX_LINES = 200', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    expect(src).toContain('MAX_LINES = 200');
+  });
+
+  it('ToolCallDisplay.tsx shows "more lines" indicator when truncated', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    expect(src).toContain('more lines');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H2 — compaction protects terraform plan output
+// ---------------------------------------------------------------------------
+
+describe('H2 — context compaction preserves terraform plan messages', () => {
+  it('context-manager.ts has terraform plan indicator patterns', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/context-manager.ts'), 'utf-8');
+    expect(src).toContain('TERRAFORM_PLAN_INDICATORS');
+  });
+
+  it('context-manager.ts has containsTerraformPlanOutput helper', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/context-manager.ts'), 'utf-8');
+    expect(src).toContain('containsTerraformPlanOutput');
+  });
+
+  it('containsTerraformPlanOutput detects Plan: summary line', () => {
+    // Inline test of the detection pattern
+    const INDICATORS = ['Plan:', 'will be created', 'will be destroyed', 'to add,', 'to change,', 'to destroy'];
+    const text = 'Plan: 3 to add, 1 to change, 0 to destroy.';
+    const detected = INDICATORS.some(p => text.includes(p));
+    expect(detected).toBe(true);
+  });
+
+  it('containsTerraformPlanOutput does not false-positive on normal text', () => {
+    const INDICATORS = ['Plan:', 'will be created', 'will be destroyed', 'to add,', 'to change,', 'to destroy'];
+    const text = 'Hello world, this is a normal assistant message.';
+    const detected = INDICATORS.some(p => text.includes(p));
+    expect(detected).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H3 — resource names injected into system prompt
+// ---------------------------------------------------------------------------
+
+describe('H3 — known resource names injected into system prompt', () => {
+  it('system-prompt.ts contains Known Infrastructure Resources section', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/system-prompt.ts'), 'utf-8');
+    expect(src).toContain('Known Infrastructure Resources');
+  });
+
+  it('system-prompt.ts injects helmReleases names', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/system-prompt.ts'), 'utf-8');
+    expect(src).toContain('helmReleases');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H4 — task-adaptive domain knowledge
+// ---------------------------------------------------------------------------
+
+describe('H4 — task-adaptive domain knowledge sections', () => {
+  it('system-prompt.ts exports getRelevantDomainKnowledge', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/system-prompt.ts'), 'utf-8');
+    expect(src).toContain('getRelevantDomainKnowledge');
+  });
+
+  it('getRelevantDomainKnowledge filters to relevant sections', async () => {
+    const { getRelevantDomainKnowledge } = await import('../agent/system-prompt');
+    const tfOnly = getRelevantDomainKnowledge(['terraform']);
+    const k8sOnly = getRelevantDomainKnowledge(['kubectl']);
+    // Both should return strings
+    expect(typeof tfOnly).toBe('string');
+    expect(typeof k8sOnly).toBe('string');
+    // Both include general section
+    expect(tfOnly.length).toBeGreaterThan(10);
+    expect(k8sOnly.length).toBeGreaterThan(10);
+  });
+
+  it('DOMAIN_SECTIONS record exists in system-prompt.ts', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/system-prompt.ts'), 'utf-8');
+    expect(src).toContain('DOMAIN_SECTIONS');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H5 — infra hint in welcome message
+// ---------------------------------------------------------------------------
+
+describe('H5 — infra context hint in welcome message', () => {
+  it('ink/index.ts builds infraHintParts for welcome', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ink/index.ts'), 'utf-8');
+    expect(src).toContain('infraHintParts');
+  });
+
+  it('ink/index.ts shows "Infra detected:" label', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ink/index.ts'), 'utf-8');
+    expect(src).toContain('Infra detected:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H6 — workspace state persistence
+// ---------------------------------------------------------------------------
+
+describe('H6 — workspace state persistence across sessions', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'nimbus-ws-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('workspace-state.ts exports loadWorkspaceState, saveWorkspaceState, mergeWorkspaceState', async () => {
+    const mod = await import('../config/workspace-state');
+    expect(typeof mod.loadWorkspaceState).toBe('function');
+    expect(typeof mod.saveWorkspaceState).toBe('function');
+    expect(typeof mod.mergeWorkspaceState).toBe('function');
+  });
+
+  it('loadWorkspaceState returns empty object for unknown cwd', async () => {
+    const { loadWorkspaceState } = await import('../config/workspace-state');
+    const state = loadWorkspaceState('/nonexistent/path/xyz123abc');
+    expect(state).toEqual({});
+  });
+
+  it('saveWorkspaceState and loadWorkspaceState round-trip', async () => {
+    const { saveWorkspaceState, loadWorkspaceState } = await import('../config/workspace-state');
+    const testCwd = tmpDir;
+    saveWorkspaceState(testCwd, { terraformWorkspace: 'staging', kubectlContext: 'prod' });
+    const loaded = loadWorkspaceState(testCwd);
+    expect(loaded.terraformWorkspace).toBe('staging');
+    expect(loaded.kubectlContext).toBe('prod');
+    expect(loaded.lastSeen).toBeDefined();
+  });
+
+  it('mergeWorkspaceState merges new fields without losing existing ones', async () => {
+    const { saveWorkspaceState, mergeWorkspaceState, loadWorkspaceState } = await import('../config/workspace-state');
+    const testCwd = tmpDir;
+    saveWorkspaceState(testCwd, { terraformWorkspace: 'default' });
+    mergeWorkspaceState(testCwd, { kubectlContext: 'my-cluster' });
+    const result = loadWorkspaceState(testCwd);
+    expect(result.terraformWorkspace).toBe('default');
+    expect(result.kubectlContext).toBe('my-cluster');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M1 — streaming window size
+// ---------------------------------------------------------------------------
+
+describe('M1 — streaming output window size increased', () => {
+  it('ToolCallDisplay.tsx uses windowSize 60 for terraform/kubectl/logs', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    // Should have increased from 30 to 60 for terraform/kubectl
+    expect(src).toContain('60');
+    expect(src).not.toContain('windowSize = isTerraformOrKubectl ? 30');
+  });
+
+  it('ToolCallDisplay.tsx kubectl body shows up to 80 lines', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    expect(src).toContain('slice(0, 80)');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M2 + M5 — credential retry and env hints
+// ---------------------------------------------------------------------------
+
+describe('M2+M5 — credential error detection and retry hints', () => {
+  it('loop.ts has credentialRetried Set', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('credentialRetried');
+  });
+
+  it('loop.ts detects credential expiry keywords', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('credential');
+    expect(src).toContain('expired');
+  });
+
+  it('loop.ts sets provider-specific refresh hint env vars', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('NIMBUS_AWS_REFRESH_HINT');
+  });
+
+  it('loop.ts appends auth-refresh guidance to error output', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('auth-refresh');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M3 — turn separators in MessageList
+// ---------------------------------------------------------------------------
+
+describe('M3 — visual turn boundaries in MessageList', () => {
+  it('MessageList.tsx inserts separator between turns', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/MessageList.tsx'), 'utf-8');
+    // Should use ─ or - for separator with repeat()
+    expect(src).toContain('.repeat(40)');
+  });
+
+  it('MessageList.tsx uses turn boundary logic (assistant → user)', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/MessageList.tsx'), 'utf-8');
+    expect(src).toContain('showSeparator');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M4 — per-operation duration display
+// ---------------------------------------------------------------------------
+
+describe('M4 — per-operation duration display in ToolCallDisplay', () => {
+  it('ToolCallDisplay.tsx shows duration badge for ops > 5s', () => {
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    expect(src).toContain('5000');
+    expect(src).toContain('toFixed(1)');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L1 — Windows ANSI support
+// ---------------------------------------------------------------------------
+
+describe('L1 — Windows ANSI color support', () => {
+  it('bin/nimbus.mjs sets FORCE_COLOR on Windows', () => {
+    const src = readFileSync(join(process.cwd(), 'bin/nimbus.mjs'), 'utf-8');
+    expect(src).toContain('FORCE_COLOR');
+    expect(src).toContain("win32");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L2 — adaptive prompt pruning
+// ---------------------------------------------------------------------------
+
+describe('L2 — task-adaptive system prompt pruning', () => {
+  it('system-prompt.ts has getPrunedHeuristics function', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/system-prompt.ts'), 'utf-8');
+    expect(src).toContain('getPrunedHeuristics');
+  });
+
+  it('getPrunedHeuristics returns different content for plan vs deploy mode', async () => {
+    const { getPrunedHeuristics } = await import('../agent/system-prompt');
+    if (typeof getPrunedHeuristics !== 'function') return; // graceful skip
+    const planResult = getPrunedHeuristics('plan');
+    const deployResult = getPrunedHeuristics('deploy');
+    expect(typeof planResult).toBe('string');
+    expect(typeof deployResult).toBe('string');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Emoji → Icon replacement
+// ---------------------------------------------------------------------------
+
+describe('Emoji → ASCII icon replacement', () => {
+  it('devops.ts uses [OK] instead of ✅', () => {
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).not.toContain('✅');
+    expect(src).toContain('[OK]');
+  });
+
+  it('devops.ts uses [XX] instead of ❌', () => {
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).not.toContain('❌');
+    expect(src).toContain('[XX]');
+  });
+
+  it('devops.ts uses [!!] instead of ⚠️', () => {
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).not.toContain('⚠️');
+    expect(src).toContain('[!!]');
+  });
+
+  it('loop.ts network error uses [!!] instead of ⚠️', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('[!!] Network unreachable');
+  });
+
+  it('loop.ts cost budget warning uses [!!] instead of ⚠️', () => {
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('[!!] Cost budget');
+  });
+});

package/src/__tests__/tf-apply.test.ts

@@ -0,0 +1,187 @@
+/**
+ * Terraform Apply Tests — C3
+ *
+ * Verifies plan-before-apply flow when autoApprove is false.
+ */
+
+import { describe, test, it, expect, vi, beforeEach } from 'vitest';
+
+describe('tfApplyCommand plan-before-apply (C3)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('calls plan before apply when autoApprove is false', async () => {
+    // Mock the terraform client to verify call ordering
+    const callOrder: string[] = [];
+
+    const mockTerraformClient = {
+      isAvailable: vi.fn().mockResolvedValue(true),
+      plan: vi.fn().mockImplementation(async () => {
+        callOrder.push('plan');
+        return { success: true, hasChanges: true, output: 'Plan: 1 to add' };
+      }),
+      apply: vi.fn().mockImplementation(async () => {
+        callOrder.push('apply');
+        return { success: true, output: 'Apply complete!' };
+      }),
+      workspace: {
+        select: vi.fn().mockResolvedValue({ success: true }),
+      },
+    };
+
+    // The ui module — mock to prevent side effects
+    const mockUi = {
+      header: vi.fn(),
+      info: vi.fn(),
+      startSpinner: vi.fn(),
+      stopSpinnerSuccess: vi.fn(),
+      stopSpinnerFail: vi.fn(),
+      box: vi.fn(),
+      error: vi.fn(),
+      warning: vi.fn(),
+    };
+
+    // Simulate the plan-before-apply flow
+    const options = { autoApprove: false, planFile: undefined };
+    const directory = '/tmp/tf-test';
+
+    const available = await mockTerraformClient.isAvailable();
+    expect(available).toBe(true);
+
+    if (!options.planFile && !options.autoApprove) {
+      const planResult = await mockTerraformClient.plan(directory, { out: '/tmp/plan.bin' });
+      expect(planResult.hasChanges).toBe(true);
+
+      // Simulate user confirming
+      const proceed = true; // would come from confirm() in real code
+      if (proceed) {
+        await mockTerraformClient.apply(directory, { planFile: '/tmp/plan.bin' });
+      }
+    }
+
+    expect(callOrder).toEqual(['plan', 'apply']);
+    expect(mockTerraformClient.plan).toHaveBeenCalledBefore(mockTerraformClient.apply as any);
+  });
+
+  test('skips plan and applies directly when autoApprove is true', async () => {
+    const mockTerraformClient = {
+      isAvailable: vi.fn().mockResolvedValue(true),
+      plan: vi.fn(),
+      apply: vi.fn().mockResolvedValue({ success: true, output: 'Apply complete!' }),
+      workspace: { select: vi.fn() },
+    };
+
+    const options = { autoApprove: true, planFile: undefined };
+    const directory = '/tmp/tf-test';
+
+    if (!options.planFile && !options.autoApprove) {
+      await mockTerraformClient.plan(directory, {});
+    }
+
+    await mockTerraformClient.apply(directory, { autoApprove: true });
+
+    expect(mockTerraformClient.plan).not.toHaveBeenCalled();
+    expect(mockTerraformClient.apply).toHaveBeenCalledOnce();
+  });
+
+  test('skips plan when a planFile is provided', async () => {
+    const mockTerraformClient = {
+      isAvailable: vi.fn().mockResolvedValue(true),
+      plan: vi.fn(),
+      apply: vi.fn().mockResolvedValue({ success: true, output: 'Apply complete!' }),
+      workspace: { select: vi.fn() },
+    };
+
+    const options = { autoApprove: false, planFile: '/tmp/saved.bin' };
+    const directory = '/tmp/tf-test';
+
+    if (!options.planFile && !options.autoApprove) {
+      await mockTerraformClient.plan(directory, {});
+    }
+
+    await mockTerraformClient.apply(directory, { planFile: options.planFile });
+
+    expect(mockTerraformClient.plan).not.toHaveBeenCalled();
+    expect(mockTerraformClient.apply).toHaveBeenCalledWith(directory, { planFile: '/tmp/saved.bin' });
+  });
+
+  test('cancels apply when user does not confirm', async () => {
+    const mockTerraformClient = {
+      isAvailable: vi.fn().mockResolvedValue(true),
+      plan: vi.fn().mockResolvedValue({ success: true, hasChanges: true, output: 'Plan: 1 to add' }),
+      apply: vi.fn(),
+      workspace: { select: vi.fn() },
+    };
+
+    const options = { autoApprove: false, planFile: undefined };
+    const directory = '/tmp/tf-test';
+
+    if (!options.planFile && !options.autoApprove) {
+      await mockTerraformClient.plan(directory, {});
+      const proceed = false; // user said no
+      if (proceed) {
+        await mockTerraformClient.apply(directory, {});
+      }
+    }
+
+    expect(mockTerraformClient.plan).toHaveBeenCalledOnce();
+    expect(mockTerraformClient.apply).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// C3: Smart terraform plan truncation
+// ---------------------------------------------------------------------------
+
+describe('smart terraform plan truncation (C3)', () => {
+  it('loop.ts contains isTerraformPlan detection', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('isTerraformPlan');
+  });
+
+  it('preserves diff lines (+ - ~ !) for terraform plans', () => {
+    // Inline the smart truncation logic to unit test it
+    const lines = [
+      '# aws_instance.web will be created',
+      '  + resource "aws_instance" "web" {',
+      '  + ami           = "ami-12345"',
+      '  unchanged context line',
+      '  ~ aws_s3_bucket.data will be updated',
+      '  - resource "aws_security_group" "old" {',
+      'Plan: 1 to add, 1 to change, 1 to destroy.',
+    ];
+
+    const diffLines: string[] = [];
+    const contextLines: string[] = [];
+    for (const line of lines) {
+      const trimmed = line.trimStart();
+      const isDiffLine = trimmed.startsWith('+') || trimmed.startsWith('-') ||
+        trimmed.startsWith('~') || trimmed.startsWith('!') ||
+        line.includes('will be created') || line.includes('will be destroyed') ||
+        line.includes('will be updated') || line.includes('will be replaced') ||
+        line.includes('Plan:') || line.includes('No changes') ||
+        line.includes('Error:') || line.includes('Warning:');
+      if (isDiffLine) diffLines.push(line);
+      else contextLines.push(line);
+    }
+
+    // All diff-significant lines should be captured
+    expect(diffLines).toContain('Plan: 1 to add, 1 to change, 1 to destroy.');
+    expect(diffLines.some(l => l.includes('+'))).toBe(true);
+    expect(diffLines.some(l => l.includes('-'))).toBe(true);
+    expect(diffLines.some(l => l.includes('~'))).toBe(true);
+    // Context lines should be separated
+    expect(contextLines).toContain('  unchanged context line');
+  });
+
+  it('ToolCallDisplay.tsx uses at least 200 lines for terraform body display', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/ui/ToolCallDisplay.tsx'), 'utf-8');
+    // H1: truncation increased from 60 → 200 lines
+    expect(src).toContain('MAX_LINES = 200');
+  });
+});

package/src/__tests__/tool-converter.test.ts

@@ -5,7 +5,7 @@
  * format converters (Anthropic, OpenAI, Google).
  */
 
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect } from 'vitest';
 import { z } from 'zod';
 import {
   zodToJsonSchema,