olympus-ai 3.3.0 → 3.4.1

package/dist/__tests__/token-tracking-integration.test.js

@@ -0,0 +1,669 @@
+/**
+ * Task 6.4: Final Integration Testing for Token Tracking
+ *
+ * Tests the complete token tracking flow from session start to feedback capture,
+ * budget warnings, and CLI commands.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { join } from 'path';
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import { generateLearnedContext } from '../learning/hooks/learned-context.js';
+import { loadSessionState, saveSessionState, updateTokenBudget, shouldIssueWarning, markWarningIssued, } from '../learning/session-state.js';
+import { appendFeedback, updateAgentPerformance, readFeedbackLog } from '../learning/storage.js';
+import { randomUUID } from 'crypto';
+import * as storage from '../learning/storage.js';
+const TEST_DIR = join(process.cwd(), '.test-integration-' + Date.now());
+const TEST_LEARNING_DIR = join(TEST_DIR, '.claude', 'olympus', 'learning');
+let agentPerfBackup = null;
+let feedbackBackup = null;
+beforeEach(() => {
+    // Create isolated test directories
+    mkdirSync(TEST_DIR, { recursive: true });
+    mkdirSync(join(TEST_DIR, '.olympus'), { recursive: true });
+    mkdirSync(TEST_LEARNING_DIR, { recursive: true });
+    // Mock getLearningDir to use test directory
+    vi.spyOn(storage, 'getLearningDir').mockReturnValue(TEST_LEARNING_DIR);
+});
+afterEach(() => {
+    // Restore mocks
+    vi.restoreAllMocks();
+    // Clean up test directory
+    if (TEST_DIR.includes('.test-integration-')) {
+        rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+});
+describe('Integration Test 1: End-to-End Session with Token Tracking', () => {
+    it.skip('should track tokens through complete session lifecycle', () => {
+        const sessionId = 'e2e-session-1';
+        // 1. Session Start: Initialize state
+        let state = loadSessionState(TEST_DIR, sessionId);
+        expect(state.token_budget).toBeDefined();
+        expect(state.token_budget.current_usage).toBe(0);
+        expect(state.token_budget.session_baseline).toBe(10000);
+        // 2. UserPromptSubmit hook (no token tracking)
+        // Just verify state persists
+        saveSessionState(TEST_DIR, state);
+        state = loadSessionState(TEST_DIR, sessionId);
+        expect(state.session_id).toBe(sessionId);
+        // 3. PostToolUse hook: Capture feedback with token usage
+        const feedback1 = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            session_id: sessionId,
+            project_path: TEST_DIR,
+            event_type: 'success',
+            agent_used: 'olympian',
+            original_task: 'Implement feature X',
+            user_message: 'Task completed successfully',
+            feedback_category: 'praise',
+            confidence: 0.9,
+            token_usage: {
+                input_tokens: 3000,
+                output_tokens: 1500,
+                total_tokens: 4500,
+                estimated: false,
+            },
+        };
+        appendFeedback(feedback1);
+        // Update session state with token usage
+        state = updateTokenBudget(state, feedback1.token_usage.total_tokens);
+        saveSessionState(TEST_DIR, state);
+        expect(state.token_budget.current_usage).toBe(4500);
+        // 4. Another PostToolUse: More token accumulation
+        const feedback2 = {
+            id: randomUUID(),
+            timestamp: new Date(Date.now() + 60000).toISOString(),
+            session_id: sessionId,
+            project_path: TEST_DIR,
+            event_type: 'success',
+            agent_used: 'olympian',
+            original_task: 'Fix bug Y',
+            user_message: 'Bug fixed correctly',
+            feedback_category: 'praise',
+            confidence: 0.9,
+            token_usage: {
+                input_tokens: 2000,
+                output_tokens: 1000,
+                total_tokens: 3000,
+                estimated: false,
+            },
+        };
+        appendFeedback(feedback2);
+        state = updateTokenBudget(state, feedback2.token_usage.total_tokens);
+        saveSessionState(TEST_DIR, state);
+        expect(state.token_budget.current_usage).toBe(7500);
+        // 5. Stop hook: Verify AgentPerformance updated
+        const allFeedback = readFeedbackLog();
+        const updatedPerf = updateAgentPerformance('olympian', allFeedback);
+        expect(updatedPerf).not.toBeNull();
+        expect(updatedPerf.token_efficiency).toBeDefined();
+        expect(updatedPerf.token_efficiency.total_tokens).toBeGreaterThan(0);
+        expect(updatedPerf.token_efficiency.invocation_count).toBeGreaterThan(0);
+        // 6. Verify feedback entries have token_usage
+        const feedbackPath = join(TEST_LEARNING_DIR, 'feedback-log.jsonl');
+        expect(existsSync(feedbackPath)).toBe(true);
+        const feedbackEntries = readFeedbackLog();
+        expect(feedbackEntries.length).toBeGreaterThanOrEqual(2);
+        const lastTwo = feedbackEntries.slice(-2);
+        for (const entry of lastTwo) {
+            expect(entry.token_usage).toBeDefined();
+            expect(entry.token_usage.total_tokens).toBeGreaterThan(0);
+        }
+    });
+    it.skip('should calculate token efficiency metrics correctly', () => {
+        const sessionId = 'e2e-session-2';
+        let state = loadSessionState(TEST_DIR, sessionId);
+        // Create mix of success and failure feedback
+        const feedbacks = [
+            {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                session_id: sessionId,
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'oracle-low',
+                original_task: 'Task 1',
+                user_message: 'Good work',
+                feedback_category: 'praise',
+                confidence: 0.9,
+                token_usage: { input_tokens: 1000, output_tokens: 500, total_tokens: 1500, estimated: false },
+            },
+            {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() + 40000).toISOString(),
+                session_id: sessionId,
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'oracle-low',
+                original_task: 'Task 2',
+                user_message: 'Well done',
+                feedback_category: 'praise',
+                confidence: 0.9,
+                token_usage: { input_tokens: 1200, output_tokens: 600, total_tokens: 1800, estimated: false },
+            },
+            {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() + 80000).toISOString(),
+                session_id: sessionId,
+                project_path: TEST_DIR,
+                event_type: 'revision',
+                agent_used: 'oracle-low',
+                original_task: 'Task 3',
+                user_message: 'That needs fixing',
+                feedback_category: 'correction',
+                confidence: 0.8,
+                token_usage: { input_tokens: 1500, output_tokens: 800, total_tokens: 2300, estimated: false },
+            },
+        ];
+        let totalTokens = 0;
+        for (const fb of feedbacks) {
+            appendFeedback(fb);
+            totalTokens += fb.token_usage.total_tokens;
+        }
+        state = updateTokenBudget(state, totalTokens);
+        saveSessionState(TEST_DIR, state);
+        // Update agent performance from all feedback
+        const allFeedback = readFeedbackLog();
+        const oracleLowPerf = updateAgentPerformance('oracle-low', allFeedback);
+        expect(oracleLowPerf).not.toBeNull();
+        expect(oracleLowPerf.token_efficiency).toBeDefined();
+        expect(oracleLowPerf.token_efficiency.total_tokens).toBe(totalTokens);
+        expect(oracleLowPerf.token_efficiency.invocation_count).toBe(3);
+        expect(oracleLowPerf.token_efficiency.avg_tokens_per_success).toBeGreaterThan(0);
+        expect(oracleLowPerf.success_count).toBe(2);
+        expect(oracleLowPerf.revision_count).toBe(1);
+    });
+});
+describe('Integration Test 2: Backward Compatibility', () => {
+    it.skip('should handle old feedback entries without token_usage', () => {
+        // Create old-style feedback entry (without token_usage)
+        const oldFeedback = {
+            id: randomUUID(),
+            timestamp: new Date(Date.now() - 86400000).toISOString(),
+            session_id: 'old-session',
+            project_path: TEST_DIR,
+            event_type: 'success',
+            agent_used: 'olympian',
+            original_task: 'Old task without tokens',
+            user_message: 'Completed',
+            feedback_category: 'praise',
+            confidence: 0.9,
+            // No token_usage field
+        };
+        const feedbackPath = join(TEST_LEARNING_DIR, 'feedback-log.jsonl');
+        writeFileSync(feedbackPath, JSON.stringify(oldFeedback) + '\n');
+        // Add new feedback with token_usage
+        const newFeedback = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            session_id: 'new-session',
+            project_path: TEST_DIR,
+            event_type: 'success',
+            agent_used: 'olympian',
+            original_task: 'New task with tokens',
+            user_message: 'Done well',
+            feedback_category: 'praise',
+            confidence: 0.9,
+            token_usage: {
+                input_tokens: 2000,
+                output_tokens: 1000,
+                total_tokens: 3000,
+                estimated: false,
+            },
+        };
+        appendFeedback(newFeedback);
+        // Should not throw error
+        const allFeedback = readFeedbackLog();
+        const updated = updateAgentPerformance('olympian', allFeedback);
+        expect(updated).not.toBeNull();
+        expect(updated.token_efficiency).toBeDefined();
+        expect(updated.token_efficiency.total_tokens).toBe(3000); // Only counts new entry
+        expect(updated.total_invocations).toBe(2); // Counts both entries
+    });
+    it.skip('should aggregate metrics from mixed old and new entries', () => {
+        const feedbackPath = join(TEST_LEARNING_DIR, 'feedback-log.jsonl');
+        // Create mixed entries
+        const entries = [
+            // Old entries without token_usage
+            {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() - 200000).toISOString(),
+                session_id: 'test-session',
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'explore',
+                original_task: 'Old task 1',
+                user_message: 'Done',
+                feedback_category: 'praise',
+                confidence: 0.8,
+            },
+            {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() - 100000).toISOString(),
+                session_id: 'test-session',
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'explore',
+                original_task: 'Old task 2',
+                user_message: 'Completed',
+                feedback_category: 'praise',
+                confidence: 0.8,
+            },
+            // New entries with token_usage
+            {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() - 50000).toISOString(),
+                session_id: 'test-session',
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'explore',
+                original_task: 'New task 1',
+                user_message: 'Good',
+                feedback_category: 'praise',
+                confidence: 0.9,
+                token_usage: { input_tokens: 800, output_tokens: 400, total_tokens: 1200, estimated: false },
+            },
+            {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                session_id: 'test-session',
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'explore',
+                original_task: 'New task 2',
+                user_message: 'Excellent',
+                feedback_category: 'praise',
+                confidence: 0.9,
+                token_usage: { input_tokens: 900, output_tokens: 450, total_tokens: 1350, estimated: false },
+            },
+        ];
+        writeFileSync(feedbackPath, entries.map(e => JSON.stringify(e)).join('\n') + '\n');
+        // Update performance (should handle mixed data)
+        const allFeedback = readFeedbackLog();
+        const perf = updateAgentPerformance('explore', allFeedback);
+        expect(perf).not.toBeNull();
+        expect(perf.total_invocations).toBe(4);
+        expect(perf.token_efficiency).toBeDefined();
+        // Only entries with token_usage should contribute to token metrics
+        expect(perf.token_efficiency.total_tokens).toBe(1200 + 1350);
+        expect(perf.token_efficiency.invocation_count).toBe(2);
+    });
+});
+describe('Integration Test 3: Injection Token Cap', () => {
+    it('should respect 500 token limit for SessionStart injection', () => {
+        // Create realistic agent performance data
+        const agentPerformance = {
+            'olympian': {
+                agent_name: 'olympian',
+                total_invocations: 25,
+                success_count: 22,
+                revision_count: 3,
+                cancellation_count: 0,
+                success_rate: 0.88,
+                failure_patterns: [
+                    { pattern: 'complex async operations', count: 2, examples: [] },
+                    { pattern: 'state management', count: 1, examples: [] },
+                ],
+                strong_areas: ['file editing', 'code generation', 'testing'],
+                weak_areas: ['deep debugging'],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 4200,
+                    avg_tokens_per_failure: 6500,
+                    total_tokens: 105000,
+                    invocation_count: 25,
+                    efficiency_score: 0.85,
+                    trend: 'stable',
+                },
+            },
+            'oracle-low': {
+                agent_name: 'oracle-low',
+                total_invocations: 18,
+                success_count: 17,
+                revision_count: 1,
+                cancellation_count: 0,
+                success_rate: 0.94,
+                failure_patterns: [],
+                strong_areas: ['simple debugging', 'code analysis'],
+                weak_areas: [],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 2100,
+                    avg_tokens_per_failure: 2800,
+                    total_tokens: 37800,
+                    invocation_count: 18,
+                    efficiency_score: 1.15,
+                    trend: 'improving',
+                },
+            },
+            'explore': {
+                agent_name: 'explore',
+                total_invocations: 30,
+                success_count: 29,
+                revision_count: 1,
+                cancellation_count: 0,
+                success_rate: 0.97,
+                failure_patterns: [],
+                strong_areas: ['codebase search', 'pattern matching'],
+                weak_areas: [],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 1200,
+                    avg_tokens_per_failure: 1500,
+                    total_tokens: 36000,
+                    invocation_count: 30,
+                    efficiency_score: 1.35,
+                    trend: 'stable',
+                },
+            },
+        };
+        const perfPath = join(TEST_LEARNING_DIR, 'agent-performance.json');
+        writeFileSync(perfPath, JSON.stringify(agentPerformance, null, 2));
+        // Ensure file exists before reading
+        expect(existsSync(perfPath)).toBe(true);
+        const context = generateLearnedContext(TEST_DIR);
+        // Calculate token count (rough estimate: 1 token ≈ 4 chars)
+        const estimatedTokens = context.length / 4;
+        expect(estimatedTokens).toBeLessThanOrEqual(500);
+        expect(context).toContain('<olympus-efficiency>');
+    });
+    it('should prioritize most efficient agents when space is limited', () => {
+        // Create many agents to test truncation
+        const agentPerformance = {};
+        const agents = [
+            { name: 'explore', efficiency: 1.5 },
+            { name: 'oracle-low', efficiency: 1.3 },
+            { name: 'olympian-low', efficiency: 1.1 },
+            { name: 'olympian', efficiency: 0.9 },
+            { name: 'oracle', efficiency: 0.7 },
+            { name: 'frontend-engineer', efficiency: 0.6 },
+        ];
+        for (const agent of agents) {
+            agentPerformance[agent.name] = {
+                agent_name: agent.name,
+                total_invocations: 10,
+                success_count: 9,
+                revision_count: 1,
+                cancellation_count: 0,
+                success_rate: 0.9,
+                failure_patterns: [],
+                strong_areas: ['area1', 'area2'],
+                weak_areas: ['area3'],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 3000,
+                    avg_tokens_per_failure: 4000,
+                    total_tokens: 30000,
+                    invocation_count: 10,
+                    efficiency_score: agent.efficiency,
+                    trend: 'stable',
+                },
+            };
+        }
+        writeFileSync(join(TEST_LEARNING_DIR, 'agent-performance.json'), JSON.stringify(agentPerformance, null, 2));
+        const context = generateLearnedContext(TEST_DIR);
+        // Most efficient agents should appear
+        expect(context).toContain('explore');
+        expect(context).toContain('oracle-low');
+        // Verify token limit
+        const estimatedTokens = context.length / 4;
+        expect(estimatedTokens).toBeLessThanOrEqual(500);
+    });
+});
+describe('Integration Test 4: Budget Warning Behavior', () => {
+    it('should fire warning once when threshold exceeded', () => {
+        const sessionId = 'budget-warning-1';
+        let state = loadSessionState(TEST_DIR, sessionId);
+        expect(state.token_budget.session_baseline).toBe(10000);
+        expect(state.token_budget.warning_threshold).toBe(1.5);
+        const warningLimit = state.token_budget.session_baseline * state.token_budget.warning_threshold;
+        expect(warningLimit).toBe(15000);
+        // Add tokens below threshold
+        state = updateTokenBudget(state, 14000);
+        expect(shouldIssueWarning(state)).toBe(false);
+        // Exceed threshold
+        state = updateTokenBudget(state, 2000); // Total: 16000 > 15000
+        expect(shouldIssueWarning(state)).toBe(true);
+        // Mark warning issued
+        state = markWarningIssued(state);
+        saveSessionState(TEST_DIR, state);
+        // Should not issue again
+        expect(shouldIssueWarning(state)).toBe(false);
+        // Even with more usage
+        state = updateTokenBudget(state, 10000); // Total: 26000
+        expect(shouldIssueWarning(state)).toBe(false);
+        expect(state.token_budget.warning_issued).toBe(true);
+    });
+    it('should be non-blocking (continue: true)', () => {
+        const sessionId = 'budget-warning-2';
+        let state = loadSessionState(TEST_DIR, sessionId);
+        // Massively exceed budget
+        state = updateTokenBudget(state, 100000);
+        // Warning should be issued
+        expect(shouldIssueWarning(state)).toBe(true);
+        // But this should never block execution
+        // Hook implementation always returns { continue: true }
+        // This is a behavioral guarantee verified by the hook itself
+        expect(state.token_budget).toBeDefined();
+    });
+    it('should handle multiple sessions independently', () => {
+        // Note: Session state is stored per directory, not per session ID
+        // So we need separate directories for independent sessions
+        const dir1 = join(TEST_DIR, 'session1');
+        const dir2 = join(TEST_DIR, 'session2');
+        mkdirSync(dir1, { recursive: true });
+        mkdirSync(dir2, { recursive: true });
+        let state1 = loadSessionState(dir1, 'session1');
+        let state2 = loadSessionState(dir2, 'session2');
+        // Exceed budget in session1
+        state1 = updateTokenBudget(state1, 20000);
+        state1 = markWarningIssued(state1);
+        saveSessionState(dir1, state1);
+        // Session2 should be independent
+        expect(shouldIssueWarning(state2)).toBe(false);
+        state2 = updateTokenBudget(state2, 20000);
+        expect(shouldIssueWarning(state2)).toBe(true);
+        // Reload to verify persistence
+        const reloadedState1 = loadSessionState(dir1, 'session1');
+        const reloadedState2 = loadSessionState(dir2, 'session2');
+        expect(reloadedState1.token_budget.warning_issued).toBe(true);
+        expect(reloadedState2.token_budget.warning_issued).toBe(false);
+    });
+});
+describe('Integration Test 5: CLI Commands', () => {
+    beforeEach(() => {
+        // Set up realistic test data
+        const agentPerformance = {
+            'olympian': {
+                agent_name: 'olympian',
+                total_invocations: 15,
+                success_count: 13,
+                revision_count: 2,
+                cancellation_count: 0,
+                success_rate: 0.87,
+                failure_patterns: [],
+                strong_areas: ['editing', 'testing'],
+                weak_areas: [],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 4200,
+                    avg_tokens_per_failure: 5500,
+                    total_tokens: 65600,
+                    invocation_count: 15,
+                    efficiency_score: 0.88,
+                    trend: 'stable',
+                },
+            },
+            'oracle-low': {
+                agent_name: 'oracle-low',
+                total_invocations: 10,
+                success_count: 10,
+                revision_count: 0,
+                cancellation_count: 0,
+                success_rate: 1.0,
+                failure_patterns: [],
+                strong_areas: ['debugging'],
+                weak_areas: [],
+                last_updated: new Date().toISOString(),
+                token_efficiency: {
+                    avg_tokens_per_success: 2100,
+                    avg_tokens_per_failure: 0,
+                    total_tokens: 21000,
+                    invocation_count: 10,
+                    efficiency_score: 1.2,
+                    trend: 'improving',
+                },
+            },
+        };
+        writeFileSync(join(TEST_LEARNING_DIR, 'agent-performance.json'), JSON.stringify(agentPerformance, null, 2));
+    });
+    it('should handle --efficiency flag data format', () => {
+        // Read agent performance
+        const perfPath = join(TEST_LEARNING_DIR, 'agent-performance.json');
+        const perfData = JSON.parse(readFileSync(perfPath, 'utf-8'));
+        // Verify data structure for CLI display
+        const agentsWithTokens = Object.values(perfData).filter(a => a.token_efficiency);
+        expect(agentsWithTokens.length).toBeGreaterThan(0);
+        for (const agent of agentsWithTokens) {
+            expect(agent.token_efficiency).toBeDefined();
+            expect(agent.token_efficiency.avg_tokens_per_success).toBeGreaterThan(0);
+            expect(agent.token_efficiency.efficiency_score).toBeGreaterThan(0);
+            expect(agent.token_efficiency.trend).toMatch(/^(improving|stable|declining|insufficient_data)$/);
+        }
+    });
+    it('should handle --show-costs flag data format', () => {
+        const perfPath = join(TEST_LEARNING_DIR, 'agent-performance.json');
+        const perfData = JSON.parse(readFileSync(perfPath, 'utf-8'));
+        // Cost calculation data should be available
+        const agentsWithTokens = Object.values(perfData).filter(a => a.token_efficiency);
+        for (const agent of agentsWithTokens) {
+            const { total_tokens, invocation_count } = agent.token_efficiency;
+            expect(total_tokens).toBeGreaterThan(0);
+            expect(invocation_count).toBeGreaterThan(0);
+            // Can calculate average cost
+            const avgTokens = total_tokens / invocation_count;
+            expect(avgTokens).toBeGreaterThan(0);
+        }
+    });
+    it('should handle --budget-status flag data format', () => {
+        const sessionId = 'cli-budget-test';
+        let state = loadSessionState(TEST_DIR, sessionId);
+        state = updateTokenBudget(state, 8000);
+        saveSessionState(TEST_DIR, state);
+        // Reload and verify budget status data
+        const reloaded = loadSessionState(TEST_DIR, sessionId);
+        expect(reloaded.token_budget).toBeDefined();
+        expect(reloaded.token_budget.session_baseline).toBe(10000);
+        expect(reloaded.token_budget.current_usage).toBe(8000);
+        expect(reloaded.token_budget.warning_threshold).toBe(1.5);
+        // Calculate percentage for display
+        const percentage = (reloaded.token_budget.current_usage / reloaded.token_budget.session_baseline) * 100;
+        expect(percentage).toBe(80);
+    });
+    it('should gracefully handle no-data case for all CLI commands', () => {
+        // Remove agent performance file
+        const perfPath = join(TEST_LEARNING_DIR, 'agent-performance.json');
+        if (existsSync(perfPath)) {
+            rmSync(perfPath);
+        }
+        // Should not throw when reading non-existent data
+        expect(() => {
+            if (existsSync(perfPath)) {
+                readFileSync(perfPath, 'utf-8');
+            }
+        }).not.toThrow();
+        // Session state should still work even without agent performance
+        const sessionId = 'no-data-test';
+        const state = loadSessionState(TEST_DIR, sessionId);
+        expect(state.token_budget).toBeDefined();
+    });
+});
+describe('Integration Test 6: Performance and Regression', () => {
+    it('should not cause noticeable slowdown in hook execution', () => {
+        const startTime = Date.now();
+        // Simulate typical hook workflow
+        const sessionId = 'perf-test-1';
+        let state = loadSessionState(TEST_DIR, sessionId);
+        for (let i = 0; i < 10; i++) {
+            const feedback = {
+                id: randomUUID(),
+                timestamp: new Date(Date.now() + i * 1000).toISOString(),
+                session_id: sessionId,
+                project_path: TEST_DIR,
+                event_type: 'success',
+                agent_used: 'olympian',
+                original_task: `Task ${i}`,
+                user_message: `Task ${i} done`,
+                feedback_category: 'praise',
+                confidence: 0.9,
+                token_usage: {
+                    input_tokens: 2000 + i * 100,
+                    output_tokens: 1000 + i * 50,
+                    total_tokens: 3000 + i * 150,
+                    estimated: false,
+                },
+            };
+            appendFeedback(feedback);
+            state = updateTokenBudget(state, feedback.token_usage.total_tokens);
+        }
+        // Update performance once at the end (typical pattern)
+        const allFeedback = readFeedbackLog();
+        updateAgentPerformance('olympian', allFeedback);
+        saveSessionState(TEST_DIR, state);
+        const elapsed = Date.now() - startTime;
+        // Should complete in reasonable time (< 2 seconds for 10 iterations)
+        expect(elapsed).toBeLessThan(2000);
+    });
+    it('should maintain existing functionality without regressions', () => {
+        // Verify core features still work
+        const sessionId = 'regression-test';
+        const state = loadSessionState(TEST_DIR, sessionId);
+        // Session state core functionality
+        expect(state.session_id).toBe(sessionId);
+        expect(state.started_at).toBeDefined();
+        expect(state.token_budget).toBeDefined();
+        // Feedback capture still works
+        const feedback = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            session_id: sessionId,
+            project_path: TEST_DIR,
+            event_type: 'success',
+            agent_used: 'explore',
+            original_task: 'Search codebase',
+            user_message: 'Found it',
+            feedback_category: 'praise',
+            confidence: 0.9,
+            token_usage: {
+                input_tokens: 500,
+                output_tokens: 200,
+                total_tokens: 700,
+                estimated: false,
+            },
+        };
+        expect(() => appendFeedback(feedback)).not.toThrow();
+        // Agent performance update still works
+        const allFeedback = readFeedbackLog();
+        expect(() => updateAgentPerformance('explore', allFeedback)).not.toThrow();
+    });
+    it('should handle concurrent sessions without conflicts', () => {
+        // Session state is stored per directory, so create separate directories
+        const sessionDirs = ['concurrent-1', 'concurrent-2', 'concurrent-3'].map(id => join(TEST_DIR, id));
+        // Create directories and load states
+        const states = sessionDirs.map((dir, i) => {
+            mkdirSync(dir, { recursive: true });
+            return loadSessionState(dir, `session-${i}`);
+        });
+        // Update each session independently
+        for (let i = 0; i < states.length; i++) {
+            states[i] = updateTokenBudget(states[i], 5000 * (i + 1));
+            saveSessionState(sessionDirs[i], states[i]);
+        }
+        // Reload and verify independence
+        for (let i = 0; i < sessionDirs.length; i++) {
+            const reloaded = loadSessionState(sessionDirs[i], `session-${i}`);
+            expect(reloaded.token_budget.current_usage).toBe(5000 * (i + 1));
+        }
+    });
+});
+//# sourceMappingURL=token-tracking-integration.test.js.map