@roj-ai/sdk 0.1.36 → 0.2.2

package/src/plugins/context-compact/context-compactor.test.ts

@@ -1,1036 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { agentEvents } from '~/core/agents/state.js'
-import type { AgentId } from '~/core/agents/schema.js'
-import { generateTestAgentId } from '~/core/agents/schema.js'
-import { contextCompactedEventSchema, contextEvents } from '~/core/context/state.js'
-import { withSessionId } from '~/core/events/test-helpers.js'
-import type { InferenceResponse, LLMMessage } from '~/core/llm/provider.js'
-import { ModelId } from '~/core/llm/schema.js'
-import { estimateMessagesTokens } from '~/core/llm/tokens.js'
-import type { SessionId } from '~/core/sessions/schema.js'
-import { generateSessionId } from '~/core/sessions/schema.js'
-import { coreReducer, createSessionState } from '~/core/sessions/state.js'
-import { generateToolCallId } from '~/core/tools/schema.js'
-import { Err, Ok } from '~/lib/utils/result.js'
-import { silentLogger } from '../../lib/logger/logger.js'
-import { ContextCompactor, createContextCompactedEvent, formatMessageForSummary } from './context-compactor.js'
-import type { CompactionConfig, CompactionResult, RunInferenceFn } from './context-compactor.js'
-
-// ============================================================================
-// Test Constants
-// ============================================================================
-
-const TEST_MODEL_ID: ModelId = ModelId('test/model')
-
-// ============================================================================
-// Mock runInference callback
-// ============================================================================
-
-interface InferenceMockCall {
-	extraMessages: LLMMessage[]
-}
-
-class InferenceMock {
-	private responses: InferenceResponse[] = []
-	private responseIndex = 0
-	calls: InferenceMockCall[] = []
-
-	setResponses(responses: InferenceResponse[]): void {
-		this.responses = responses
-		this.responseIndex = 0
-	}
-
-	readonly run: RunInferenceFn = async (extraMessages) => {
-		this.calls.push({ extraMessages })
-		if (this.responseIndex >= this.responses.length) {
-			return Err({ type: 'server_error', message: 'No more mock responses' })
-		}
-		return Ok(this.responses[this.responseIndex++])
-	}
-}
-
-// ============================================================================
-// Tests: ContextCompactor.needsCompaction
-// ============================================================================
-
-describe('ContextCompactor.needsCompaction', () => {
-	let inference: InferenceMock
-	let compactor: ContextCompactor
-
-	beforeEach(() => {
-		inference = new InferenceMock()
-		compactor = new ContextCompactor(silentLogger, {
-			model: TEST_MODEL_ID,
-			maxTokens: 100,
-			keepRecentMessages: 2,
-		})
-	})
-
-	it('returns false when below threshold', () => {
-		const messages: LLMMessage[] = [{ role: 'user', content: 'short' }]
-		expect(compactor.needsCompaction(messages)).toBe(false)
-	})
-
-	it('returns true when above threshold', () => {
-		// Create messages with > 100 tokens
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'a'.repeat(200) }, // ~50 tokens + overhead
-			{ role: 'assistant', content: 'b'.repeat(200) }, // ~50 tokens + overhead
-			{ role: 'user', content: 'c'.repeat(200) }, // ~50 tokens + overhead
-		]
-		expect(compactor.needsCompaction(messages)).toBe(true)
-	})
-})
-
-// ============================================================================
-// Tests: ContextCompactor.compact
-// ============================================================================
-
-describe('ContextCompactor.compact', () => {
-	let inference: InferenceMock
-	let compactor: ContextCompactor
-	let sessionId: SessionId
-	let agentId: AgentId
-
-	beforeEach(() => {
-		inference = new InferenceMock()
-		compactor = new ContextCompactor(silentLogger, {
-			model: TEST_MODEL_ID,
-			maxTokens: 100,
-			keepRecentMessages: 2,
-		})
-		sessionId = generateSessionId()
-		agentId = generateTestAgentId()
-	})
-
-	it('returns empty summary when no messages to compact', async () => {
-		// Only 2 messages, keepRecentMessages = 2
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'message 1' },
-			{ role: 'assistant', content: 'message 2' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.summary).toBe('')
-		expect(result.value.messagesRemoved).toBe(0)
-		expect(result.value.compactedMessages).toEqual(messages)
-	})
-
-	it('compacts old messages and keeps recent ones', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary of the conversation',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: {
-					promptTokens: 50,
-					completionTokens: 20,
-					totalTokens: 70,
-					latencyMs: 100,
-					model: 'mock',
-				},
-			},
-		])
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old message 1' },
-			{ role: 'assistant', content: 'old message 2' },
-			{ role: 'user', content: 'old message 3' },
-			{ role: 'user', content: 'recent message 1' },
-			{ role: 'assistant', content: 'recent message 2' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.summary).toBe('Summary of the conversation')
-		expect(result.value.messagesRemoved).toBe(3)
-		expect(result.value.compactedMessages.length).toBe(3) // summary + 2 recent
-
-		// First message is the summary (user-role so it cleanly fits into chat history)
-		expect(result.value.compactedMessages[0].role).toBe('user')
-		expect(result.value.compactedMessages[0].content).toContain(
-			'[CONVERSATION SUMMARY]',
-		)
-		expect(result.value.compactedMessages[0].content).toContain(
-			'Summary of the conversation',
-		)
-
-		// Recent messages preserved
-		expect(result.value.compactedMessages[1].content).toBe('recent message 1')
-		expect(result.value.compactedMessages[2].content).toBe('recent message 2')
-	})
-
-	it('calls runInference with a single trailing summarize-instruction message', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: {
-					promptTokens: 50,
-					completionTokens: 20,
-					totalTokens: 70,
-					latencyMs: 100,
-					model: 'mock',
-				},
-			},
-		])
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'user message' },
-			{ role: 'assistant', content: 'assistant message' },
-			{ role: 'user', content: 'recent' },
-			{ role: 'assistant', content: 'recent too' },
-		]
-
-		await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		expect(inference.calls.length).toBe(1)
-		const call = inference.calls[0]
-		// Inline summarization sends ONE trailing user message — the host (agent)
-		// is responsible for the full prefix (preamble + history); the compactor
-		// only contributes the instruction.
-		expect(call.extraMessages.length).toBe(1)
-		expect(call.extraMessages[0].role).toBe('user')
-		expect(typeof call.extraMessages[0].content).toBe('string')
-	})
-
-	it('returns error when LLM fails', async () => {
-		// No responses set, so LLM will fail
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old 1' },
-			{ role: 'assistant', content: 'old 2' },
-			{ role: 'user', content: 'old 3' },
-			{ role: 'user', content: 'recent 1' },
-			{ role: 'assistant', content: 'recent 2' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(false)
-		if (result.ok) return
-
-		expect(result.error.message).toContain('Compaction failed')
-	})
-})
-
-// ============================================================================
-// Tests: ContextCompactor.compactIfNeeded
-// ============================================================================
-
-describe('ContextCompactor.compactIfNeeded', () => {
-	let inference: InferenceMock
-	let compactor: ContextCompactor
-	let sessionId: SessionId
-	let agentId: AgentId
-
-	beforeEach(() => {
-		inference = new InferenceMock()
-		compactor = new ContextCompactor(silentLogger, {
-			model: TEST_MODEL_ID,
-			maxTokens: 50,
-			keepRecentMessages: 1,
-		})
-		sessionId = generateSessionId()
-		agentId = generateTestAgentId()
-	})
-
-	it('returns null when compaction not needed', async () => {
-		const messages: LLMMessage[] = [{ role: 'user', content: 'short' }]
-
-		const result = await compactor.compactIfNeeded(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value).toBeNull()
-		expect(inference.calls.length).toBe(0)
-	})
-
-	it('compacts when needed', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: {
-					promptTokens: 50,
-					completionTokens: 20,
-					totalTokens: 70,
-					latencyMs: 100,
-					model: 'mock',
-				},
-			},
-		])
-
-		// Create messages exceeding threshold
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'a'.repeat(100) },
-			{ role: 'assistant', content: 'b'.repeat(100) },
-			{ role: 'user', content: 'c'.repeat(100) },
-		]
-
-		const result = await compactor.compactIfNeeded(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value).not.toBeNull()
-		expect(result.value!.summary).toBe('Summary')
-	})
-})
-
-// ============================================================================
-// Tests: createContextCompactedEvent
-// ============================================================================
-
-describe('createContextCompactedEvent', () => {
-	it('creates event with correct fields', () => {
-		const sessionId = generateSessionId()
-		const agentId = generateTestAgentId()
-		const result: CompactionResult = {
-			compactedMessages: [
-				{ role: 'system', content: 'summary' },
-				{ role: 'user', content: 'recent' },
-			],
-			originalMessages: [{ role: 'user', content: 'old message' }],
-			summary: 'The summary',
-			originalTokens: 1000,
-			compactedTokens: 200,
-			messagesRemoved: 5,
-		}
-
-		const event = createContextCompactedEvent(sessionId, agentId, result)
-
-		expect(event.type).toBe('context_compacted')
-		expect(event.sessionId).toBe(sessionId)
-		expect(event.agentId).toBe(agentId)
-		expect(event.compactedContent).toBe('The summary')
-		expect(event.originalTokens).toBe(1000)
-		expect(event.compactedTokens).toBe(200)
-		expect(event.messagesRemoved).toBe(5)
-		expect(event.newConversationHistory.length).toBe(2)
-		expect(event.newConversationHistory[0].role).toBe('system')
-		expect(event.newConversationHistory[0].content).toBe('summary')
-		expect(event.originalMessages?.length).toBe(1)
-		expect(event.originalMessages?.[0].content).toBe('old message')
-		expect(event.timestamp).toBeDefined()
-	})
-
-	it('preserves assistant tool calls and tool results in history', () => {
-		const sessionId = generateSessionId()
-		const agentId = generateTestAgentId()
-		const toolCallId = generateToolCallId()
-		const result: CompactionResult = {
-			compactedMessages: [
-				{
-					role: 'assistant',
-					content: 'Checking.',
-					toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-				},
-				{
-					role: 'tool',
-					content: 'tool result',
-					toolCallId,
-					toolName: 'read',
-					isError: false,
-					timestamp: 123,
-				},
-			],
-			originalMessages: [],
-			summary: '',
-			originalTokens: 100,
-			compactedTokens: 50,
-			messagesRemoved: 0,
-		}
-
-		const event = createContextCompactedEvent(sessionId, agentId, result)
-
-		expect(event.newConversationHistory).toEqual(result.compactedMessages)
-	})
-
-	it('parses and reduces old-shape events exactly as before', () => {
-		const sessionId = generateSessionId()
-		const agentId = generateTestAgentId()
-		const oldPayload = contextCompactedEventSchema.parse({
-			agentId,
-			compactedContent: 'Old summary',
-			newConversationHistory: [
-				{ role: 'user', content: 'summary' },
-				{ role: 'assistant', content: 'recent response' },
-				{ role: 'system', content: 'legacy context' },
-			],
-			originalTokens: 1000,
-			compactedTokens: 100,
-			messagesRemoved: 12,
-		})
-
-		let state = createSessionState(sessionId, 'test', 0)
-		state = coreReducer(state, withSessionId(
-			sessionId,
-			agentEvents.create('agent_spawned', {
-				agentId,
-				definitionName: 'test-agent',
-				parentId: null,
-			}),
-		))
-		state = coreReducer(state, withSessionId(
-			sessionId,
-			contextEvents.create('context_compacted', oldPayload),
-		))
-
-		expect(state.agents.get(agentId)?.conversationHistory).toEqual([
-			{ role: 'user', content: 'summary', sourceMessageIds: [], cacheControl: undefined },
-			{ role: 'assistant', content: 'recent response', toolCalls: undefined, cacheControl: undefined },
-			{ role: 'system', content: 'legacy context', cacheControl: undefined },
-		])
-	})
-})
-
-// ============================================================================
-// Tests: Default config
-// ============================================================================
-
-describe('ContextCompactor with custom config', () => {
-	it('respects custom maxTokens', () => {
-		const inference = new InferenceMock()
-		const config: CompactionConfig = {
-			model: TEST_MODEL_ID,
-			maxTokens: 20,
-			keepRecentMessages: 1,
-		}
-		const compactor = new ContextCompactor(silentLogger, config)
-
-		const smallMessages: LLMMessage[] = [{ role: 'user', content: 'hi' }]
-		expect(compactor.needsCompaction(smallMessages)).toBe(false)
-
-		const largeMessages: LLMMessage[] = [
-			{ role: 'user', content: 'a'.repeat(100) },
-		]
-		expect(compactor.needsCompaction(largeMessages)).toBe(true)
-	})
-
-	it('respects custom keepRecentMessages', async () => {
-		const inference = new InferenceMock()
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: {
-					promptTokens: 50,
-					completionTokens: 20,
-					totalTokens: 70,
-					latencyMs: 100,
-					model: 'mock',
-				},
-			},
-		])
-
-		const config: CompactionConfig = {
-			model: TEST_MODEL_ID,
-			maxTokens: 10,
-			keepRecentMessages: 3,
-		}
-		const compactor = new ContextCompactor(silentLogger, config)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old 1' },
-			{ role: 'assistant', content: 'old 2' },
-			{ role: 'user', content: 'recent 1' },
-			{ role: 'assistant', content: 'recent 2' },
-			{ role: 'user', content: 'recent 3' },
-		]
-
-		const result = await compactor.compact(
-			generateSessionId(),
-			generateTestAgentId(),
-			messages,
-			inference.run,
-		)
-
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		// 2 old messages removed, 3 kept + 1 summary = 4 total
-		expect(result.value.messagesRemoved).toBe(2)
-		expect(result.value.compactedMessages.length).toBe(4)
-	})
-
-	it('uses custom summaryPrompt', async () => {
-		const inference = new InferenceMock()
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: {
-					promptTokens: 50,
-					completionTokens: 20,
-					totalTokens: 70,
-					latencyMs: 100,
-					model: 'mock',
-				},
-			},
-		])
-
-		const customPrompt = 'Custom summary instructions'
-		const config: CompactionConfig = {
-			model: TEST_MODEL_ID,
-			maxTokens: 10,
-			keepRecentMessages: 1,
-			summaryPrompt: customPrompt,
-		}
-		const compactor = new ContextCompactor(silentLogger, config)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old' },
-			{ role: 'user', content: 'recent' },
-		]
-
-		await compactor.compact(generateSessionId(), generateTestAgentId(), messages, inference.run)
-
-		expect(inference.calls.length).toBe(1)
-		// Custom prompt is sent as the content of the trailing user-role instruction.
-		expect(inference.calls[0].extraMessages[0].content).toBe(customPrompt)
-	})
-})
-
-// ============================================================================
-// Tests: formatMessageForSummary
-// ============================================================================
-
-describe('formatMessageForSummary', () => {
-	it('formats user message', () => {
-		const msg: LLMMessage = { role: 'user', content: 'Hello world' }
-		expect(formatMessageForSummary(msg)).toBe('User: Hello world')
-	})
-
-	it('formats user message with multimodal content', () => {
-		const msg: LLMMessage = {
-			role: 'user',
-			content: [{ type: 'text', text: 'Check this image' }],
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toContain('User:')
-		expect(result).toContain('Check this image')
-	})
-
-	it('formats assistant message with text only', () => {
-		const msg: LLMMessage = { role: 'assistant', content: 'Sure, I can help' }
-		expect(formatMessageForSummary(msg)).toBe('Agent: Sure, I can help')
-	})
-
-	it('formats assistant message with tool calls', () => {
-		const msg: LLMMessage = {
-			role: 'assistant',
-			content: '',
-			toolCalls: [{ id: generateToolCallId(), name: 'read', input: { path: '/src/index.ts' } }],
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toBe('Agent: [Called tools: read(path)]')
-	})
-
-	it('formats assistant message with text and tool calls', () => {
-		const msg: LLMMessage = {
-			role: 'assistant',
-			content: 'Let me read that file.',
-			toolCalls: [{ id: generateToolCallId(), name: 'read', input: { path: '/src/index.ts' } }],
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toContain('Agent: Let me read that file.')
-		expect(result).toContain('[Called tools: read(path)]')
-	})
-
-	it('formats assistant message with multiple tool calls', () => {
-		const msg: LLMMessage = {
-			role: 'assistant',
-			content: '',
-			toolCalls: [
-				{ id: generateToolCallId(), name: 'read', input: { path: '/a.ts' } },
-				{ id: generateToolCallId(), name: 'edit', input: { path: '/b.ts', old_string: 'x', new_string: 'y' } },
-			],
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toBe('Agent: [Called tools: read(path), edit(path, old_string, new_string)]')
-	})
-
-	it('formats tool result with tool name', () => {
-		const msg: LLMMessage = {
-			role: 'tool',
-			content: 'export function main() {}',
-			toolCallId: generateToolCallId(),
-			toolName: 'read',
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toBe('Tool(read): export function main() {}')
-	})
-
-	it('formats tool result without tool name as unknown', () => {
-		const msg: LLMMessage = {
-			role: 'tool',
-			content: 'some result',
-			toolCallId: generateToolCallId(),
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toBe('Tool(unknown): some result')
-	})
-
-	it('truncates large tool results', () => {
-		const largeContent = 'x'.repeat(1000)
-		const msg: LLMMessage = {
-			role: 'tool',
-			content: largeContent,
-			toolCallId: generateToolCallId(),
-			toolName: 'read',
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toContain('Tool(read):')
-		expect(result).toContain('...(truncated)...')
-		expect(result.length).toBeLessThan(largeContent.length)
-	})
-
-	it('does not truncate small tool results', () => {
-		const smallContent = 'small result'
-		const msg: LLMMessage = {
-			role: 'tool',
-			content: smallContent,
-			toolCallId: generateToolCallId(),
-			toolName: 'read',
-		}
-		const result = formatMessageForSummary(msg)
-		expect(result).toBe('Tool(read): small result')
-		expect(result).not.toContain('truncated')
-	})
-
-	it('formats system message', () => {
-		const msg: LLMMessage = { role: 'system', content: 'You are an assistant.' }
-		expect(formatMessageForSummary(msg)).toBe('System: You are an assistant.')
-	})
-})
-
-// ============================================================================
-// Tests: Tool calls in compaction
-// ============================================================================
-
-describe('ContextCompactor with tool calls', () => {
-	let inference: InferenceMock
-	let compactor: ContextCompactor
-	let sessionId: SessionId
-	let agentId: AgentId
-
-	beforeEach(() => {
-		inference = new InferenceMock()
-		compactor = new ContextCompactor(silentLogger, {
-			model: TEST_MODEL_ID,
-			maxTokens: 100,
-			keepRecentMessages: 1,
-		})
-		sessionId = generateSessionId()
-		agentId = generateTestAgentId()
-	})
-
-	it('does not leave orphaned tool results at the start of kept messages', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const toolCallId = generateToolCallId()
-		// keepRecentMessages=1 would split between the assistant (tool call) and tool result
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old message' },
-			{ role: 'assistant', content: 'old response' },
-			{ role: 'user', content: 'Read the file' },
-			{
-				role: 'assistant',
-				content: '',
-				toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-			},
-			{ role: 'tool', content: 'export const foo = 1', toolCallId, toolName: 'read' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		// The tool result must NOT be the first kept message — it should be compacted along with its tool call
-		const keptMessages = result.value.compactedMessages.filter(m => m.role !== 'system')
-		for (const msg of keptMessages) {
-			expect(msg.role).not.toBe('tool')
-		}
-		// All 5 original messages should be compacted (none kept except summary)
-		expect(result.value.messagesRemoved).toBe(5)
-	})
-
-	it('round-trips a kept tool turn and accounts for its token structure', async () => {
-		inference.setResponses([
-			{
-				content: 'Short summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const toolCallId = generateToolCallId()
-		const toolTurn: LLMMessage[] = [
-			{
-				role: 'assistant',
-				content: 'I will inspect the file.',
-				toolCalls: [{
-					id: toolCallId,
-					name: 'read',
-					input: { path: '/src/index.ts', reason: 'x'.repeat(400) },
-				}],
-			},
-			{
-				role: 'tool',
-				content: 'export const value = 1',
-				toolCallId,
-				toolName: 'read',
-				isError: false,
-				timestamp: 123,
-			},
-		]
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old context '.repeat(1000) },
-			{ role: 'assistant', content: 'old response '.repeat(1000) },
-			...toolTurn,
-		]
-		const preservingCompactor = new ContextCompactor(silentLogger, {
-			maxTokens: 100,
-			keepRecentMessages: 2,
-		})
-
-		const result = await preservingCompactor.compact(sessionId, agentId, messages, inference.run)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.compactedMessages.slice(1)).toEqual(toolTurn)
-		expect(result.value.compactedTokens).toBeLessThan(result.value.originalTokens)
-		expect(result.value.compactedTokens).toBeGreaterThan(
-			estimateMessagesTokens(result.value.compactedMessages),
-		)
-
-		const event = createContextCompactedEvent(sessionId, agentId, result.value)
-		expect(event.newConversationHistory.slice(1)).toEqual(toolTurn)
-	})
-
-	it('keeps an open tool declaration even when keep limits are zero', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const toolCallId = generateToolCallId()
-		const openToolCall: LLMMessage = {
-			role: 'assistant',
-			content: '',
-			toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-		}
-		const zeroKeepCompactor = new ContextCompactor(silentLogger, {
-			maxTokens: 100,
-			keepRecentMessages: 0,
-			keepRecentTokens: 0,
-		})
-
-		const result = await zeroKeepCompactor.compact(
-			sessionId,
-			agentId,
-			[
-				{ role: 'user', content: 'old context' },
-				openToolCall,
-			],
-			inference.run,
-		)
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.compactedMessages.at(-1)).toEqual(openToolCall)
-	})
-})
-
-// ============================================================================
-// Tests: History offloading
-// ============================================================================
-
-describe('ContextCompactor with history offloading', () => {
-	let inference: InferenceMock
-	let sessionId: SessionId
-	let agentId: AgentId
-
-	beforeEach(() => {
-		inference = new InferenceMock()
-		sessionId = generateSessionId()
-		agentId = generateTestAgentId()
-	})
-
-	it('offloads history when enabled and offloader is provided', async () => {
-		const offloadedPaths: { agentId: AgentId; content: string; pathPrefix: string }[] = []
-		const mockOffloader = {
-			async offload(agentId: AgentId, content: string, pathPrefix: string): Promise<string> {
-				offloadedPaths.push({ agentId, content, pathPrefix })
-				return `${pathPrefix}${agentId}/history.md`
-			},
-		}
-
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const compactor = new ContextCompactor(
-			silentLogger,
-			{
-				model: TEST_MODEL_ID,
-				maxTokens: 100,
-				keepRecentMessages: 1,
-				offloadHistory: true,
-			},
-			mockOffloader,
-		)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old message 1' },
-			{ role: 'assistant', content: 'old message 2' },
-			{ role: 'user', content: 'recent message' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		// Verify offloader was called
-		expect(offloadedPaths.length).toBe(1)
-		expect(offloadedPaths[0].agentId).toBe(agentId)
-		expect(offloadedPaths[0].content).toContain('User: old message 1')
-		expect(offloadedPaths[0].pathPrefix).toBe('/session/.history/')
-
-		// Verify result contains historyPath
-		expect(result.value.historyPath).toBe(`/session/.history/${agentId}/history.md`)
-
-		// Verify summary message contains history reference
-		expect(result.value.compactedMessages[0].content).toContain('has been saved to')
-		expect(result.value.compactedMessages[0].content).toContain(`/session/.history/${agentId}/history.md`)
-	})
-
-	it('does not offload history when disabled', async () => {
-		const mockOffloader = {
-			async offload(): Promise<string> {
-				throw new Error('Should not be called')
-			},
-		}
-
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const compactor = new ContextCompactor(
-			silentLogger,
-			{
-				model: TEST_MODEL_ID,
-				maxTokens: 100,
-				keepRecentMessages: 1,
-				offloadHistory: false, // explicitly disabled
-			},
-			mockOffloader,
-		)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old' },
-			{ role: 'user', content: 'recent' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.historyPath).toBeUndefined()
-		expect(result.value.compactedMessages[0].content).not.toContain('has been saved to')
-	})
-
-	it('does not offload history when offloader is not provided', async () => {
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const compactor = new ContextCompactor(
-			silentLogger,
-			{
-				model: TEST_MODEL_ID,
-				maxTokens: 100,
-				keepRecentMessages: 1,
-				offloadHistory: true, // enabled but no offloader
-			},
-			// no offloader provided
-		)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old' },
-			{ role: 'user', content: 'recent' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.historyPath).toBeUndefined()
-	})
-
-	it('uses custom historyPathPrefix', async () => {
-		const offloadedPaths: { pathPrefix: string }[] = []
-		const mockOffloader = {
-			async offload(_agentId: AgentId, _content: string, pathPrefix: string): Promise<string> {
-				offloadedPaths.push({ pathPrefix })
-				return `/custom/path/history.md`
-			},
-		}
-
-		inference.setResponses([
-			{
-				content: 'Summary',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const compactor = new ContextCompactor(
-			silentLogger,
-			{
-				model: TEST_MODEL_ID,
-				maxTokens: 100,
-				keepRecentMessages: 1,
-				offloadHistory: true,
-				historyPathPrefix: '/session/.custom-history/',
-			},
-			mockOffloader,
-		)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old' },
-			{ role: 'user', content: 'recent' },
-		]
-
-		await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		expect(offloadedPaths.length).toBe(1)
-		expect(offloadedPaths[0].pathPrefix).toBe('/session/.custom-history/')
-	})
-
-	it('continues compaction even if offloading fails', async () => {
-		const mockOffloader = {
-			async offload(): Promise<string> {
-				throw new Error('Disk full')
-			},
-		}
-
-		inference.setResponses([
-			{
-				content: 'Summary despite offload failure',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-			},
-		])
-
-		const compactor = new ContextCompactor(
-			silentLogger,
-			{
-				model: TEST_MODEL_ID,
-				maxTokens: 100,
-				keepRecentMessages: 1,
-				offloadHistory: true,
-			},
-			mockOffloader,
-		)
-
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'old' },
-			{ role: 'user', content: 'recent' },
-		]
-
-		const result = await compactor.compact(sessionId, agentId, messages, inference.run)
-
-		// Compaction should succeed despite offload failure
-		expect(result.ok).toBe(true)
-		if (!result.ok) return
-
-		expect(result.value.summary).toBe('Summary despite offload failure')
-		expect(result.value.historyPath).toBeUndefined()
-	})
-})
-
-// ============================================================================
-// Tests: createContextCompactedEvent with historyPath
-// ============================================================================
-
-describe('createContextCompactedEvent with historyPath', () => {
-	it('includes historyPath in event when provided', () => {
-		const sessionId = generateSessionId()
-		const agentId = generateTestAgentId()
-		const result: CompactionResult = {
-			compactedMessages: [
-				{ role: 'system', content: 'summary' },
-			],
-			originalMessages: [],
-			summary: 'The summary',
-			originalTokens: 1000,
-			compactedTokens: 200,
-			messagesRemoved: 5,
-			historyPath: '/session/.history/agent-1/history.md',
-		}
-
-		const event = createContextCompactedEvent(sessionId, agentId, result)
-
-		expect(event.historyPath).toBe('/session/.history/agent-1/history.md')
-	})
-
-	it('does not include historyPath when not provided', () => {
-		const sessionId = generateSessionId()
-		const agentId = generateTestAgentId()
-		const result: CompactionResult = {
-			compactedMessages: [
-				{ role: 'system', content: 'summary' },
-			],
-			originalMessages: [],
-			summary: 'The summary',
-			originalTokens: 1000,
-			compactedTokens: 200,
-			messagesRemoved: 5,
-		}
-
-		const event = createContextCompactedEvent(sessionId, agentId, result)
-
-		expect(event.historyPath).toBeUndefined()
-	})
-})