@namzu/sdk 14.0.7 → 15.0.0

package/src/compaction/__tests__/dangling.test.ts

@@ -1,457 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type {
-	AssistantMessage,
-	Message,
-	ToolMessage,
-	UserMessage,
-} from '../../types/message/index.js'
-import { findDanglingMessages, findSafeTrimIndex, removeDanglingMessages } from '../dangling.js'
-
-/**
- * Test helpers to create messages with proper typing.
- */
-function createUserMessage(content: string): UserMessage {
-	return { role: 'user', content, timestamp: Date.now() }
-}
-
-function createAssistantMessage(content: string | null, toolCallIds?: string[]): AssistantMessage {
-	const msg: AssistantMessage = {
-		role: 'assistant',
-		content,
-		timestamp: Date.now(),
-	}
-
-	if (toolCallIds && toolCallIds.length > 0) {
-		msg.toolCalls = toolCallIds.map((id) => ({
-			id,
-			type: 'function',
-			function: { name: 'test_tool', arguments: '{}' },
-		}))
-	}
-
-	return msg
-}
-
-function createToolMessage(content: string, toolCallId: string): ToolMessage {
-	return { role: 'tool', content, toolCallId, timestamp: Date.now() }
-}
-
-describe('findDanglingMessages', () => {
-	it('should find no dangling messages in a valid sequence', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createUserMessage('next'),
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(true)
-		expect(result.assistantsWithUnmatchedCalls).toHaveLength(0)
-		expect(result.orphanedToolMessages).toHaveLength(0)
-	})
-
-	it('should find assistant messages with unmatched tool calls', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			// Missing tool message for call-1
-			createUserMessage('next'),
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(false)
-		expect(result.assistantsWithUnmatchedCalls).toContain(1)
-		expect(result.orphanedToolMessages).toHaveLength(0)
-	})
-
-	it('should find orphaned tool messages with no matching assistant call', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createToolMessage('orphan', 'call-2'), // No assistant call for call-2
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(false)
-		expect(result.orphanedToolMessages).toContain(3)
-		expect(result.assistantsWithUnmatchedCalls).toHaveLength(0)
-	})
-
-	it('should handle multiple tool calls in a single assistant message', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1', 'call-2']),
-			createToolMessage('result-1', 'call-1'),
-			createToolMessage('result-2', 'call-2'),
-			createUserMessage('next'),
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(true)
-	})
-
-	it('should find partially satisfied multiple tool calls', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1', 'call-2']),
-			createToolMessage('result-1', 'call-1'),
-			// Missing result for call-2
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(false)
-		expect(result.assistantsWithUnmatchedCalls).toContain(1)
-	})
-
-	it('should find no dangling messages in an assistant-only sequence', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response without tools'),
-			createUserMessage('next'),
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(true)
-	})
-
-	it('should handle empty message array', () => {
-		const messages: Message[] = []
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(true)
-		expect(result.assistantsWithUnmatchedCalls).toHaveLength(0)
-		expect(result.orphanedToolMessages).toHaveLength(0)
-	})
-
-	it('should find multiple dangling issues in complex sequence', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']), // Unmatched
-			createToolMessage('orphan-1', 'call-999'), // Orphaned
-			createAssistantMessage('response2', ['call-2']),
-			createToolMessage('result-2', 'call-2'),
-			createToolMessage('orphan-2', 'call-888'), // Orphaned
-		]
-
-		const result = findDanglingMessages(messages)
-
-		expect(result.isValid).toBe(false)
-		expect(result.assistantsWithUnmatchedCalls).toContain(1)
-		expect(result.orphanedToolMessages).toContain(2)
-		expect(result.orphanedToolMessages).toContain(5)
-	})
-})
-
-describe('removeDanglingMessages', () => {
-	it('should return a copy when messages are already valid', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		expect(cleaned).toEqual(messages)
-		expect(cleaned).not.toBe(messages) // Different object
-	})
-
-	it('should remove assistant messages with unmatched tool calls', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']), // Will be removed
-			createUserMessage('next'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		expect(cleaned).toHaveLength(2)
-		expect(cleaned[0]?.role).toBe('user')
-		expect(cleaned[1]?.role).toBe('user')
-	})
-
-	it('should remove orphaned tool messages', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createToolMessage('orphan', 'call-999'), // Will be removed
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		expect(cleaned).toHaveLength(3)
-		expect(cleaned[3]).toBeUndefined()
-	})
-
-	it('should remove assistant and following orphaned tool messages together', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1', 'call-2']), // call-2 unmatched → assistant flagged
-			createToolMessage('attempt', 'call-1'), // Matches assistant's call list → removed with assistant
-			createUserMessage('next'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		expect(cleaned).toHaveLength(2)
-		expect(cleaned[0]?.role).toBe('user')
-		expect(cleaned[0]?.content).toBe('test')
-		expect(cleaned[1]?.role).toBe('user')
-		expect(cleaned[1]?.content).toBe('next')
-	})
-
-	it('should preserve message order while removing dangling messages', () => {
-		const messages: Message[] = [
-			createUserMessage('1'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createUserMessage('2'),
-			createAssistantMessage('response2', ['call-2']), // Unmatched
-			createUserMessage('3'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		// Only the unmatched assistant is removed; valid pair and users are kept in order
-		expect(cleaned).toHaveLength(5)
-		expect(cleaned[0]?.content).toBe('1')
-		expect(cleaned[1]?.content).toBe('response')
-		expect(cleaned[2]?.content).toBe('result')
-		expect(cleaned[3]?.content).toBe('2')
-		expect(cleaned[4]?.content).toBe('3')
-	})
-
-	it('should handle complex cleanup with multiple dangling issues', () => {
-		const messages: Message[] = [
-			createUserMessage('start'),
-			createAssistantMessage('response1', ['call-1']), // Unmatched
-			createToolMessage('orphan-1', 'call-999'), // Orphaned
-			createAssistantMessage('response2', ['call-2']),
-			createToolMessage('result-2', 'call-2'),
-			createToolMessage('orphan-2', 'call-888'), // Orphaned
-			createUserMessage('end'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		// Removed: assistant('response1') (unmatched), orphan-1, orphan-2
-		// Kept: start, response2, result-2 (valid pair), end
-		expect(cleaned).toHaveLength(4)
-		expect(cleaned[0]?.content).toBe('start')
-		expect(cleaned[1]?.content).toBe('response2')
-		expect(cleaned[2]?.content).toBe('result-2')
-		expect(cleaned[3]?.content).toBe('end')
-	})
-
-	it('should remove dangling assistant messages when they have follow-up tool attempts', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1', 'call-2']), // call-2 unmatched → assistant flagged
-			createToolMessage('wrong-result', 'call-1'), // Matches assistant's call list → removed with assistant
-			createUserMessage('next'),
-		]
-
-		const cleaned = removeDanglingMessages(messages)
-
-		expect(cleaned).toHaveLength(2)
-		expect(cleaned[0]?.content).toBe('test')
-		expect(cleaned[1]?.content).toBe('next')
-	})
-})
-
-describe('findSafeTrimIndex', () => {
-	it('should not trim when target is 0', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, 0)
-
-		expect(safeIdx).toBe(0)
-	})
-
-	it('should not trim when target is at end', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, messages.length)
-
-		expect(safeIdx).toBe(messages.length)
-	})
-
-	it('should clamp negative target index to 0', () => {
-		const messages: Message[] = [createUserMessage('test')]
-
-		const safeIdx = findSafeTrimIndex(messages, -5)
-
-		expect(safeIdx).toBeGreaterThanOrEqual(0)
-	})
-
-	it('should clamp target beyond array length', () => {
-		const messages: Message[] = [createUserMessage('test')]
-
-		const safeIdx = findSafeTrimIndex(messages, 1000)
-
-		expect(safeIdx).toBeLessThanOrEqual(messages.length)
-	})
-
-	it('should skip orphaned tool messages at trim point', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createToolMessage('orphan', 'call-999'), // Orphaned at trim point
-			createUserMessage('next'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, 3)
-
-		// Should skip the orphaned tool message at index 3
-		expect(safeIdx).toBeGreaterThan(3)
-	})
-
-	it('should preserve complete tool call/result pairs', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createUserMessage('next'),
-		]
-
-		// Try to trim in middle of pair
-		const safeIdx = findSafeTrimIndex(messages, 2)
-
-		// Algorithm advances forward past the pair — safeIdx=3 keeps the pair intact in slice(0, safeIdx)
-		expect(safeIdx).toBe(3)
-	})
-
-	it('should not start with a tool message after trim', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createToolMessage('orphan', 'call-999'),
-			createUserMessage('next'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, 3)
-
-		if (safeIdx < messages.length) {
-			const firstAfterTrim = messages[safeIdx]
-			if (firstAfterTrim) {
-				expect(firstAfterTrim.role).not.toBe('tool')
-			}
-		}
-	})
-
-	it('should handle complex scenario with multiple pairs', () => {
-		const messages: Message[] = [
-			createUserMessage('1'),
-			createAssistantMessage('response1', ['call-1']),
-			createToolMessage('result-1', 'call-1'),
-			createUserMessage('2'),
-			createAssistantMessage('response2', ['call-2']),
-			createToolMessage('result-2', 'call-2'),
-			createUserMessage('3'),
-		]
-
-		// Try to trim between the two pairs
-		const safeIdx = findSafeTrimIndex(messages, 4)
-
-		// Should either include or exclude the second pair completely
-		const kept = messages.slice(0, safeIdx)
-		const danglingResult = findDanglingMessages(kept)
-		expect(danglingResult.isValid).toBe(true)
-	})
-
-	it('should produce valid message sequence after trim', () => {
-		const messages: Message[] = [
-			createUserMessage('1'),
-			createAssistantMessage('response1', ['call-1']),
-			createToolMessage('result-1', 'call-1'),
-			createUserMessage('2'),
-			createAssistantMessage('response2', ['call-2']),
-			createToolMessage('result-2', 'call-2'),
-			createUserMessage('3'),
-			createAssistantMessage('unmatched', ['call-3']), // Unmatched
-		]
-
-		// Asserted on the KEPT side, which is the side that reaches a
-		// provider. This used to check that the DROPPED prefix was
-		// dangle-free — a proxy for "the kept tail has no leading orphan",
-		// and only ever a proxy: the prefix is summarised into prose, so an
-		// unanswered call inside it harms nothing. Checking the real
-		// property directly also covers the case the proxy missed, which is
-		// a tail that opens on an assistant turn.
-		for (let target = 0; target < messages.length; target++) {
-			const safeIdx = findSafeTrimIndex(messages, target)
-			const kept = messages.slice(safeIdx)
-			if (kept.length === 0) continue
-
-			// The tail becomes the whole conversation once the summary is
-			// hoisted out as a system message, so it has to open the way a
-			// conversation opens.
-			expect(kept[0]?.role).toBe('user')
-			// And it cannot open on a result whose call was summarised away.
-			expect(kept[0]?.role).not.toBe('tool')
-		}
-	})
-
-	it('should not trim unnecessarily if sequence is already valid', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']),
-			createToolMessage('result', 'call-1'),
-			createUserMessage('next'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, messages.length)
-
-		expect(safeIdx).toBe(messages.length)
-	})
-
-	it('should advance past unsatisfied assistant message and its following tool attempt', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createAssistantMessage('response', ['call-1']), // Unmatched at index 1
-			createToolMessage('attempt', 'call-1'), // Following attempt at index 2
-			createUserMessage('next'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, 2)
-
-		// Should skip past the unmatched call and its following tool message
-		expect(safeIdx).toBeGreaterThan(2)
-		const kept = messages.slice(0, safeIdx)
-		expect(findDanglingMessages(kept).isValid).toBe(true)
-	})
-
-	it('should handle all-tool-messages scenario', () => {
-		const messages: Message[] = [
-			createUserMessage('test'),
-			createToolMessage('orphan-1', 'call-999'),
-			createToolMessage('orphan-2', 'call-888'),
-		]
-
-		const safeIdx = findSafeTrimIndex(messages, 1)
-
-		// Algorithm advances past both orphan tools — kept portion (slice from safeIdx) is empty and valid
-		const kept = messages.slice(safeIdx)
-		expect(findDanglingMessages(kept).isValid).toBe(true)
-	})
-})

