@iservu-inc/adf-cli 0.17.1 → 0.18.0

package/tests/harness-milestone-tracker.test.js

@@ -0,0 +1,158 @@
+const fs = require('fs-extra');
+const path = require('path');
+const MilestoneTracker = require('../lib/harness/milestone-tracker');
+
+describe('MilestoneTracker', () => {
+  const tempDir = path.join(__dirname, 'temp-milestone-test');
+  let tracker;
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+    tracker = new MilestoneTracker(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  const sampleBlocks = [
+    {
+      title: 'Project Overview',
+      number: 1,
+      questions: [{ id: 'q1' }, { id: 'q2' }]
+    },
+    {
+      title: 'Technical Architecture',
+      number: 2,
+      questions: [{ id: 'q3' }, { id: 'q4' }, { id: 'q5' }]
+    },
+    {
+      title: 'Deployment',
+      number: 3,
+      questions: [{ id: 'q6' }]
+    }
+  ];
+
+  test('should generate milestones from blocks', async () => {
+    const milestones = await tracker.generateFromBlocks(sampleBlocks);
+    expect(milestones.length).toBe(3);
+    expect(milestones[0].title).toBe('Project Overview');
+    expect(milestones[0].questionsInScope).toEqual(['q1', 'q2']);
+    expect(milestones[1].questionsInScope).toEqual(['q3', 'q4', 'q5']);
+  });
+
+  test('should track question completion', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    const ms = await tracker.completeQuestion('q1');
+    expect(ms.questionsCompleted).toContain('q1');
+    expect(ms.percentage).toBe(50);
+    expect(ms.status).toBe('in_progress');
+  });
+
+  test('should complete milestone when all questions done', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    await tracker.completeQuestion('q1');
+    const ms = await tracker.completeQuestion('q2');
+    expect(ms.status).toBe('completed');
+    expect(ms.percentage).toBe(100);
+    expect(ms.completedAt).toBeDefined();
+  });
+
+  test('should not duplicate completed questions', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    await tracker.completeQuestion('q1');
+    await tracker.completeQuestion('q1');
+    const ms = tracker.getAll()[0];
+    expect(ms.questionsCompleted.length).toBe(1);
+  });
+
+  test('should skip milestone', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    const ms = await tracker.skipMilestone(1);
+    expect(ms.status).toBe('skipped');
+  });
+
+  test('should throw on invalid skip index', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+    await expect(tracker.skipMilestone(10)).rejects.toThrow('Invalid milestone index');
+  });
+
+  test('should get current milestone', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    const current = tracker.getCurrentMilestone();
+    expect(current.title).toBe('Project Overview');
+
+    // Complete first milestone
+    await tracker.completeQuestion('q1');
+    await tracker.completeQuestion('q2');
+
+    const next = tracker.getCurrentMilestone();
+    expect(next.title).toBe('Technical Architecture');
+  });
+
+  test('should return null when all milestones complete', async () => {
+    await tracker.generateFromBlocks([
+      { title: 'Only Block', number: 1, questions: [{ id: 'q1' }] }
+    ]);
+
+    await tracker.completeQuestion('q1');
+    expect(tracker.getCurrentMilestone()).toBeNull();
+  });
+
+  test('should calculate overall progress', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+
+    let progress = tracker.getProgress();
+    expect(progress.total).toBe(3);
+    expect(progress.completed).toBe(0);
+    expect(progress.pending).toBe(3);
+    expect(progress.percentage).toBe(0);
+
+    // Complete first milestone
+    await tracker.completeQuestion('q1');
+    await tracker.completeQuestion('q2');
+
+    progress = tracker.getProgress();
+    expect(progress.completed).toBe(1);
+    expect(progress.percentage).toBe(33);
+  });
+
+  test('should provide handoff info', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+    await tracker.completeQuestion('q1');
+
+    const info = tracker.getHandoffInfo();
+    expect(info.title).toBe('Project Overview');
+    expect(info.percentage).toBe(50);
+  });
+
+  test('should save and load milestones', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+    await tracker.completeQuestion('q1');
+
+    // Create new tracker and load
+    const tracker2 = new MilestoneTracker(tempDir);
+    const loaded = await tracker2.load();
+    expect(loaded).toBe(true);
+
+    const milestones = tracker2.getAll();
+    expect(milestones.length).toBe(3);
+    expect(milestones[0].questionsCompleted).toContain('q1');
+  });
+
+  test('should return false when no milestones to load', async () => {
+    const loaded = await tracker.load();
+    expect(loaded).toBe(false);
+  });
+
+  test('should return null for unknown question', async () => {
+    await tracker.generateFromBlocks(sampleBlocks);
+    const result = await tracker.completeQuestion('q_unknown');
+    expect(result).toBeNull();
+  });
+});

