palaryn 0.1.0

package/dist/tests/unit/budget-manager.test.js

@@ -0,0 +1,778 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const manager_1 = require("../../src/budget/manager");
+// ---------------------------------------------------------------------------
+// Helper: create a ToolCall with sensible defaults and optional overrides
+// ---------------------------------------------------------------------------
+function createTestToolCall(overrides) {
+    return {
+        tool_call_id: 'tc-001',
+        task_id: 'task-001',
+        workspace_id: 'ws-001',
+        actor: { type: 'agent', id: 'agent-001' },
+        source: { platform: 'test' },
+        tool: { name: 'http.request', capability: 'read' },
+        args: { method: 'GET', url: 'https://example.com' },
+        timestamp: new Date().toISOString(),
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Default test config (generous limits so individual tests can tighten them)
+// ---------------------------------------------------------------------------
+function defaultConfig(overrides) {
+    return {
+        task_budget_usd: 2.0,
+        max_steps_per_task: 50,
+        max_retries_per_call: 3,
+        max_wall_clock_ms: 300000,
+        ...overrides,
+    };
+}
+// ===========================================================================
+// Tests
+// ===========================================================================
+describe('BudgetManager', () => {
+    // -----------------------------------------------------------------------
+    // Cost Estimation
+    // -----------------------------------------------------------------------
+    describe('estimateCost', () => {
+        let manager;
+        beforeEach(() => {
+            manager = new manager_1.BudgetManager(defaultConfig());
+        });
+        it('should return cost based on tool name from cost table', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'http.request', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.tool_name).toBe('http.request');
+            expect(estimate.capability).toBe('read');
+            expect(estimate.estimated_cost_usd).toBe(0.001);
+        });
+        it('should return higher cost for known write tool entry', () => {
+            // http.request with write capability should match http.request.write (0.002)
+            const toolCall = createTestToolCall({ tool: { name: 'http.request', capability: 'write' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.002);
+        });
+        it('should return correct cost for slack.post', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'slack.post', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.003);
+        });
+        it('should return correct cost for git.operation', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'git.operation', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.002);
+        });
+        it('should return correct cost for db.query', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'db.query', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.005);
+        });
+        it('should return correct cost for browser.navigate', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'browser.navigate', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.01);
+        });
+        it('should return default cost for unknown tools', () => {
+            const toolCall = createTestToolCall({ tool: { name: 'custom.unknown_tool', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.tool_name).toBe('custom.unknown_tool');
+            expect(estimate.estimated_cost_usd).toBe(0.001); // default
+        });
+        it('should apply 1.5x multiplier for delete capability', () => {
+            // db.query base = 0.005, delete => 0.005 * 1.5 = 0.0075
+            const toolCall = createTestToolCall({ tool: { name: 'db.query', capability: 'delete' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBeCloseTo(0.0075, 6);
+        });
+        it('should apply 2.0x multiplier for admin capability', () => {
+            // db.query base = 0.005, admin => 0.005 * 2.0 = 0.01
+            const toolCall = createTestToolCall({ tool: { name: 'db.query', capability: 'admin' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBeCloseTo(0.01, 6);
+        });
+        it('should respect per-call max_cost_usd constraint as upper bound', () => {
+            // browser.navigate base = 0.01, but constraint limits to 0.005
+            const toolCall = createTestToolCall({
+                tool: { name: 'browser.navigate', capability: 'read' },
+                constraints: { max_cost_usd: 0.005 },
+            });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.005);
+        });
+        it('should not reduce cost when max_cost_usd is higher than estimated', () => {
+            // http.request base = 0.001, constraint = 1.0 (way above)
+            const toolCall = createTestToolCall({
+                tool: { name: 'http.request', capability: 'read' },
+                constraints: { max_cost_usd: 1.0 },
+            });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.001);
+        });
+        it('should not apply constraint when max_cost_usd is 0', () => {
+            // max_cost_usd: 0 should be ignored (the condition checks > 0)
+            const toolCall = createTestToolCall({
+                tool: { name: 'http.request', capability: 'read' },
+                constraints: { max_cost_usd: 0 },
+            });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.001);
+        });
+        it('should not apply constraint when constraints is undefined', () => {
+            const toolCall = createTestToolCall({ constraints: undefined });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.001);
+        });
+        it('should look up capability-specific key for write on http.request', () => {
+            // http.request.write exists in COST_TABLE with value 0.002
+            const toolCall = createTestToolCall({ tool: { name: 'http.request', capability: 'write' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.002);
+        });
+        it('should fall back to base tool cost for write when no .write key exists', () => {
+            // slack.post with write capability: no slack.post.write entry, so falls back to slack.post (0.003)
+            const toolCall = createTestToolCall({ tool: { name: 'slack.post', capability: 'write' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.003);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Budget Check
+    // -----------------------------------------------------------------------
+    describe('check', () => {
+        it('should allow call when within all limits', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(true);
+            expect(result.reason).toBeUndefined();
+            expect(result.report).toBeDefined();
+            expect(result.report.estimated_cost_usd).toBe(0.001);
+            expect(result.report.spent_cost_usd_task).toBe(0);
+            expect(result.report.remaining_cost_usd_task).toBe(2.0);
+        });
+        it('should deny when task budget would be exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.005 }));
+            const toolCall = createTestToolCall();
+            // Record enough spend to nearly exhaust budget
+            manager.record(toolCall, 0.005);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Task budget exceeded');
+        });
+        it('should deny when step limit exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_steps_per_task: 2 }));
+            const toolCall = createTestToolCall();
+            // Record 2 steps
+            manager.record(toolCall, 0.0001);
+            manager.record(toolCall, 0.0001);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Step limit exceeded');
+        });
+        it('should deny when wall clock time exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_wall_clock_ms: 100 }));
+            // Create a tool call with a timestamp far in the past
+            const pastTimestamp = new Date(Date.now() - 200).toISOString();
+            const toolCall = createTestToolCall({ timestamp: pastTimestamp });
+            // Force creation of task state with the old timestamp
+            // by issuing a check (which calls getTaskState internally)
+            // The first check initialises state with toolCall.timestamp
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Wall clock time exceeded');
+        });
+        it('should deny when user daily budget exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_daily_budget_usd: 0.003 }));
+            const toolCall = createTestToolCall();
+            // Record enough to hit user daily limit
+            manager.record(toolCall, 0.003);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('User daily budget exceeded');
+        });
+        it('should deny when user monthly budget exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_monthly_budget_usd: 0.003 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.003);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('User monthly budget exceeded');
+        });
+        it('should deny when workspace daily budget exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ workspace_daily_budget_usd: 0.003 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.003);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Workspace daily budget exceeded');
+        });
+        it('should deny when workspace monthly budget exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ workspace_monthly_budget_usd: 0.003 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.003);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Workspace monthly budget exceeded');
+        });
+        it('should still allow when exactly at task budget minus estimated cost', () => {
+            // task_budget = 0.010, spent = 0.009, estimated = 0.001 => 0.009 + 0.001 = 0.010 => equal, not exceeded
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.010 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.009);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(true);
+        });
+        it('should deny when just over task budget', () => {
+            // task_budget = 0.010, spent = 0.0091, estimated = 0.001 => 0.0101 > 0.010
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.010 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.0091);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Task budget exceeded');
+        });
+        it('should still allow when at exactly max_steps minus one', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_steps_per_task: 3 }));
+            const toolCall = createTestToolCall();
+            // Record 2 steps, so next would be step 3 (exactly max)
+            manager.record(toolCall, 0.0001);
+            manager.record(toolCall, 0.0001);
+            const result = manager.check(toolCall);
+            // steps = 2, steps + 1 = 3, max_steps = 3 => 3 > 3 is false => allowed
+            expect(result.allowed).toBe(true);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Recording Costs
+    // -----------------------------------------------------------------------
+    describe('record', () => {
+        let manager;
+        beforeEach(() => {
+            manager = new manager_1.BudgetManager(defaultConfig());
+        });
+        it('should update task spent_usd after recording', () => {
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.005);
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBe(0.005);
+        });
+        it('should update task steps after recording', () => {
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.001);
+            manager.record(toolCall, 0.001);
+            // After 2 records, spent should be 0.002 and remaining = 2.0 - 0.002 = 1.998
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBeCloseTo(0.002, 6);
+            expect(report.remaining_cost_usd_task).toBeCloseTo(1.998, 6);
+        });
+        it('should update user daily spend', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_daily_budget_usd: 1.0 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.5);
+            // After recording 0.5, a subsequent check should show 0.5 spent for user daily
+            // We can verify indirectly: record more, then check if the total triggers denial
+            manager.record(toolCall, 0.5);
+            const result = manager.check(toolCall);
+            // user daily spend now 1.0 + estimated 0.001 > 1.0 => denied
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('User daily budget exceeded');
+        });
+        it('should update workspace daily spend', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ workspace_daily_budget_usd: 0.01 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.01);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Workspace daily budget exceeded');
+        });
+        it('should update user monthly spend', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_monthly_budget_usd: 0.01 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.01);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('User monthly budget exceeded');
+        });
+        it('should update workspace monthly spend', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ workspace_monthly_budget_usd: 0.01 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.01);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Workspace monthly budget exceeded');
+        });
+        it('should accumulate costs across multiple records', () => {
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.001);
+            manager.record(toolCall, 0.002);
+            manager.record(toolCall, 0.003);
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBeCloseTo(0.006, 6);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Retry Tracking
+    // -----------------------------------------------------------------------
+    describe('recordRetry', () => {
+        it('should allow retries within limit', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_retries_per_call: 3 }));
+            const r1 = manager.recordRetry('tc-001');
+            expect(r1.allowed).toBe(true);
+            expect(r1.count).toBe(1);
+            const r2 = manager.recordRetry('tc-001');
+            expect(r2.allowed).toBe(true);
+            expect(r2.count).toBe(2);
+            const r3 = manager.recordRetry('tc-001');
+            expect(r3.allowed).toBe(true);
+            expect(r3.count).toBe(3);
+        });
+        it('should deny retries when limit exceeded', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_retries_per_call: 2 }));
+            manager.recordRetry('tc-001');
+            manager.recordRetry('tc-001');
+            const r3 = manager.recordRetry('tc-001');
+            expect(r3.allowed).toBe(false);
+            expect(r3.count).toBe(3);
+        });
+        it('should track retries independently per tool call', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ max_retries_per_call: 2 }));
+            manager.recordRetry('tc-001');
+            manager.recordRetry('tc-001');
+            // tc-002 has its own counter
+            const r1 = manager.recordRetry('tc-002');
+            expect(r1.allowed).toBe(true);
+            expect(r1.count).toBe(1);
+            // tc-001 is at its limit
+            const r3 = manager.recordRetry('tc-001');
+            expect(r3.allowed).toBe(false);
+            expect(r3.count).toBe(3);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Budget Report
+    // -----------------------------------------------------------------------
+    describe('getReport', () => {
+        it('should calculate correct report for fresh task', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 5.0 }));
+            const toolCall = createTestToolCall();
+            const report = manager.getReport(toolCall, 0.01);
+            expect(report.estimated_cost_usd).toBe(0.01);
+            expect(report.spent_cost_usd_task).toBe(0);
+            expect(report.remaining_cost_usd_task).toBe(5.0);
+        });
+        it('should calculate correct remaining after spend', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 1.0 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.3);
+            const report = manager.getReport(toolCall, 0.1);
+            expect(report.estimated_cost_usd).toBe(0.1);
+            expect(report.spent_cost_usd_task).toBeCloseTo(0.3, 6);
+            expect(report.remaining_cost_usd_task).toBeCloseTo(0.7, 6);
+        });
+        it('should clamp remaining to zero when overspent', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.001 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.005);
+            const report = manager.getReport(toolCall, 0);
+            // remaining should be Math.max(0, 0.001 - 0.005) = 0
+            expect(report.remaining_cost_usd_task).toBe(0);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Reset
+    // -----------------------------------------------------------------------
+    describe('reset', () => {
+        it('should clear all internal state', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_daily_budget_usd: 1.0 }));
+            const toolCall = createTestToolCall();
+            // Record some state
+            manager.record(toolCall, 0.5);
+            manager.recordRetry('tc-001');
+            // After reset, everything should be fresh
+            manager.reset();
+            const report = manager.getReport(toolCall, 0.001);
+            expect(report.spent_cost_usd_task).toBe(0);
+            expect(report.remaining_cost_usd_task).toBe(2.0);
+            // Retries should also be cleared
+            const retry = manager.recordRetry('tc-001');
+            expect(retry.count).toBe(1);
+            expect(retry.allowed).toBe(true);
+            // Budget check should pass again
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(true);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Multiple Tasks Tracked Independently
+    // -----------------------------------------------------------------------
+    describe('multiple tasks', () => {
+        it('should track tasks independently', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.01 }));
+            const task1 = createTestToolCall({ task_id: 'task-A' });
+            const task2 = createTestToolCall({ task_id: 'task-B' });
+            manager.record(task1, 0.008);
+            manager.record(task2, 0.001);
+            // task-A is nearly exhausted
+            const report1 = manager.getReport(task1, 0);
+            expect(report1.spent_cost_usd_task).toBeCloseTo(0.008, 6);
+            expect(report1.remaining_cost_usd_task).toBeCloseTo(0.002, 6);
+            // task-B has plenty remaining
+            const report2 = manager.getReport(task2, 0);
+            expect(report2.spent_cost_usd_task).toBeCloseTo(0.001, 6);
+            expect(report2.remaining_cost_usd_task).toBeCloseTo(0.009, 6);
+            // task-A next call should be denied (0.008 + 0.001 estimated > 0.01? No, 0.009 <= 0.01)
+            const check1 = manager.check(task1);
+            expect(check1.allowed).toBe(true);
+            // Record more on task-A to push it over
+            manager.record(task1, 0.002);
+            const check1b = manager.check(task1);
+            expect(check1b.allowed).toBe(false);
+            expect(check1b.reason).toContain('Task budget exceeded');
+            // task-B should still be fine
+            const check2 = manager.check(task2);
+            expect(check2.allowed).toBe(true);
+        });
+        it('should share user spend across tasks', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ user_daily_budget_usd: 0.005, task_budget_usd: 10 }));
+            const task1 = createTestToolCall({ task_id: 'task-A', actor: { type: 'agent', id: 'agent-001' } });
+            const task2 = createTestToolCall({ task_id: 'task-B', actor: { type: 'agent', id: 'agent-001' } });
+            // Spend across two tasks under the same user
+            manager.record(task1, 0.003);
+            manager.record(task2, 0.002);
+            // Total user daily spend = 0.005, any further call should be denied
+            const check = manager.check(task2);
+            expect(check.allowed).toBe(false);
+            expect(check.reason).toContain('User daily budget exceeded');
+        });
+        it('should share workspace spend across different actors', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ workspace_daily_budget_usd: 0.005, task_budget_usd: 10 }));
+            const tc1 = createTestToolCall({
+                task_id: 'task-A',
+                workspace_id: 'ws-001',
+                actor: { type: 'agent', id: 'agent-001' },
+            });
+            const tc2 = createTestToolCall({
+                task_id: 'task-B',
+                workspace_id: 'ws-001',
+                actor: { type: 'agent', id: 'agent-002' },
+            });
+            manager.record(tc1, 0.003);
+            manager.record(tc2, 0.002);
+            // Both share workspace spend; total = 0.005
+            const check = manager.check(tc2);
+            expect(check.allowed).toBe(false);
+            expect(check.reason).toContain('Workspace daily budget exceeded');
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Default Config Values
+    // -----------------------------------------------------------------------
+    describe('default config values', () => {
+        it('should apply default task_budget_usd when not provided', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config = manager.getConfig();
+            expect(config.task_budget_usd).toBe(2.0);
+        });
+        it('should apply default max_steps_per_task when not provided', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config = manager.getConfig();
+            expect(config.max_steps_per_task).toBe(50);
+        });
+        it('should apply default max_retries_per_call when not provided', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config = manager.getConfig();
+            expect(config.max_retries_per_call).toBe(3);
+        });
+        it('should apply default max_wall_clock_ms when not provided', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config = manager.getConfig();
+            expect(config.max_wall_clock_ms).toBe(300000);
+        });
+        it('should leave optional budgets undefined when not provided', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config = manager.getConfig();
+            expect(config.user_daily_budget_usd).toBeUndefined();
+            expect(config.user_monthly_budget_usd).toBeUndefined();
+            expect(config.workspace_daily_budget_usd).toBeUndefined();
+            expect(config.workspace_monthly_budget_usd).toBeUndefined();
+        });
+        it('should override defaults when explicit values provided', () => {
+            const manager = new manager_1.BudgetManager({
+                task_budget_usd: 10,
+                max_steps_per_task: 100,
+                max_retries_per_call: 5,
+                max_wall_clock_ms: 600000,
+            });
+            const config = manager.getConfig();
+            expect(config.task_budget_usd).toBe(10);
+            expect(config.max_steps_per_task).toBe(100);
+            expect(config.max_retries_per_call).toBe(5);
+            expect(config.max_wall_clock_ms).toBe(600000);
+        });
+        it('should return a copy of config (not the original)', () => {
+            const manager = new manager_1.BudgetManager({});
+            const config1 = manager.getConfig();
+            const config2 = manager.getConfig();
+            expect(config1).toEqual(config2);
+            expect(config1).not.toBe(config2);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Budget check report structure
+    // -----------------------------------------------------------------------
+    describe('check report structure', () => {
+        it('should include all required fields in report when allowed', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const result = manager.check(toolCall);
+            expect(result.report).toHaveProperty('estimated_cost_usd');
+            expect(result.report).toHaveProperty('spent_cost_usd_task');
+            expect(result.report).toHaveProperty('remaining_cost_usd_task');
+            expect(typeof result.report.estimated_cost_usd).toBe('number');
+            expect(typeof result.report.spent_cost_usd_task).toBe('number');
+            expect(typeof result.report.remaining_cost_usd_task).toBe('number');
+        });
+        it('should include report even when denied', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.0001 }));
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.001);
+            const result = manager.check(toolCall);
+            expect(result.allowed).toBe(false);
+            expect(result.report).toBeDefined();
+            expect(result.report.estimated_cost_usd).toBeGreaterThan(0);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Configurable Cost Table
+    // -----------------------------------------------------------------------
+    describe('configurable cost table', () => {
+        it('should use default cost table when no override provided', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const costTable = manager.getCostTable();
+            expect(costTable['http.request']).toBe(0.001);
+            expect(costTable['default']).toBe(0.001);
+        });
+        it('should merge custom cost_table over defaults', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({
+                cost_table: {
+                    'http.request': 0.01,
+                    'llm.completion': 0.05,
+                },
+            }));
+            const costTable = manager.getCostTable();
+            // Custom overrides applied
+            expect(costTable['http.request']).toBe(0.01);
+            expect(costTable['llm.completion']).toBe(0.05);
+            // Defaults preserved
+            expect(costTable['slack.post']).toBe(0.003);
+            expect(costTable['default']).toBe(0.001);
+        });
+        it('should use custom cost_table values for estimateCost', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({
+                cost_table: { 'http.request': 0.05 },
+            }));
+            const toolCall = createTestToolCall({ tool: { name: 'http.request', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.05);
+        });
+        it('should allow overriding the default cost', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({
+                cost_table: { 'default': 0.01 },
+            }));
+            const toolCall = createTestToolCall({ tool: { name: 'unknown.tool', capability: 'read' } });
+            const estimate = manager.estimateCost(toolCall);
+            expect(estimate.estimated_cost_usd).toBe(0.01);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // CostRecord recording
+    // -----------------------------------------------------------------------
+    describe('record with CostRecord', () => {
+        it('should accept a CostRecord object', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, {
+                estimated_cost_usd: 0.001,
+                actual_cost_usd: 0.015,
+                usage: { input_tokens: 500, output_tokens: 200, total_tokens: 700, source: 'headers' },
+            });
+            const report = manager.getReport(toolCall, 0);
+            // Should have used actual_cost_usd (0.015) for spend tracking
+            expect(report.spent_cost_usd_task).toBe(0.015);
+        });
+        it('should fall back to estimated_cost_usd when actual is not provided', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, {
+                estimated_cost_usd: 0.005,
+            });
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBe(0.005);
+        });
+        it('should store CostRecord for retrieval', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const costRecord = {
+                estimated_cost_usd: 0.001,
+                actual_cost_usd: 0.015,
+                usage: { input_tokens: 500, output_tokens: 200 },
+            };
+            manager.record(toolCall, costRecord);
+            const retrieved = manager.getCostRecord(toolCall.tool_call_id);
+            expect(retrieved).toEqual(costRecord);
+        });
+        it('should return undefined for unknown tool_call_id', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            expect(manager.getCostRecord('nonexistent')).toBeUndefined();
+        });
+        it('should still accept plain number for backward compatibility', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            manager.record(toolCall, 0.003);
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBe(0.003);
+            // No CostRecord stored when using plain number
+            expect(manager.getCostRecord(toolCall.tool_call_id)).toBeUndefined();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // getReportWithActual
+    // -----------------------------------------------------------------------
+    describe('getReportWithActual', () => {
+        it('should include actual_cost_usd and usage in report', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const usage = { input_tokens: 500, output_tokens: 200, total_tokens: 700, source: 'headers' };
+            const report = manager.getReportWithActual(toolCall, 0.001, 0.015, usage);
+            expect(report.estimated_cost_usd).toBe(0.001);
+            expect(report.actual_cost_usd).toBe(0.015);
+            expect(report.usage).toEqual(usage);
+            expect(report.spent_cost_usd_task).toBe(0);
+            expect(report.remaining_cost_usd_task).toBe(2.0);
+        });
+        it('should work without actual cost or usage', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const report = manager.getReportWithActual(toolCall, 0.001);
+            expect(report.estimated_cost_usd).toBe(0.001);
+            expect(report.actual_cost_usd).toBeUndefined();
+            expect(report.usage).toBeUndefined();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Token pricing config
+    // -----------------------------------------------------------------------
+    describe('token pricing config', () => {
+        it('should store token_pricing in config', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({
+                token_pricing: {
+                    'gpt-4': { input_per_token: 0.00003, output_per_token: 0.00006 },
+                },
+            }));
+            const config = manager.getConfig();
+            expect(config.token_pricing).toBeDefined();
+            expect(config.token_pricing['gpt-4']).toEqual({
+                input_per_token: 0.00003,
+                output_per_token: 0.00006,
+            });
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Budget Reservation (S5: Atomic check + reserve)
+    // -----------------------------------------------------------------------
+    describe('reserveAndCheck', () => {
+        it('should atomically check and reserve budget', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const result = await manager.reserveAndCheck(toolCall);
+            expect(result.allowed).toBe(true);
+            expect(result.reservationKey).toBeDefined();
+            expect(result.reservationKey).toContain('reservation:');
+            // The reserved amount should be reflected in the spent budget
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBe(0.001); // estimated cost reserved
+        });
+        it('should deny when reservation would exceed task budget', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.001 }));
+            const toolCall = createTestToolCall();
+            // First reservation takes the whole budget
+            const first = await manager.reserveAndCheck(toolCall);
+            expect(first.allowed).toBe(true);
+            // Second reservation should be denied (budget exhausted)
+            const second = await manager.reserveAndCheck(createTestToolCall({ tool_call_id: 'tc-002' }));
+            expect(second.allowed).toBe(false);
+            expect(second.reason).toContain('Task budget exceeded');
+        });
+        it('should prevent concurrent requests from both passing budget check', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.0015 }));
+            const tc1 = createTestToolCall({ tool_call_id: 'tc-001' });
+            const tc2 = createTestToolCall({ tool_call_id: 'tc-002' });
+            // First reservation passes (0.001 estimated)
+            const r1 = await manager.reserveAndCheck(tc1);
+            expect(r1.allowed).toBe(true);
+            // Second reservation should fail (0.001 reserved + 0.001 estimated > 0.0015)
+            const r2 = await manager.reserveAndCheck(tc2);
+            expect(r2.allowed).toBe(false);
+        });
+    });
+    describe('commitReservation', () => {
+        it('should adjust budget when actual cost differs from estimate', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 1.0 }));
+            const toolCall = createTestToolCall();
+            const result = await manager.reserveAndCheck(toolCall);
+            expect(result.allowed).toBe(true);
+            // Reserved 0.001 (estimated), but actual cost is 0.0005
+            manager.commitReservation(result.reservationKey, 0.0005);
+            // Budget should reflect actual cost (0.0005), not estimated (0.001)
+            const report = manager.getReport(toolCall, 0);
+            expect(report.spent_cost_usd_task).toBeCloseTo(0.0005, 6);
+            expect(report.remaining_cost_usd_task).toBeCloseTo(0.9995, 6);
+        });
+        it('should be a no-op for unknown reservation key', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            // Should not throw
+            manager.commitReservation('reservation:unknown', 0.001);
+        });
+    });
+    describe('releaseReservation', () => {
+        it('should fully release reserved budget', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            const toolCall = createTestToolCall();
+            const result = await manager.reserveAndCheck(toolCall);
+            expect(result.allowed).toBe(true);
+            // Verify budget was reserved
+            const beforeRelease = manager.getReport(toolCall, 0);
+            expect(beforeRelease.spent_cost_usd_task).toBe(0.001);
+            // Release the reservation
+            manager.releaseReservation(result.reservationKey);
+            // Budget should be fully restored
+            const afterRelease = manager.getReport(toolCall, 0);
+            expect(afterRelease.spent_cost_usd_task).toBe(0);
+            expect(afterRelease.remaining_cost_usd_task).toBe(2.0);
+        });
+        it('should be a no-op for unknown reservation key', () => {
+            const manager = new manager_1.BudgetManager(defaultConfig());
+            // Should not throw
+            manager.releaseReservation('reservation:unknown');
+        });
+        it('should restore budget for subsequent reservations after release', async () => {
+            const manager = new manager_1.BudgetManager(defaultConfig({ task_budget_usd: 0.0015 }));
+            const tc1 = createTestToolCall({ tool_call_id: 'tc-001' });
+            const tc2 = createTestToolCall({ tool_call_id: 'tc-002' });
+            // First reservation
+            const r1 = await manager.reserveAndCheck(tc1);
+            expect(r1.allowed).toBe(true);
+            // Second would fail due to budget
+            const r2Fail = await manager.reserveAndCheck(tc2);
+            expect(r2Fail.allowed).toBe(false);
+            // Release first reservation
+            manager.releaseReservation(r1.reservationKey);
+            // Now second should succeed
+            const r2Pass = await manager.reserveAndCheck(tc2);
+            expect(r2Pass.allowed).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=budget-manager.test.js.map