package/src/compaction/__tests__/factory.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { RUNTIME_DEFAULTS } from '../../config/runtime.js'
-import { createConversationManager } from '../factory.js'
-import {
-	NullManager,
-	SlidingWindowManager,
-	StructuredCompactionManager,
-} from '../managers/index.js'
-
-describe('createConversationManager', () => {
-	const config = RUNTIME_DEFAULTS.compaction
-
-	it('should create NullManager for disabled strategy', () => {
-		const manager = createConversationManager('disabled', config)
-		expect(manager).toBeInstanceOf(NullManager)
-		expect(manager.name).toBe('null')
-	})
-
-	it('should create SlidingWindowManager for sliding-window strategy', () => {
-		const manager = createConversationManager('sliding-window', config)
-		expect(manager).toBeInstanceOf(SlidingWindowManager)
-		expect(manager.name).toBe('sliding-window')
-	})
-
-	it('should create StructuredCompactionManager for structured strategy', () => {
-		const manager = createConversationManager('structured', config)
-		expect(manager).toBeInstanceOf(StructuredCompactionManager)
-		expect(manager.name).toBe('structured')
-	})
-
-	it('should throw on unknown strategy', () => {
-		// @ts-expect-error - Testing invalid input
-		expect(() => createConversationManager('unknown', config)).toThrow()
-	})
-
-	it('should pass keepRecentMessages to SlidingWindowManager', () => {
-		const customConfig = {
-			...config,
-			keepRecentMessages: 8,
-		}
-		const manager = createConversationManager('sliding-window', customConfig)
-		expect(manager).toBeInstanceOf(SlidingWindowManager)
-	})
-
-	it('should pass config to StructuredCompactionManager', () => {
-		const customConfig = {
-			...config,
-			convoTextBudget: 5000,
-		}
-		const manager = createConversationManager('structured', customConfig)
-		expect(manager).toBeInstanceOf(StructuredCompactionManager)
-	})
-})

