@roj-ai/sdk 0.1.35 → 0.2.1

package/dist/plugins/limits-guard/limits-guard.integration.test.js

@@ -1,887 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import z from 'zod/v4';
-import { AgentId } from '../../core/agents/schema.js';
-import { agentEvents } from '../../core/agents/state.js';
-import { MockLLMProvider } from '../../core/llm/mock.js';
-import { ModelId } from '../../core/llm/schema.js';
-import { llmEvents } from '../../core/llm/state.js';
-import { selectPluginState } from '../../core/sessions/reducer.js';
-import { createTool } from '../../core/tools/definition.js';
-import { ToolCallId } from '../../core/tools/schema.js';
-import { toolEvents } from '../../core/tools/state.js';
-import { Ok } from '../../lib/utils/result.js';
-import { contextCompactPlugin } from '../../plugins/context-compact/index.js';
-import { getAgentMailbox, selectMailboxState } from '../../plugins/mailbox/query.js';
-import { mailboxEvents } from '../../plugins/mailbox/state.js';
-import { createMultiAgentPreset, createTestPreset, TestHarness } from '../../testing/index.js';
-import { limitsEvents, limitsGuardPlugin } from './plugin.js';
-function createLimitsHarness(options) {
-    return new TestHarness({ ...options, systemPlugins: [limitsGuardPlugin] });
-}
-/**
- * Wait for a specific agent to reach 'paused' status (or timeout).
- * Polls the TestSession's state directly (live getter).
- */
-async function waitForAgentPaused(session, agentId, timeoutMs = 10000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const agentState = session.state.agents.get(agentId);
-        if (agentState?.status === 'paused')
-            return;
-        await new Promise(r => setTimeout(r, 10));
-    }
-    throw new Error(`waitForAgentPaused timed out after ${timeoutMs}ms for agent ${agentId}`);
-}
-async function waitUntil(predicate, timeoutMs = 10000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (predicate())
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    throw new Error(`waitUntil timed out after ${timeoutMs}ms`);
-}
-/**
- * Wait for all agents to be either idle (pending with no work) or paused.
- */
-async function waitForAllSettled(session, timeoutMs = 10000) {
-    const deadline = Date.now() + timeoutMs;
-    outer: while (Date.now() < deadline) {
-        for (const [, agentState] of session.state.agents) {
-            if (agentState.status === 'paused')
-                continue;
-            if (agentState.status === 'pending' && agentState.pendingToolCalls.length === 0 && agentState.pendingToolResults.length === 0) {
-                continue;
-            }
-            await new Promise(r => setTimeout(r, 10));
-            continue outer;
-        }
-        // Double-check after a brief delay
-        await new Promise(r => setTimeout(r, 10));
-        for (const [, agentState] of session.state.agents) {
-            if (agentState.status === 'paused')
-                continue;
-            if (agentState.status === 'pending' && agentState.pendingToolCalls.length === 0 && agentState.pendingToolResults.length === 0) {
-                continue;
-            }
-            continue outer;
-        }
-        return;
-    }
-    throw new Error(`waitForAllSettled timed out after ${timeoutMs}ms`);
-}
-describe('limits-guard plugin', () => {
-    // =========================================================================
-    // hard limits
-    // =========================================================================
-    describe('hard limits', () => {
-        it('agent exceeding inference hard limit → agent_paused event → agent stops', async () => {
-            let inferenceCount = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxTurns: 3 } })],
-                    })],
-                mockHandler: () => {
-                    inferenceCount++;
-                    return {
-                        content: null,
-                        toolCalls: [{ id: ToolCallId(`tc${inferenceCount}`), name: 'tell_user', input: { message: `Turn ${inferenceCount}` } }],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetrics(),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, entryAgentId);
-            const entryAgent = session.state.agents.get(entryAgentId);
-            expect(entryAgent.status).toBe('paused');
-            const pausedEvents = await session.getEventsByType(agentEvents, 'agent_paused');
-            expect(pausedEvents.length).toBeGreaterThanOrEqual(1);
-            const pauseEvent = pausedEvents.find(e => e.agentId === entryAgentId);
-            expect(pauseEvent).toBeDefined();
-            expect(pauseEvent.reason).toBe('handler');
-            await harness.shutdown();
-        });
-        it('agent exceeding tool call hard limit → agent paused', async () => {
-            let callNum = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxToolCalls: 3, maxTurns: 100 } })],
-                    })],
-                mockHandler: () => {
-                    callNum++;
-                    return {
-                        content: null,
-                        toolCalls: [
-                            { id: ToolCallId(`tc${callNum}a`), name: 'tell_user', input: { message: `A${callNum}` } },
-                            { id: ToolCallId(`tc${callNum}b`), name: 'tell_user', input: { message: `B${callNum}` } },
-                        ],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetrics(),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, entryAgentId);
-            const entryAgent = session.state.agents.get(entryAgentId);
-            expect(entryAgent.status).toBe('paused');
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(counters).toBeDefined();
-            expect(counters.toolCallCount).toBeGreaterThanOrEqual(3);
-            await harness.shutdown();
-        });
-        it('agent exceeding spawned agent limit → agent paused', async () => {
-            let orchestratorCalls = 0;
-            const harness = createLimitsHarness({
-                presets: [createMultiAgentPreset([
-                        { name: 'worker', system: 'Worker agent.', tools: [], agents: [] },
-                    ], { orchestratorSystem: 'Orchestrator agent.' })],
-                mockHandler: (request) => {
-                    if (request.systemPrompt.includes('Orchestrator')) {
-                        orchestratorCalls++;
-                        return {
-                            content: null,
-                            toolCalls: [
-                                { id: ToolCallId(`tc${orchestratorCalls}a`), name: 'start_worker', input: { message: `Task ${orchestratorCalls}a` } },
-                                { id: ToolCallId(`tc${orchestratorCalls}b`), name: 'start_worker', input: { message: `Task ${orchestratorCalls}b` } },
-                            ],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Worker done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            const orchestratorId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, orchestratorId, 15000);
-            const orch = session.state.agents.get(orchestratorId);
-            expect(orch.status).toBe('paused');
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(orchestratorId);
-            expect(counters).toBeDefined();
-            expect(counters.spawnedAgentCount).toBeGreaterThanOrEqual(10);
-            await harness.shutdown();
-        });
-        it('communication-only loop without new inbound work → soft-stops and remains wakeable', async () => {
-            let inferenceCount = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({
-                                limits: { maxConsecutiveNoProgressTurns: 3, maxTurns: 100 },
-                            })],
-                    })],
-                mockHandler: () => {
-                    inferenceCount++;
-                    if (inferenceCount > 4) {
-                        return {
-                            content: 'Recovered for new work',
-                            toolCalls: [],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return {
-                        content: null,
-                        toolCalls: [{
-                                id: ToolCallId(`tc${inferenceCount}`),
-                                name: 'tell_user',
-                                input: { message: `Still waiting, update ${inferenceCount}` },
-                            }],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetrics(),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendAndWaitForIdle('Start');
-            // The response to "Start" had inbound work. The next three turns were
-            // driven only by the previous tell_user result, so the fourth inference
-            // reaches the limit and its redundant tool call is suppressed.
-            expect(inferenceCount).toBe(4);
-            const toolStarted = await session.getEventsByType(toolEvents, 'tool_started');
-            expect(toolStarted).toHaveLength(3);
-            const pauseEvents = await session.getEventsByType(agentEvents, 'agent_paused');
-            expect(pauseEvents.some((event) => event.agentId === entryAgentId)).toBe(false);
-            const warningEvents = await session.getEventsByType(limitsEvents, 'limit_warning');
-            const noProgressEvent = warningEvents.find((event) => event.agentId === entryAgentId
-                && event.limitName === 'maxConsecutiveNoProgressTurns');
-            expect(noProgressEvent?.currentValue).toBe(3);
-            expect(noProgressEvent?.message).toContain('until new input arrives');
-            expect(session.state.agents.get(entryAgentId)?.status).toBe('pending');
-            // The stop is recoverable without agents.resume or human intervention.
-            await session.sendAndWaitForIdle('Now do real work');
-            expect(inferenceCount).toBe(5);
-            expect(session.state.agents.get(entryAgentId)?.status).toBe('pending');
-            await harness.shutdown();
-        });
-        it('communication-only replies to distinct user messages do not count as no progress', async () => {
-            let inferenceCount = 0;
-            let allowProcessing = false;
-            const preset = createTestPreset({
-                orchestratorSystem: 'Test agent.',
-                orchestratorPlugins: [limitsGuardPlugin.configureAgent({
-                        limits: { maxConsecutiveNoProgressTurns: 3, maxTurns: 100 },
-                    })],
-            });
-            preset.orchestrator.debounceCallback = () => {
-                if (!allowProcessing)
-                    return 'wait';
-                allowProcessing = false;
-                return 'process_now';
-            };
-            preset.orchestrator.checkIntervalMs = 1;
-            const harness = createLimitsHarness({
-                presets: [preset],
-                mockHandler: () => {
-                    inferenceCount++;
-                    return {
-                        content: null,
-                        toolCalls: [{
-                                id: ToolCallId(`reply-${inferenceCount}`),
-                                name: 'tell_user',
-                                input: { message: `Reply ${inferenceCount}` },
-                            }],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetrics(),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            for (let messageNumber = 1; messageNumber <= 3; messageNumber++) {
-                await session.sendMessage(`User message ${messageNumber}`);
-                allowProcessing = true;
-                await waitUntil(() => {
-                    const state = session.state.agents.get(entryAgentId);
-                    return inferenceCount === messageNumber && state?.pendingToolResults.length === 1;
-                });
-                const counters = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-                expect(counters?.consecutiveNoProgressTurns).toBe(0);
-            }
-            const consumedEvents = await session.getEventsByType(agentEvents, 'agent_input_consumed');
-            expect(consumedEvents).toHaveLength(3);
-            expect(consumedEvents.every((event) => event.sourcePlugins.includes('user-chat'))).toBe(true);
-            const pauseEvents = await session.getEventsByType(agentEvents, 'agent_paused');
-            expect(pauseEvents.some((event) => event.agentId === entryAgentId)).toBe(false);
-            const warningEvents = await session.getEventsByType(limitsEvents, 'limit_warning');
-            expect(warningEvents.some((event) => event.limitName === 'maxConsecutiveNoProgressTurns')).toBe(false);
-            await harness.shutdown();
-        });
-        it('send_message followed by non-communication work does not trip the no-progress limit', async () => {
-            let workerInferenceCount = 0;
-            let workCount = 0;
-            const recordWork = createTool({
-                name: 'record_work',
-                description: 'Record one unit of real work.',
-                input: z.object({}),
-                execute: async () => {
-                    workCount++;
-                    return Ok('work recorded');
-                },
-            });
-            const harness = createLimitsHarness({
-                presets: [createMultiAgentPreset([
-                        {
-                            name: 'worker',
-                            system: 'Worker agent.',
-                            tools: [recordWork],
-                            agents: [],
-                            plugins: [limitsGuardPlugin.configureAgent({
-                                    limits: { maxConsecutiveNoProgressTurns: 2, maxTurns: 100 },
-                                })],
-                        },
-                    ], { orchestratorSystem: 'Orchestrator agent.' })],
-                mockHandler: (request) => {
-                    if (request.systemPrompt.endsWith('Orchestrator agent.')) {
-                        const hasStartedWorker = request.messages.some((message) => message.role === 'assistant'
-                            && message.toolCalls?.some((toolCall) => toolCall.name === 'start_worker'));
-                        if (!hasStartedWorker) {
-                            return {
-                                content: null,
-                                toolCalls: [{ id: ToolCallId('start-worker'), name: 'start_worker', input: { message: 'Do the work' } }],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        }
-                        return {
-                            content: 'Orchestration complete',
-                            toolCalls: [],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    workerInferenceCount++;
-                    switch (workerInferenceCount) {
-                        case 1:
-                            return {
-                                content: null,
-                                toolCalls: [{
-                                        id: ToolCallId('worker-progress'),
-                                        name: 'send_message',
-                                        input: { to: 'parent', message: 'Starting real work' },
-                                    }],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        case 2:
-                            return {
-                                content: null,
-                                toolCalls: [{ id: ToolCallId('worker-work'), name: 'record_work', input: {} }],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        case 3:
-                            return {
-                                content: null,
-                                toolCalls: [{
-                                        id: ToolCallId('worker-result'),
-                                        name: 'send_message',
-                                        input: { to: 'parent', message: 'Real work complete' },
-                                    }],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        default:
-                            return {
-                                content: 'WAITING',
-                                toolCalls: [],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                    }
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendAndWaitForIdle('Start', { timeoutMs: 10_000 });
-            expect(workCount).toBe(1);
-            expect(workerInferenceCount).toBe(4);
-            expect(session.state.agents.get(AgentId('worker_1'))?.status).toBe('pending');
-            const pauseEvents = await session.getEventsByType(agentEvents, 'agent_paused');
-            expect(pauseEvents.some((event) => event.agentId === AgentId('worker_1'))).toBe(false);
-            await harness.shutdown();
-        });
-    });
-    // =========================================================================
-    // soft limits (status display)
-    // =========================================================================
-    describe('soft limits (status display)', () => {
-        it('approaching limit (80%) → status contains warning message', async () => {
-            let inferenceCount = 0;
-            let sawWarning = false;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({
-                                limits: { maxTurns: 5, maxConsecutiveNoProgressTurns: 100 },
-                            })],
-                    })],
-                mockHandler: (request) => {
-                    inferenceCount++;
-                    const messagesStr = JSON.stringify(request.messages);
-                    if (messagesStr.includes('Approaching maxTurns limit')) {
-                        sawWarning = true;
-                    }
-                    if (inferenceCount < 5) {
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId(`tc${inferenceCount}`), name: 'tell_user', input: { message: `Turn ${inferenceCount}` } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            // Agent will be paused at turn 5 or finish at turn 5 if last response has no tools
-            await waitForAllSettled(session);
-            expect(sawWarning).toBe(true);
-            await harness.shutdown();
-        });
-    });
-    // =========================================================================
-    // counter tracking
-    // =========================================================================
-    describe('counter tracking', () => {
-        it('each inference increments inferenceCount', async () => {
-            let callCount = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxTurns: 100 } })],
-                    })],
-                mockHandler: () => {
-                    callCount++;
-                    if (callCount <= 2) {
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId(`tc${callCount}`), name: 'tell_user', input: { message: `Msg ${callCount}` } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendAndWaitForIdle('Start');
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(session.getEntryAgentId());
-            expect(counters).toBeDefined();
-            expect(counters.inferenceCount).toBe(3); // 2 with tools + 1 final
-            await harness.shutdown();
-        });
-        it('each tool call increments toolCallCount', async () => {
-            let callCount = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxTurns: 100 } })],
-                    })],
-                mockHandler: () => {
-                    callCount++;
-                    if (callCount === 1) {
-                        return {
-                            content: null,
-                            toolCalls: [
-                                { id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'A' } },
-                                { id: ToolCallId('tc2'), name: 'tell_user', input: { message: 'B' } },
-                            ],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendAndWaitForIdle('Start');
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(session.getEntryAgentId());
-            expect(counters).toBeDefined();
-            expect(counters.toolCallCount).toBe(2);
-            await harness.shutdown();
-        });
-        it('each agent spawn increments parent spawnedAgentCount', async () => {
-            let orchestratorCalls = 0;
-            const harness = createLimitsHarness({
-                presets: [createMultiAgentPreset([
-                        { name: 'worker', system: 'Worker agent.', tools: [], agents: [] },
-                    ], { orchestratorSystem: 'Orchestrator agent.' })],
-                mockHandler: (request) => {
-                    if (request.systemPrompt.includes('Orchestrator')) {
-                        orchestratorCalls++;
-                        if (orchestratorCalls === 1) {
-                            return {
-                                content: null,
-                                toolCalls: [
-                                    { id: ToolCallId('tc1'), name: 'start_worker', input: { message: 'Task 1' } },
-                                    { id: ToolCallId('tc2'), name: 'start_worker', input: { message: 'Task 2' } },
-                                ],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        }
-                        return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                    }
-                    return { content: 'Worker done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendAndWaitForIdle('Start', { timeoutMs: 10000 });
-            const orchestratorId = session.getEntryAgentId();
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(orchestratorId);
-            expect(counters).toBeDefined();
-            expect(counters.spawnedAgentCount).toBe(2);
-            await harness.shutdown();
-        });
-        it('each mailbox message increments sender messagesSentCount', async () => {
-            let orchestratorCalls = 0;
-            let workerCalls = 0;
-            const harness = createLimitsHarness({
-                presets: [createMultiAgentPreset([
-                        { name: 'worker', system: 'Worker agent.', tools: [], agents: [] },
-                    ], { orchestratorSystem: 'Orchestrator agent.' })],
-                mockHandler: (request) => {
-                    if (request.systemPrompt.includes('Orchestrator')) {
-                        orchestratorCalls++;
-                        if (orchestratorCalls === 1) {
-                            return {
-                                content: null,
-                                toolCalls: [{ id: ToolCallId('tc1'), name: 'start_worker', input: { message: 'Task' } }],
-                                finishReason: 'stop',
-                                metrics: MockLLMProvider.defaultMetrics(),
-                            };
-                        }
-                        return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                    }
-                    workerCalls++;
-                    if (workerCalls === 1) {
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId('tc2'), name: 'send_message', input: { to: 'parent', message: 'Report' } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Worker done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendAndWaitForIdle('Start', { timeoutMs: 10000 });
-            const workerCounters = selectPluginState(session.state, 'agentLimits')?.get(AgentId('worker_1'));
-            expect(workerCounters).toBeDefined();
-            expect(workerCounters.messagesSentCount).toBeGreaterThanOrEqual(1);
-            await harness.shutdown();
-        });
-    });
-    // =========================================================================
-    // resume resets
-    // =========================================================================
-    describe('resume resets', () => {
-        it('agent_resumed → pattern-based counters reset, cumulative counters preserved', async () => {
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({
-                                limits: { maxRepeatedResponses: 2, maxTurns: 100 },
-                            })],
-                    })],
-                // Always return the same text → triggers maxRepeatedResponses
-                mockHandler: () => ({
-                    content: 'I am stuck',
-                    toolCalls: [],
-                    finishReason: 'stop',
-                    metrics: MockLLMProvider.defaultMetrics(),
-                }),
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            // 1st identical response → ok → idle
-            await session.sendAndWaitForIdle('Message 1');
-            // 2nd identical response → maxRepeatedResponses = 2 → paused
-            await session.sendMessage('Message 2');
-            await waitForAgentPaused(session, entryAgentId);
-            expect(session.state.agents.get(entryAgentId).status).toBe('paused');
-            // Resume the agent
-            const resumeResult = await session.callPluginMethod('agents.resume', {
-                agentId: String(entryAgentId),
-            });
-            expect(resumeResult.ok).toBe(true);
-            // All counters should be reset after resume
-            const countersAfterResume = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(countersAfterResume).toBeDefined();
-            expect(countersAfterResume.inferenceCount).toBe(0);
-            expect(countersAfterResume.toolCallCount).toBe(0);
-            expect(countersAfterResume.recentResponseHashes).toEqual([]);
-            // Agent resumes with reset counters. Wait for it to settle (no work → idle).
-            await session.waitForIdle();
-            // Send 2 more messages to hit the limit again
-            await session.sendAndWaitForIdle('Message 3');
-            await session.sendMessage('Message 4');
-            await waitForAgentPaused(session, entryAgentId);
-            const resumedEvents = await session.getEventsByType(agentEvents, 'agent_resumed');
-            expect(resumedEvents.filter(e => e.agentId === entryAgentId)).toHaveLength(1);
-            await harness.shutdown();
-        });
-    });
-    // =========================================================================
-    // budgets (cost / tokens)
-    // =========================================================================
-    describe('budgets', () => {
-        it('agent exceeding cost budget → paused with budget_exceeded event', async () => {
-            let n = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        // $0.50 per call, $1.00 budget → pauses before the 3rd call.
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxCost: 1.0, maxTurns: 100 } })],
-                    })],
-                mockHandler: () => {
-                    n++;
-                    return {
-                        content: null,
-                        toolCalls: [{ id: ToolCallId(`tc${n}`), name: 'tell_user', input: { message: `Turn ${n}` } }],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetricsWithCost(0.5),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, entryAgentId);
-            expect(session.state.agents.get(entryAgentId).status).toBe('paused');
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(counters.costSpent).toBeGreaterThanOrEqual(1.0);
-            const budgetEvents = await session.getEventsByType(limitsEvents, 'budget_exceeded');
-            const evt = budgetEvents.find(e => e.agentId === entryAgentId);
-            expect(evt).toBeDefined();
-            expect(evt.scope).toBe('agent');
-            expect(evt.limitName).toBe('maxCost');
-            await harness.shutdown();
-        });
-        it('costSpent is preserved across resume — budget cannot be bypassed by pausing', async () => {
-            let n = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        orchestratorPlugins: [limitsGuardPlugin.configureAgent({ limits: { maxCost: 1.0, maxTurns: 100 } })],
-                    })],
-                mockHandler: () => {
-                    n++;
-                    return {
-                        content: null,
-                        toolCalls: [{ id: ToolCallId(`tc${n}`), name: 'tell_user', input: { message: `Turn ${n}` } }],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetricsWithCost(0.5),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, entryAgentId);
-            const before = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(before).toBeDefined();
-            expect(before.costSpent).toBeGreaterThanOrEqual(1.0);
-            await session.callPluginMethod('agents.resume', { agentId: String(entryAgentId) });
-            // Budget is still exhausted → agent pauses again immediately without inferring.
-            await waitForAgentPaused(session, entryAgentId);
-            const after = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(after).toBeDefined();
-            // Anti-looping counter reset…
-            expect(after.inferenceCount).toBe(0);
-            // …but spend preserved, so the cap is not bypassable.
-            expect(after.costSpent).toBeGreaterThanOrEqual(before.costSpent);
-            await harness.shutdown();
-        });
-        it('child pausing on budget → parent is notified via a child-paused message', async () => {
-            let orchestratorCalls = 0;
-            let workerCalls = 0;
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Orchestrator agent.',
-                        agents: [{
-                                name: 'worker',
-                                system: 'Worker agent.',
-                                tools: [],
-                                agents: [],
-                                // $0.50 per call, $0.50 budget → pauses at the 2nd inference's
-                                // beforeInference (after one completed call spent the budget).
-                                plugins: [limitsGuardPlugin.configureAgent({ limits: { maxCost: 0.5, maxTurns: 100 } })],
-                            }],
-                    })],
-                mockHandler: (request) => {
-                    // Worker: keep spending until the budget pauses it.
-                    if (request.systemPrompt.includes('Worker agent.')) {
-                        workerCalls++;
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId(`w${workerCalls}`), name: 'tell_user', input: { message: `Work ${workerCalls}` } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetricsWithCost(0.5),
-                        };
-                    }
-                    // Orchestrator: spawn the worker exactly once, then idle.
-                    orchestratorCalls++;
-                    if (orchestratorCalls === 1) {
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId('spawn'), name: 'start_worker', input: { message: 'Do work' } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Waiting', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, AgentId('worker_1'));
-            const orchestratorId = session.getEntryAgentId();
-            // The mailbox plugin's onPause hook reports the pause to the parent.
-            // onPause runs *after* the agent_paused event (which flips status to
-            // 'paused'), so poll for the notification.
-            const findNotice = async () => (await session.getEventsByType(mailboxEvents, 'mailbox_message')).find(m => m.toAgentId === orchestratorId
-                && m.message.from === AgentId('worker_1')
-                && m.message.content.includes('<child-paused')
-                && m.message.content.includes('worker_1'));
-            let notice = await findNotice();
-            const deadline = Date.now() + 5000;
-            while (!notice && Date.now() < deadline) {
-                await new Promise(r => setTimeout(r, 20));
-                notice = await findNotice();
-            }
-            expect(notice).toBeDefined();
-            await harness.shutdown();
-        });
-        it('child-paused notice is actually consumed by a parent that already went idle', async () => {
-            // Regression guard for the lifecycle: a parent that finished its work is
-            // NOT in a terminal "complete" state — it's persisted as `pending` with an
-            // empty mailbox. When the child pauses and delivers <child-paused>, the
-            // dequeue check flips the parent's decide() from "complete" back to "infer",
-            // so the parent wakes and reads the message rather than leaving it unconsumed.
-            let workerCalls = 0;
-            let orchestratorSawChildPaused = false;
-            const requestHasChildPaused = (request) => request.messages.some((m) => {
-                const c = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-                return c.includes('<child-paused');
-            });
-            const harness = createLimitsHarness({
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Orchestrator agent.',
-                        agents: [{
-                                name: 'worker',
-                                system: 'Worker agent.',
-                                tools: [],
-                                agents: [],
-                                plugins: [limitsGuardPlugin.configureAgent({ limits: { maxCost: 0.5, maxTurns: 100 } })],
-                            }],
-                    })],
-                mockHandler: (request) => {
-                    if (request.systemPrompt.includes('Worker agent.')) {
-                        workerCalls++;
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId(`w${workerCalls}`), name: 'tell_user', input: { message: `Work ${workerCalls}` } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetricsWithCost(0.5),
-                        };
-                    }
-                    // Orchestrator: spawn the worker once, then go idle. Any later wake-up
-                    // is driven by an incoming message — record if it carried the notice.
-                    if (requestHasChildPaused(request))
-                        orchestratorSawChildPaused = true;
-                    if (workerCalls === 0) {
-                        return {
-                            content: null,
-                            toolCalls: [{ id: ToolCallId('spawn'), name: 'start_worker', input: { message: 'Do work' } }],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetrics(),
-                        };
-                    }
-                    return { content: 'Acknowledged', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() };
-                },
-            });
-            const session = await harness.createSession('test');
-            await session.sendMessage('Start');
-            await waitForAgentPaused(session, AgentId('worker_1'));
-            // The parent should wake from idle and run an inference that includes the
-            // <child-paused> message — proving the notice is consumed, not orphaned.
-            const deadline = Date.now() + 5000;
-            while (!orchestratorSawChildPaused && Date.now() < deadline) {
-                await new Promise(r => setTimeout(r, 20));
-            }
-            expect(orchestratorSawChildPaused).toBe(true);
-            // And the message is marked consumed in the parent's mailbox.
-            const orchestratorId = session.getEntryAgentId();
-            const mailbox = getAgentMailbox(selectMailboxState(session.state), orchestratorId);
-            const childPausedMsg = mailbox.find((m) => m.content.includes('<child-paused'));
-            expect(childPausedMsg).toBeDefined();
-            expect(childPausedMsg.consumed).toBe(true);
-            await harness.shutdown();
-        });
-        it('compaction (auxiliary inference) cost counts toward the budget', async () => {
-            // The compaction summarization is a real, billed LLM call routed through
-            // runAuxiliaryInference → auxiliary_inference_completed. It must be charged
-            // against the cost budget, otherwise an agent could spend unboundedly on
-            // compaction without ever tripping its cap.
-            const REGULAR_COST = 0.1;
-            const SUMMARY_COST = 5.0;
-            // Compaction request detection: inline compaction appends a trailing user
-            // message containing the summarization marker.
-            const isSummarizationRequest = (request) => {
-                const last = request.messages[request.messages.length - 1];
-                if (!last || last.role !== 'user')
-                    return false;
-                const content = typeof last.content === 'string' ? last.content : JSON.stringify(last.content);
-                return content.includes('[CONTEXT COMPACTION REQUEST]');
-            };
-            const harness = new TestHarness({
-                systemPlugins: [contextCompactPlugin, limitsGuardPlugin],
-                presets: [createTestPreset({
-                        orchestratorSystem: 'Test agent.',
-                        plugins: [
-                            contextCompactPlugin.configure({
-                                compaction: { model: ModelId('mock'), maxTokens: 10, keepRecentMessages: 2 },
-                            }),
-                        ],
-                        // Budget large enough to survive the cheap regular turns but small
-                        // enough that one expensive summarization call blows past it.
-                        orchestratorPlugins: [
-                            limitsGuardPlugin.configureAgent({ limits: { maxCost: 2.0, maxTurns: 100 } }),
-                        ],
-                    })],
-                mockHandler: (request) => {
-                    if (isSummarizationRequest(request)) {
-                        return {
-                            content: 'Summary of conversation so far.',
-                            toolCalls: [],
-                            finishReason: 'stop',
-                            metrics: MockLLMProvider.defaultMetricsWithCost(SUMMARY_COST),
-                        };
-                    }
-                    return {
-                        content: 'Agent response with some content to increase token count.',
-                        toolCalls: [],
-                        finishReason: 'stop',
-                        metrics: MockLLMProvider.defaultMetricsWithCost(REGULAR_COST),
-                    };
-                },
-            });
-            const session = await harness.createSession('test');
-            const entryAgentId = session.getEntryAgentId();
-            // Returns once the agent is either idle or paused — used because we don't
-            // know up front whether the compaction cost trips the budget on the same
-            // turn (depends on beforeInference hook ordering) or on the next one.
-            const waitForIdleOrPaused = async (timeoutMs = 10000) => {
-                const deadline = Date.now() + timeoutMs;
-                while (Date.now() < deadline) {
-                    const st = session.state.agents.get(entryAgentId);
-                    if (st?.status === 'paused')
-                        return 'paused';
-                    if (st?.status === 'pending' && st.pendingToolCalls.length === 0 && st.pendingToolResults.length === 0) {
-                        return 'idle';
-                    }
-                    await new Promise(r => setTimeout(r, 10));
-                }
-                throw new Error('waitForIdleOrPaused timed out');
-            };
-            await session.sendAndWaitForIdle('First message');
-            await session.sendAndWaitForIdle('Second message');
-            // Third message triggers compaction (the expensive summarization call).
-            // It may pause on this turn or settle idle and pause on the next one.
-            await session.sendMessage('Third message to trigger compaction');
-            if (await waitForIdleOrPaused() === 'idle') {
-                await session.sendMessage('Fourth message');
-            }
-            await waitForAgentPaused(session, entryAgentId);
-            // Compaction genuinely ran and was billed.
-            const auxEvents = await session.getEventsByType(llmEvents, 'auxiliary_inference_completed');
-            expect(auxEvents.some((e) => e.metrics.cost === SUMMARY_COST)).toBe(true);
-            // The summarization cost is reflected in the agent's tracked spend…
-            const counters = selectPluginState(session.state, 'agentLimits')?.get(entryAgentId);
-            expect(counters).toBeDefined();
-            expect(counters.costSpent).toBeGreaterThanOrEqual(SUMMARY_COST);
-            // …and it tripped the cost budget (the regular turns alone, at 0.1 each,
-            // could never reach the 2.0 cap on their own here).
-            const budgetEvents = await session.getEventsByType(limitsEvents, 'budget_exceeded');
-            const evt = budgetEvents.find((e) => e.agentId === entryAgentId);
-            expect(evt).toBeDefined();
-            expect(evt.scope).toBe('agent');
-            expect(evt.limitName).toBe('maxCost');
-            await harness.shutdown();
-        });
-    });
-});
-//# sourceMappingURL=limits-guard.integration.test.js.map