package/tests/harness-protocol.test.js

@@ -0,0 +1,341 @@
+const {
+  HarnessRun,
+  ContextWindow,
+  HandoffPackage,
+  Milestone,
+  Event,
+  FeatureManifest,
+  ProviderCapability,
+  PROVIDER_CAPABILITIES,
+  VALID_RUN_STATUSES,
+  VALID_EVENT_TYPES
+} = require('../lib/harness/protocol');
+
+describe('Harness Protocol', () => {
+
+  describe('HarnessRun', () => {
+    test('should create with defaults', () => {
+      const run = new HarnessRun();
+      expect(run.id).toMatch(/^run_/);
+      expect(run.version).toBe('1.0.0');
+      expect(run.status).toBe('initializing');
+      expect(run.mode).toBe('interactive');
+      expect(run.workflow).toBe('balanced');
+      expect(run.spec.goals).toEqual([]);
+      expect(run.contextWindows).toEqual([]);
+      expect(run.tokenBudget.consumed).toBe(0);
+    });
+
+    test('should create from explicit data', () => {
+      const run = new HarnessRun({
+        id: 'run_test-123',
+        status: 'running',
+        mode: 'headless',
+        workflow: 'rapid',
+        spec: { goals: ['Build MVP'], nonGoals: [], constraints: [], doneWhen: ['Tests pass'] },
+        sessionId: 'session-1'
+      });
+      expect(run.id).toBe('run_test-123');
+      expect(run.status).toBe('running');
+      expect(run.mode).toBe('headless');
+      expect(run.workflow).toBe('rapid');
+      expect(run.spec.goals).toEqual(['Build MVP']);
+      expect(run.sessionId).toBe('session-1');
+    });
+
+    test('should validate correctly', () => {
+      const validRun = new HarnessRun();
+      expect(validRun.validate().valid).toBe(true);
+
+      const invalidRun = new HarnessRun({ id: 'bad', status: 'invalid', mode: 'wrong', workflow: 'nope' });
+      const result = invalidRun.validate();
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThanOrEqual(3);
+    });
+
+    test('should serialize/deserialize', () => {
+      const run = new HarnessRun({ workflow: 'comprehensive', sessionId: 'sess_1' });
+      const json = run.toJSON();
+      const restored = HarnessRun.fromJSON(json);
+      expect(restored.workflow).toBe('comprehensive');
+      expect(restored.sessionId).toBe('sess_1');
+      expect(restored.id).toBe(run.id);
+    });
+  });
+
+  describe('ContextWindow', () => {
+    test('should create with defaults', () => {
+      const cw = new ContextWindow();
+      expect(cw.id).toMatch(/^cw_/);
+      expect(cw.sequence).toBe(1);
+      expect(cw.status).toBe('active');
+      expect(cw.questionsAnswered).toEqual([]);
+      expect(cw.tokensConsumed).toBe(0);
+    });
+
+    test('should validate runId requirement', () => {
+      const cw = new ContextWindow();
+      const result = cw.validate();
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('runId is required');
+    });
+
+    test('should validate with runId', () => {
+      const cw = new ContextWindow({ runId: 'run_abc' });
+      expect(cw.validate().valid).toBe(true);
+    });
+
+    test('should serialize/deserialize', () => {
+      const cw = new ContextWindow({ runId: 'run_x', sequence: 3, tokensConsumed: 5000 });
+      const restored = ContextWindow.fromJSON(cw.toJSON());
+      expect(restored.runId).toBe('run_x');
+      expect(restored.sequence).toBe(3);
+      expect(restored.tokensConsumed).toBe(5000);
+    });
+  });
+
+  describe('HandoffPackage', () => {
+    test('should create with defaults', () => {
+      const hp = new HandoffPackage();
+      expect(hp.progressSummary).toBe('');
+      expect(hp.completedWork).toEqual([]);
+      expect(hp.nextSteps).toEqual([]);
+      expect(hp.knowledgeGraph.totalItems).toBe(0);
+      expect(hp.position.currentBlock).toBe(0);
+    });
+
+    test('should create with full data', () => {
+      const hp = new HandoffPackage({
+        progressSummary: 'Completed 5 of 10 blocks',
+        completedWork: ['Block 1', 'Block 2'],
+        nextSteps: ['Block 6'],
+        currentMilestone: { index: 2, title: 'Core Features', percentage: 50 },
+        criticalAnswers: [{ questionId: 'q1', summary: 'React app', quality: 85 }],
+        position: { currentBlock: 5, totalBlocks: 10, answeredIds: ['q1'], remainingIds: ['q6'] }
+      });
+      expect(hp.completedWork.length).toBe(2);
+      expect(hp.criticalAnswers[0].quality).toBe(85);
+      expect(hp.position.currentBlock).toBe(5);
+    });
+
+    test('should validate', () => {
+      const valid = new HandoffPackage();
+      expect(valid.validate().valid).toBe(true);
+
+      const invalid = new HandoffPackage({ progressSummary: 123 });
+      expect(invalid.validate().valid).toBe(false);
+    });
+
+    test('should serialize/deserialize', () => {
+      const hp = new HandoffPackage({ progressSummary: 'test', sourceWindowId: 'cw_1' });
+      const restored = HandoffPackage.fromJSON(hp.toJSON());
+      expect(restored.progressSummary).toBe('test');
+      expect(restored.sourceWindowId).toBe('cw_1');
+    });
+  });
+
+  describe('Milestone', () => {
+    test('should create with defaults', () => {
+      const ms = new Milestone();
+      expect(ms.id).toMatch(/^ms_/);
+      expect(ms.status).toBe('pending');
+      expect(ms.percentage).toBe(0);
+    });
+
+    test('should validate title required', () => {
+      const ms = new Milestone();
+      const result = ms.validate();
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('title is required');
+    });
+
+    test('should validate with title', () => {
+      const ms = new Milestone({ title: 'Setup' });
+      expect(ms.validate().valid).toBe(true);
+    });
+
+    test('should serialize/deserialize', () => {
+      const ms = new Milestone({ title: 'Architecture', index: 2, blockNumber: 3 });
+      const restored = Milestone.fromJSON(ms.toJSON());
+      expect(restored.title).toBe('Architecture');
+      expect(restored.index).toBe(2);
+      expect(restored.blockNumber).toBe(3);
+    });
+  });
+
+  describe('Event', () => {
+    test('should create with defaults', () => {
+      const event = new Event();
+      expect(event.type).toBe('checkpoint');
+      expect(event.timestamp).toBeDefined();
+      expect(event.data).toEqual({});
+    });
+
+    test('should validate type', () => {
+      const invalid = new Event({ type: 'invalid_type', runId: 'run_1' });
+      expect(invalid.validate().valid).toBe(false);
+
+      const valid = new Event({ type: 'answer', runId: 'run_1' });
+      expect(valid.validate().valid).toBe(true);
+    });
+
+    test('should serialize to JSONL and back', () => {
+      const event = new Event({
+        type: 'answer',
+        runId: 'run_1',
+        contextWindowId: 'cw_1',
+        data: { questionId: 'q1', quality: 90 }
+      });
+      const line = event.toJSONL();
+      expect(typeof line).toBe('string');
+      expect(line).not.toContain('\n');
+
+      const restored = Event.fromJSONL(line);
+      expect(restored.type).toBe('answer');
+      expect(restored.data.quality).toBe(90);
+    });
+
+    test('should cover all valid event types', () => {
+      expect(VALID_EVENT_TYPES).toContain('answer');
+      expect(VALID_EVENT_TYPES).toContain('handoff');
+      expect(VALID_EVENT_TYPES).toContain('window_open');
+      expect(VALID_EVENT_TYPES).toContain('window_close');
+      expect(VALID_EVENT_TYPES.length).toBe(12);
+    });
+  });
+
+  describe('FeatureManifest', () => {
+    test('should create with defaults', () => {
+      const fm = new FeatureManifest({ runId: 'run_1' });
+      expect(fm.features).toEqual([]);
+      expect(fm.runId).toBe('run_1');
+    });
+
+    test('should create with features', () => {
+      const fm = new FeatureManifest({
+        runId: 'run_1',
+        features: [
+          { title: 'Auth', description: 'User authentication' },
+          { title: 'Dashboard', description: 'Admin dashboard' }
+        ]
+      });
+      expect(fm.features.length).toBe(2);
+      expect(fm.features[0].id).toMatch(/^feat_/);
+      expect(fm.features[0].passes).toBe(false);
+    });
+
+    test('should mark passes (only allowed mutation)', () => {
+      const fm = new FeatureManifest({
+        runId: 'run_1',
+        features: [{ id: 'feat_1', title: 'Auth' }]
+      });
+
+      fm.markPasses('feat_1');
+      expect(fm.features[0].passes).toBe(true);
+      expect(fm.features[0].status).toBe('passes');
+      expect(fm.features[0].passedAt).toBeDefined();
+    });
+
+    test('should throw on unknown feature', () => {
+      const fm = new FeatureManifest({ runId: 'run_1', features: [] });
+      expect(() => fm.markPasses('feat_nonexistent')).toThrow('Feature not found');
+    });
+
+    test('should calculate progress', () => {
+      const fm = new FeatureManifest({
+        runId: 'run_1',
+        features: [
+          { id: 'feat_1', title: 'A', passes: true, status: 'passes' },
+          { id: 'feat_2', title: 'B', passes: false },
+          { id: 'feat_3', title: 'C', passes: true, status: 'passes' }
+        ]
+      });
+      const progress = fm.getProgress();
+      expect(progress.total).toBe(3);
+      expect(progress.passed).toBe(2);
+      expect(progress.remaining).toBe(1);
+      expect(progress.percentage).toBe(67);
+    });
+
+    test('should validate', () => {
+      const valid = new FeatureManifest({ runId: 'run_1', features: [{ title: 'X' }] });
+      expect(valid.validate().valid).toBe(true);
+
+      const invalid = new FeatureManifest({ features: [{ title: '' }] });
+      const result = invalid.validate();
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('ProviderCapability', () => {
+    test('should create with defaults', () => {
+      const pc = new ProviderCapability();
+      expect(pc.contextWindow).toBe(0);
+      expect(pc.backgroundExec).toBe(false);
+    });
+
+    test('should get effective context window', () => {
+      const pc = new ProviderCapability({
+        providerId: 'anthropic',
+        modelId: 'claude-opus-4-6',
+        contextWindow: 200000,
+        contextWindowBeta: 1000000
+      });
+      expect(pc.getEffectiveContextWindow(false)).toBe(200000);
+      expect(pc.getEffectiveContextWindow(true)).toBe(1000000);
+    });
+
+    test('should fall back when no beta', () => {
+      const pc = new ProviderCapability({
+        providerId: 'openai',
+        modelId: 'gpt-5-mini',
+        contextWindow: 128000
+      });
+      expect(pc.getEffectiveContextWindow(true)).toBe(128000);
+    });
+
+    test('should validate', () => {
+      const valid = new ProviderCapability({
+        providerId: 'anthropic',
+        modelId: 'claude-opus-4-6',
+        contextWindow: 200000
+      });
+      expect(valid.validate().valid).toBe(true);
+
+      const invalid = new ProviderCapability();
+      expect(invalid.validate().valid).toBe(false);
+    });
+  });
+
+  describe('PROVIDER_CAPABILITIES Registry', () => {
+    test('should have all three providers', () => {
+      expect(Object.keys(PROVIDER_CAPABILITIES)).toEqual(['anthropic', 'openai', 'google']);
+    });
+
+    test('should have correct Anthropic models', () => {
+      const anthropic = PROVIDER_CAPABILITIES.anthropic;
+      expect(anthropic['claude-opus-4-6'].contextWindow).toBe(200000);
+      expect(anthropic['claude-opus-4-6'].contextWindowBeta).toBe(1000000);
+      expect(anthropic['claude-opus-4-6'].maxOutput).toBe(128000);
+    });
+
+    test('should have correct OpenAI models', () => {
+      const openai = PROVIDER_CAPABILITIES.openai;
+      expect(openai['gpt-5.2'].contextWindow).toBe(400000);
+      expect(openai['gpt-5.2'].compactEndpoint).toBe('/responses/compact');
+    });
+
+    test('should have correct Google models', () => {
+      const google = PROVIDER_CAPABILITIES.google;
+      expect(google['gemini-3.1-pro-preview'].contextWindow).toBe(1000000);
+      expect(google['gemini-3.1-pro-preview'].interactionsAPI).toBe(true);
+      expect(google['gemini-3.1-pro-preview'].thoughtSignatures).toBe(true);
+    });
+  });
+
+  describe('Run status constants', () => {
+    test('should have all valid statuses', () => {
+      expect(VALID_RUN_STATUSES).toEqual(['initializing', 'running', 'paused', 'completed', 'failed']);
+    });
+  });
+});

package/tests/harness-provider-bridge.test.js

@@ -0,0 +1,180 @@
+const ProviderBridge = require('../lib/harness/provider-bridge');
+
+describe('ProviderBridge', () => {
+  const mockAiClient = {
+    sendMessage: jest.fn().mockResolvedValue({
+      text: 'Mock response text for testing purposes.',
+      usage: { inputTokens: 100, outputTokens: 50 }
+    })
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should create with known provider capability', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    const cap = bridge.getCapability();
+    expect(cap.contextWindow).toBe(200000);
+    expect(cap.contextWindowBeta).toBe(1000000);
+    expect(cap.maxOutput).toBe(128000);
+  });
+
+  test('should create with OpenAI capability', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'openai', 'gpt-5.2');
+    const cap = bridge.getCapability();
+    expect(cap.contextWindow).toBe(400000);
+    expect(cap.compaction).toBe(true);
+    expect(cap.compactEndpoint).toBe('/responses/compact');
+  });
+
+  test('should create with Google capability', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'google', 'gemini-3.1-pro-preview');
+    const cap = bridge.getCapability();
+    expect(cap.contextWindow).toBe(1000000);
+    expect(cap.interactionsAPI).toBe(true);
+    expect(cap.thoughtSignatures).toBe(true);
+  });
+
+  test('should fallback for unknown model', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'unknown', 'some-model');
+    const cap = bridge.getCapability();
+    expect(cap.contextWindow).toBe(128000);
+    expect(cap.maxOutput).toBe(8192);
+  });
+
+  test('should resolve OpenRouter models', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'openrouter', 'anthropic/claude-opus-4-6');
+    const cap = bridge.getCapability();
+    expect(cap.contextWindow).toBe(200000);
+    expect(cap.providerId).toBe('openrouter');
+  });
+
+  test('should send message with instrumentation', async () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    const result = await bridge.sendMessage('Hello');
+
+    expect(mockAiClient.sendMessage).toHaveBeenCalledTimes(1);
+    expect(result.text).toBe('Mock response text for testing purposes.');
+    expect(result.instrumentation).toBeDefined();
+    expect(result.instrumentation.duration).toBeGreaterThanOrEqual(0);
+    expect(result.instrumentation.inputTokens).toBe(100);
+    expect(result.instrumentation.outputTokens).toBe(50);
+    expect(result.instrumentation.providerId).toBe('anthropic');
+  });
+
+  test('should estimate tokens when not provided', async () => {
+    mockAiClient.sendMessage.mockResolvedValueOnce({
+      text: 'Short reply'
+      // No usage data
+    });
+
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    const result = await bridge.sendMessage('Test prompt');
+
+    expect(result.instrumentation.inputTokens).toBeGreaterThan(0);
+    expect(result.instrumentation.outputTokens).toBeGreaterThan(0);
+  });
+
+  test('should track cumulative token usage', async () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+
+    await bridge.sendMessage('First');
+    await bridge.sendMessage('Second');
+
+    const stats = bridge.getTokenStats();
+    expect(stats.inputTokens).toBe(200);
+    expect(stats.outputTokens).toBe(100);
+    expect(stats.totalCalls).toBe(2);
+  });
+
+  test('should calculate context window size', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    expect(bridge.getContextWindowSize(false)).toBe(200000);
+    expect(bridge.getContextWindowSize(true)).toBe(1000000);
+  });
+
+  test('should calculate remaining budget', async () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    await bridge.sendMessage('Test');
+
+    const remaining = bridge.getRemainingBudget(false);
+    expect(remaining).toBe(200000 - 150); // 200K - 100 input - 50 output
+  });
+
+  test('should report feature support', () => {
+    const anthropic = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    expect(anthropic.supportsBackgroundExec()).toBe(false);
+    expect(anthropic.supportsCompaction()).toBe(true);
+    expect(anthropic.supportsInteractionsAPI()).toBe(false);
+
+    const google = new ProviderBridge(mockAiClient, 'google', 'gemini-3.1-pro-preview');
+    expect(google.supportsBackgroundExec()).toBe(true);
+    expect(google.supportsInteractionsAPI()).toBe(true);
+    expect(google.supportsThoughtSignatures()).toBe(true);
+  });
+
+  test('should get provider info for handoff', () => {
+    const bridge = new ProviderBridge(mockAiClient, 'openai', 'gpt-5.2');
+    const info = bridge.getProviderInfo();
+    expect(info.id).toBe('openai');
+    expect(info.model).toBe('gpt-5.2');
+    expect(info.contextWindowSize).toBe(400000);
+  });
+
+  test('should enhance options for Anthropic beta', async () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    await bridge.sendMessage('Test', { useBetaContext: true });
+
+    const callArgs = mockAiClient.sendMessage.mock.calls[0][1];
+    expect(callArgs.betas).toContain('context-1m-2025-08-07');
+  });
+
+  test('should set default maxTokens', async () => {
+    const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+    await bridge.sendMessage('Test');
+
+    const callArgs = mockAiClient.sendMessage.mock.calls[0][1];
+    expect(callArgs.maxTokens).toBe(4096);
+  });
+
+  describe('static methods', () => {
+    test('should lookup capability', () => {
+      const cap = ProviderBridge.lookupCapability('anthropic', 'claude-opus-4-6');
+      expect(cap).not.toBeNull();
+      expect(cap.contextWindow).toBe(200000);
+    });
+
+    test('should return null for unknown model', () => {
+      const cap = ProviderBridge.lookupCapability('unknown', 'model');
+      expect(cap).toBeNull();
+    });
+
+    test('should get models for provider', () => {
+      const models = ProviderBridge.getModelsForProvider('openai');
+      expect(models).toContain('gpt-5.2');
+      expect(models).toContain('gpt-5.2-pro');
+    });
+
+    test('should return empty for unknown provider', () => {
+      const models = ProviderBridge.getModelsForProvider('unknown');
+      expect(models).toEqual([]);
+    });
+
+    test('should get all providers', () => {
+      const providers = ProviderBridge.getProviders();
+      expect(providers).toContain('anthropic');
+      expect(providers).toContain('openai');
+      expect(providers).toContain('google');
+    });
+  });
+
+  describe('token estimation', () => {
+    test('should estimate tokens from text', () => {
+      const bridge = new ProviderBridge(mockAiClient, 'anthropic', 'claude-opus-4-6');
+      expect(bridge.estimateTokens('Hello world')).toBeGreaterThan(0);
+      expect(bridge.estimateTokens('')).toBe(0);
+      expect(bridge.estimateTokens(null)).toBe(0);
+    });
+  });
+});