package/src/compaction/__tests__/lossiness.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { CompactionConfigSchema } from '../../config/runtime.js'
-import { extractFromToolResult } from '../extractor.js'
-import { WorkingStateManager } from '../manager.js'
-import { serializeState } from '../serializer.js'
-
-/**
- * What survives compaction is the ONLY record of the history it replaced.
- * Two ways that record was quietly degrading:
- *
- * 1. Capped lists evicted with `shift()` — oldest-first — so on a long run
- *    the 26th assistant note silently deleted the 1st. The early entries
- *    are the load-bearing ones (the original requirement, the decision
- *    that set the approach); the recent ones are still in the un-compacted
- *    tail of the conversation.
- * 2. Every tool the builtin name-sets did not recognise — every MCP tool,
- *    every custom tool — collapsed into a flat 120-character head slice,
- *    which on JSON spends the whole budget on syntax.
- */
-
-function config(overrides: Record<string, unknown> = {}) {
-	return CompactionConfigSchema.parse({ maxListSize: 5, keepFirstEntries: 2, ...overrides })
-}
-
-describe('capped lists keep their head', () => {
-	it('evicts from the middle, not the front', () => {
-		const m = new WorkingStateManager(config())
-		for (let i = 1; i <= 8; i++) m.addDecision(`decision ${i}`)
-
-		const { decisions } = m.getState()
-		expect(decisions).toHaveLength(5)
-		// The first two survive…
-		expect(decisions.slice(0, 2)).toEqual(['decision 1', 'decision 2'])
-		// …and the newest do too. The middle is what went.
-		expect(decisions.slice(-2)).toEqual(['decision 7', 'decision 8'])
-	})
-
-	it('counts what it dropped', () => {
-		const m = new WorkingStateManager(config())
-		for (let i = 1; i <= 8; i++) m.addDecision(`d${i}`)
-		expect(m.getState().evicted.decisions).toBe(3)
-	})
-
-	it('counts each slot separately', () => {
-		const m = new WorkingStateManager(config())
-		for (let i = 1; i <= 7; i++) m.addFailure(`f${i}`)
-		for (let i = 1; i <= 6; i++) m.addDiscovery(`x${i}`)
-
-		expect(m.getState().evicted.failures).toBe(2)
-		expect(m.getState().evicted.discoveries).toBe(1)
-		expect(m.getState().evicted.decisions).toBeUndefined()
-	})
-
-	it('never evicts below the pinned head, even with a tiny cap', () => {
-		const m = new WorkingStateManager(config({ maxListSize: 2, keepFirstEntries: 5 }))
-		for (let i = 1; i <= 6; i++) m.addDecision(`d${i}`)
-
-		const { decisions } = m.getState()
-		expect(decisions).toHaveLength(2)
-		// keepFirst is clamped below the cap, so the list still admits new
-		// entries rather than freezing on its first two forever.
-		expect(decisions[0]).toBe('d1')
-		expect(decisions[1]).toBe('d6')
-	})
-
-	it('keeps tool results newest-first — recency genuinely wins there', () => {
-		// An old `read` of a file that has since been edited is worse than
-		// useless, so this slot is the one exception.
-		const m = new WorkingStateManager(config({ maxToolResults: 3 }))
-		for (let i = 1; i <= 5; i++) {
-			m.addToolResult({ tool: 't', summary: `s${i}`, timestamp: i })
-		}
-		expect(m.getState().toolResults.map((r) => r.summary)).toEqual(['s3', 's4', 's5'])
-		expect(m.getState().evicted.toolResults).toBe(2)
-	})
-})
-
-describe('the summary admits what it lost', () => {
-	it('names the dropped count in the rendered section', () => {
-		const m = new WorkingStateManager(config())
-		for (let i = 1; i <= 8; i++) m.addDecision(`d${i}`)
-
-		const rendered = serializeState(m.getState())
-		expect(rendered).toContain('3 entries dropped')
-	})
-
-	it('says nothing when nothing was dropped', () => {
-		const m = new WorkingStateManager(config())
-		m.addDecision('only one')
-		expect(serializeState(m.getState())).not.toContain('dropped')
-	})
-
-	it('uses the singular for one', () => {
-		const m = new WorkingStateManager(config())
-		for (let i = 1; i <= 6; i++) m.addDecision(`d${i}`)
-		expect(serializeState(m.getState())).toContain('1 entry dropped')
-	})
-})
-
-describe('unrecognised tools get a useful summary', () => {
-	const m = () => new WorkingStateManager(config({ maxToolResults: 30 }))
-
-	it('describes the shape of a JSON array instead of slicing its syntax', () => {
-		const mgr = m()
-		const payload = JSON.stringify(
-			Array.from({ length: 40 }, (_, i) => ({ id: `row-${i}`, name: 'x'.repeat(30) })),
-		)
-		extractFromToolResult(mgr, 'mcp_crm_list_deals', payload, false)
-
-		const summary = mgr.getState().toolResults[0]?.summary ?? ''
-		expect(summary).toContain('array of 40')
-		expect(summary).toContain('id')
-		expect(summary).toContain('name')
-	})
-
-	it('lists the keys of a JSON object', () => {
-		const mgr = m()
-		const payload = JSON.stringify({
-			status: 'ok',
-			total: 12,
-			items: Array.from({ length: 50 }, (_, i) => `item-${i}-${'x'.repeat(20)}`),
-		})
-		extractFromToolResult(mgr, 'mcp_docs_search', payload, false)
-
-		const summary = mgr.getState().toolResults[0]?.summary ?? ''
-		expect(summary).toContain('object{')
-		expect(summary).toContain('status')
-		expect(summary).toContain('items')
-	})
-
-	it('keeps head AND tail of long plain text', () => {
-		const mgr = m()
-		extractFromToolResult(mgr, 'custom_tool', `START${'.'.repeat(4000)}END`, false)
-
-		const summary = mgr.getState().toolResults[0]?.summary ?? ''
-		expect(summary).toContain('START')
-		expect(summary).toContain('END')
-		expect(summary).toContain('chars omitted')
-	})
-
-	it('leaves a short result completely alone', () => {
-		const mgr = m()
-		extractFromToolResult(mgr, 'custom_tool', 'all good', false)
-		expect(mgr.getState().toolResults[0]?.summary).toBe('all good')
-	})
-
-	it('gives an unknown tool more room than the old flat 120 chars', () => {
-		const mgr = m()
-		extractFromToolResult(mgr, 'custom_tool', 'z'.repeat(5000), false)
-		expect((mgr.getState().toolResults[0]?.summary ?? '').length).toBeGreaterThan(120)
-	})
-})
-
-describe('the tool-result section admits what it dropped', () => {
-	it('names the count once results have been evicted', () => {
-		const m = new WorkingStateManager(config({ maxToolResults: 2 }))
-		m.addToolResult({ tool: 'read', summary: 'first', timestamp: 0 })
-		m.addToolResult({ tool: 'read', summary: 'second', timestamp: 0 })
-		m.addToolResult({ tool: 'read', summary: 'third', timestamp: 0 })
-
-		const rendered = serializeState(m.getState())
-
-		// The section carrying the most volume was the only one rendering a
-		// fragment as if it were the whole record: the count was tracked and
-		// never printed.
-		expect(rendered).toContain('1 earlier tool result dropped')
-		expect(rendered).toContain('second')
-		expect(rendered).toContain('third')
-	})
-
-	it('pluralizes past one', () => {
-		const m = new WorkingStateManager(config({ maxToolResults: 1 }))
-		for (const summary of ['a', 'b', 'c']) m.addToolResult({ tool: 'read', summary, timestamp: 0 })
-
-		expect(serializeState(m.getState())).toContain('2 earlier tool results dropped')
-	})
-
-	it('says nothing when nothing was dropped', () => {
-		const m = new WorkingStateManager(config({ maxToolResults: 8 }))
-		m.addToolResult({ tool: 'read', summary: 'only', timestamp: 0 })
-
-		const rendered = serializeState(m.getState())
-		expect(rendered).toContain('only')
-		expect(rendered).not.toContain('dropped to stay within')
-	})
-})