@roj-ai/sdk 0.1.13 → 0.1.15

package/src/lib/utils/concurrency.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it } from 'bun:test'
+import { mapWithConcurrency, Semaphore } from './concurrency.js'
+
+function defer<T = void>(): { promise: Promise<T>; resolve: (v: T) => void; reject: (e: unknown) => void } {
+	let resolve!: (v: T) => void
+	let reject!: (e: unknown) => void
+	const promise = new Promise<T>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+	return { promise, resolve, reject }
+}
+
+describe('mapWithConcurrency', () => {
+	it('preserves input order regardless of completion order', async () => {
+		const delays = [50, 10, 30, 5, 20]
+		const results = await mapWithConcurrency(delays, 3, async (ms, i) => {
+			await new Promise(r => setTimeout(r, ms))
+			return `${i}:${ms}`
+		})
+		expect(results).toEqual(['0:50', '1:10', '2:30', '3:5', '4:20'])
+	})
+
+	it('does not exceed the concurrency limit', async () => {
+		let active = 0
+		let peak = 0
+		const items = Array.from({ length: 20 }, (_, i) => i)
+
+		await mapWithConcurrency(items, 4, async () => {
+			active++
+			peak = Math.max(peak, active)
+			await new Promise(r => setTimeout(r, 5))
+			active--
+		})
+
+		expect(peak).toBeLessThanOrEqual(4)
+		expect(peak).toBe(4)
+	})
+
+	it('handles empty input without spawning workers', async () => {
+		let calls = 0
+		const results = await mapWithConcurrency([], 5, async () => {
+			calls++
+			return 1
+		})
+		expect(results).toEqual([])
+		expect(calls).toBe(0)
+	})
+
+	it('caps worker count at item count when concurrency > items', async () => {
+		let active = 0
+		let peak = 0
+		const items = [1, 2]
+
+		await mapWithConcurrency(items, 10, async () => {
+			active++
+			peak = Math.max(peak, active)
+			await new Promise(r => setTimeout(r, 5))
+			active--
+		})
+
+		expect(peak).toBe(2)
+	})
+
+	it('propagates errors thrown by the worker fn', async () => {
+		await expect(
+			mapWithConcurrency([1, 2, 3], 2, async (n) => {
+				if (n === 2) throw new Error('boom')
+				return n
+			}),
+		).rejects.toThrow('boom')
+	})
+})
+
+describe('Semaphore', () => {
+	it('rejects invalid limits', () => {
+		expect(() => new Semaphore(0)).toThrow()
+		expect(() => new Semaphore(-1)).toThrow()
+		expect(() => new Semaphore(1.5)).toThrow()
+	})
+
+	it('caps concurrent executions at limit', async () => {
+		const gate = new Semaphore(3)
+		let active = 0
+		let peak = 0
+
+		const tasks = Array.from({ length: 12 }, () =>
+			gate.run(async () => {
+				active++
+				peak = Math.max(peak, active)
+				await new Promise(r => setTimeout(r, 10))
+				active--
+			}),
+		)
+
+		await Promise.all(tasks)
+		expect(peak).toBe(3)
+		expect(active).toBe(0)
+	})
+
+	it('admits waiters in FIFO order', async () => {
+		const gate = new Semaphore(1)
+		const order: number[] = []
+		const blocker = defer()
+
+		// Hold the only slot
+		const held = gate.run(async () => {
+			await blocker.promise
+		})
+
+		// Queue three waiters in known order, with their own blockers so the test
+		// can observe entry order without relying on real timers.
+		const gates = [defer(), defer(), defer()]
+		const queued = gates.map((g, i) =>
+			gate.run(async () => {
+				order.push(i)
+				await g.promise
+			}),
+		)
+
+		// Yield so all three are queued.
+		await new Promise(r => setTimeout(r, 0))
+		expect(order).toEqual([])
+
+		// Release the holder; waiter 0 should run first.
+		blocker.resolve()
+		await new Promise(r => setTimeout(r, 0))
+		expect(order).toEqual([0])
+
+		gates[0]!.resolve()
+		await new Promise(r => setTimeout(r, 0))
+		expect(order).toEqual([0, 1])
+
+		gates[1]!.resolve()
+		await new Promise(r => setTimeout(r, 0))
+		expect(order).toEqual([0, 1, 2])
+
+		gates[2]!.resolve()
+		await Promise.all([held, ...queued])
+	})
+
+	it('releases the slot when the body throws', async () => {
+		const gate = new Semaphore(1)
+
+		await expect(gate.run(async () => {
+			throw new Error('boom')
+		})).rejects.toThrow('boom')
+
+		// Slot must be free again — this would deadlock otherwise.
+		const result = await gate.run(async () => 42)
+		expect(result).toBe(42)
+	})
+
+	it('serializes work under limit=1', async () => {
+		const gate = new Semaphore(1)
+		const events: string[] = []
+
+		const tasks = [0, 1, 2].map(i =>
+			gate.run(async () => {
+				events.push(`start:${i}`)
+				await new Promise(r => setTimeout(r, 5))
+				events.push(`end:${i}`)
+			}),
+		)
+
+		await Promise.all(tasks)
+		expect(events).toEqual(['start:0', 'end:0', 'start:1', 'end:1', 'start:2', 'end:2'])
+	})
+})

package/src/lib/utils/concurrency.ts

@@ -0,0 +1,72 @@
+/**
+ * Run an async mapping with bounded concurrency.
+ *
+ * Spawns up to `concurrency` workers that pull from a shared cursor.
+ * Results preserve input order.
+ */
+export async function mapWithConcurrency<T, R>(
+	items: readonly T[],
+	concurrency: number,
+	fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const results: R[] = new Array(items.length)
+	let next = 0
+	const workerCount = Math.max(1, Math.min(concurrency, items.length))
+	const workers = Array.from({ length: workerCount }, async () => {
+		while (true) {
+			const i = next++
+			if (i >= items.length) return
+			results[i] = await fn(items[i] as T, i)
+		}
+	})
+	await Promise.all(workers)
+	return results
+}
+
+/**
+ * Counting semaphore with FIFO waiter queue.
+ *
+ * Use `run(fn)` to execute work under the gate — acquires before invoking,
+ * releases on resolve/reject. Suitable for bounding contention on a shared
+ * resource (e.g. concurrent LLM calls) regardless of how many call sites
+ * compete for it.
+ */
+export class Semaphore {
+	private active = 0
+	private readonly waiters: Array<() => void> = []
+
+	constructor(private readonly limit: number) {
+		if (!Number.isInteger(limit) || limit < 1) {
+			throw new Error(`Semaphore limit must be a positive integer, got ${limit}`)
+		}
+	}
+
+	async run<T>(fn: () => Promise<T>): Promise<T> {
+		await this.acquire()
+		try {
+			return await fn()
+		} finally {
+			this.release()
+		}
+	}
+
+	private acquire(): Promise<void> {
+		if (this.active < this.limit) {
+			this.active++
+			return Promise.resolve()
+		}
+		return new Promise<void>(resolve => {
+			this.waiters.push(resolve)
+		})
+	}
+
+	private release(): void {
+		const next = this.waiters.shift()
+		if (next) {
+			// Slot transfers directly to the next waiter; active stays unchanged.
+			next()
+		} else {
+			this.active--
+		}
+	}
+}

package/src/plugins/agent-status/plugin.ts

@@ -38,40 +38,33 @@ export const agentStatusPlugin = definePlugin('agent-status')
 				sessionId: ctx.sessionId,
 				agentId: ctx.agentId,
 				status: 'thinking',
+				definitionName: ctx.agentState.definitionName,
 				timestamp: Date.now(),
 			})
 		}
 		return null
 	})
 	.hook('onComplete', async (ctx) => {
-		if (ctx.parentId !== null) {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				definitionName: ctx.agentState.definitionName,
-				timestamp: Date.now(),
-			})
-		} else {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				timestamp: Date.now(),
-			})
-		}
+		ctx.notify('agentStatus', {
+			sessionId: ctx.sessionId,
+			agentId: ctx.agentId,
+			status: 'idle',
+			definitionName: ctx.agentState.definitionName,
+			timestamp: Date.now(),
+		})
 		return null
 	})
 	.hook('onError', async (ctx) => {
-		if (ctx.parentId !== null) {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				definitionName: ctx.agentState.definitionName,
-				timestamp: Date.now(),
-			})
-		}
+		// Emit idle for both entry and sub-agents — without this the client's
+		// `activeAgents` map keeps the agent flagged thinking until reconnect,
+		// since the session-store no longer clears it on chat_message/ask_user.
+		ctx.notify('agentStatus', {
+			sessionId: ctx.sessionId,
+			agentId: ctx.agentId,
+			status: 'idle',
+			definitionName: ctx.agentState.definitionName,
+			timestamp: Date.now(),
+		})
 		return null
 	})
 	.build()

package/src/plugins/context-compact/compaction-live.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Live compaction tests against the real Anthropic API.
+ *
+ * Opt-in: run with `LIVE_TESTS=1 ANTHROPIC_API_KEY=…`. Skipped otherwise so the
+ * default `bun test` run stays hermetic.
+ *
+ * These cover the two real-API claims of the context-compact rewrite (5c27ab7):
+ *  1. The auxiliary-inference call (used by `ContextCompactor`) reuses the
+ *     agent's warm prompt cache — only the trailing instruction + output are
+ *     paid for, not the whole conversation a second time.
+ *  2. `DEFAULT_SUMMARY_INSTRUCTION` actually elicits a plain-text summary from
+ *     a real Sonnet/Haiku-class model (no tool calls, non-empty content), so
+ *     the end-to-end `ContextCompactor.compact()` path produces a usable
+ *     `[CONVERSATION SUMMARY]` block.
+ */
+
+import { describe, expect, test } from 'bun:test'
+import { generateTestAgentId } from '~/core/agents/schema.js'
+import type { ImageProcessor } from '~/core/image/types.js'
+import type { LLMMessage } from '~/core/agents/state.js'
+import { AnthropicProvider } from '~/core/llm/anthropic.js'
+import { applyCacheBreakpoint } from '~/core/llm/cache-breakpoints.js'
+import type { InferenceResponse, LLMError } from '~/core/llm/provider.js'
+import { ModelId } from '~/core/llm/schema.js'
+import { generateSessionId } from '~/core/sessions/schema.js'
+import { silentLogger } from '~/lib/logger/logger.js'
+import type { Result } from '~/lib/utils/result.js'
+import {
+	ContextCompactor,
+	DEFAULT_SUMMARY_INSTRUCTION,
+	type RunInferenceFn,
+} from './context-compactor.js'
+
+const liveEnabled = process.env.LIVE_TESTS === '1'
+const anthropicApiKey = liveEnabled ? process.env.ANTHROPIC_API_KEY : undefined
+
+const describeLive = (name: string, apiKey: string | undefined, fn: () => void) => {
+	if (!apiKey) {
+		describe.skip(`${name} (skipped — API key missing)`, fn)
+		return
+	}
+	describe(name, fn)
+}
+
+const noopImageProcessor: ImageProcessor = {
+	resolveContent: async (content) => content,
+}
+
+const MODEL = ModelId('claude-haiku-4-5-20251001')
+
+/**
+ * Padded system prompt so the cacheable prefix comfortably exceeds Anthropic's
+ * 1024-token minimum for Haiku. Deterministic content so identical calls reuse
+ * the exact same prefix.
+ */
+const LARGE_SYSTEM_PROMPT = [
+	'You are a meticulous assistant helping a developer review a long conversation.',
+	'Always respond concisely and accurately. Never speculate beyond the data.',
+	'Follow these rules strictly:',
+	...Array.from(
+		{ length: 120 },
+		(_, i) => `- Rule ${i + 1}: When asked about topic ${i + 1}, prefer factual sources and decline to speculate.`,
+	),
+	'End of instructions.',
+].join('\n')
+
+/**
+ * Deterministic multi-turn history padded well past 1024 tokens so cache writes
+ * and reads are unambiguous. Includes both user and assistant messages, which
+ * is the shape an inline-compaction call sees in practice.
+ */
+function buildLongHistory(): LLMMessage[] {
+	const history: LLMMessage[] = []
+	for (let i = 0; i < 8; i++) {
+		history.push({
+			role: 'user',
+			content:
+				`Turn ${i + 1} user: please analyze topic ${i + 1}. `
+				+ 'context detail '.repeat(30),
+		})
+		history.push({
+			role: 'assistant',
+			content:
+				`Turn ${i + 1} assistant: here is my analysis of topic ${i + 1}. `
+				+ 'analysis detail '.repeat(30),
+		})
+	}
+	return history
+}
+
+describeLive('context-compact live: auxiliary inference cache reuse', anthropicApiKey, () => {
+	test('priming inference then auxiliary summary call hits the prompt cache', async () => {
+		const provider = new AnthropicProvider({
+			apiKey: anthropicApiKey!,
+			imageProcessor: noopImageProcessor,
+			defaultModel: 'claude-haiku-4-5-20251001',
+		})
+
+		const history = buildLongHistory()
+
+		// Call 1: regular inference, breakpoint on the last history message.
+		// Mirrors what an Agent.advance() turn does just before requesting a
+		// compaction summary.
+		const primeMessages = applyCacheBreakpoint(history, 0, '1h')
+		const prime = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: primeMessages,
+		})
+		if (!prime.ok) {
+			if (prime.error.message?.includes('credit balance')) {
+				console.warn('⚠️  Live compaction cache test skipped: credit balance too low')
+				return
+			}
+			throw new Error(`prime call failed: ${JSON.stringify(prime.error)}`)
+		}
+		expect(prime.value.metrics.promptTokens).toBeGreaterThan(1024)
+
+		// Call 2: simulate Agent.runAuxiliaryInference — append the summary
+		// instruction as a trailing user message and place the breakpoint at
+		// the same position as the prime call (last history message), so the
+		// whole prefix lands as a cache read.
+		const summaryInstruction: LLMMessage = { role: 'user', content: DEFAULT_SUMMARY_INSTRUCTION }
+		const auxMessages = applyCacheBreakpoint([...history, summaryInstruction], 1, '1h')
+		const aux = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: auxMessages,
+		})
+		if (!aux.ok) throw new Error(`auxiliary call failed: ${JSON.stringify(aux.error)}`)
+
+		// Core claim: the auxiliary call served the prefix from cache (otherwise
+		// we'd re-upload the entire conversation just to get a summary).
+		expect(aux.value.metrics.cachedTokens ?? 0).toBeGreaterThan(1024)
+
+		// Sonnet/Haiku reliably emit plain text under DEFAULT_SUMMARY_INSTRUCTION.
+		// If this regresses, the prompt is no longer fit for purpose.
+		expect(aux.value.toolCalls).toHaveLength(0)
+		expect(aux.value.finishReason).toBe('stop')
+		expect(aux.value.content ?? '').not.toBe('')
+	}, 60_000)
+})
+
+describeLive('context-compact live: end-to-end compactor', anthropicApiKey, () => {
+	test('ContextCompactor.compact() produces a real summary from a real model', async () => {
+		const provider = new AnthropicProvider({
+			apiKey: anthropicApiKey!,
+			imageProcessor: noopImageProcessor,
+			defaultModel: 'claude-haiku-4-5-20251001',
+		})
+
+		const history = buildLongHistory()
+
+		// Wraps the provider exactly the way AgentContext.runAuxiliaryInference
+		// does: full prefix + extraMessages, breakpoint pinned to the last
+		// pre-extraMessages position so the agent's cache is reused.
+		const auxCalls: InferenceResponse[] = []
+		const runInference: RunInferenceFn = async (
+			extraMessages,
+		): Promise<Result<InferenceResponse, LLMError>> => {
+			const messages = applyCacheBreakpoint(
+				[...history, ...extraMessages],
+				extraMessages.length,
+				'1h',
+			)
+			const result = await provider.inference({
+				model: MODEL,
+				systemPrompt: LARGE_SYSTEM_PROMPT,
+				messages,
+			})
+			if (result.ok) auxCalls.push(result.value)
+			return result
+		}
+
+		// Prime the cache with one regular inference first, otherwise the
+		// auxiliary call would pay full write cost — same as a real session
+		// where compaction always runs after at least one normal turn.
+		const prime = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: applyCacheBreakpoint(history, 0, '1h'),
+		})
+		if (!prime.ok) {
+			if (prime.error.message?.includes('credit balance')) {
+				console.warn('⚠️  Live compaction end-to-end test skipped: credit balance too low')
+				return
+			}
+			throw new Error(`prime call failed: ${JSON.stringify(prime.error)}`)
+		}
+
+		const compactor = new ContextCompactor(silentLogger, {
+			// Force compaction regardless of estimator vs actual tokens.
+			maxTokens: 10,
+			keepRecentMessages: 2,
+		})
+
+		const result = await compactor.compact(
+			generateSessionId(),
+			generateTestAgentId(),
+			history,
+			runInference,
+		)
+
+		expect(result.ok).toBe(true)
+		if (!result.ok) return
+
+		expect(result.value.messagesRemoved).toBeGreaterThan(0)
+		expect(result.value.summary.trim().length).toBeGreaterThan(0)
+		// keepRecentMessages=2 → summary message + 2 kept = 3 total
+		expect(result.value.compactedMessages).toHaveLength(3)
+		expect(result.value.compactedMessages[0].role).toBe('user')
+		expect(result.value.compactedMessages[0].content as string).toContain(
+			'[CONVERSATION SUMMARY]',
+		)
+
+		// The auxiliary inference under the compactor should have served the
+		// prefix from cache (priming call wrote it).
+		expect(auxCalls).toHaveLength(1)
+		expect(auxCalls[0].metrics.cachedTokens ?? 0).toBeGreaterThan(1024)
+	}, 60_000)
+})

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

@@ -1,10 +1,27 @@
 import { describe, expect, it } from 'bun:test'
+import z from 'zod/v4'
 import { contextEvents } from '~/core/context/state.js'
 import { MockLLMProvider } from '~/core/llm/mock.js'
+import type { InferenceRequest } from '~/core/llm/provider.js'
 import { ModelId } from '~/core/llm/schema.js'
+import type { Preset } from '~/core/preset/index.js'
+import { createTool } from '~/core/tools/definition.js'
+import { ToolCallId } from '~/core/tools/schema.js'
 import { createTestPreset, TestHarness } from '~/testing/index.js'
 import { contextCompactPlugin } from './index.js'
 
+/**
+ * Inline compaction sends the agent's regular systemPrompt and full conversation
+ * to the LLM, with a trailing user message containing the summarization
+ * instruction. We detect compaction calls by looking at that trailing message.
+ */
+function isSummarizationRequest(request: InferenceRequest): boolean {
+	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]')
+}
+
 // ============================================================================
 // Helpers
 // ============================================================================
@@ -50,7 +67,7 @@ describe('context-compact plugin', () => {
 				presets: [createCompactPreset(10)],
 				mockHandler: (request) => {
 					// Compaction requests use CONTEXT_SUMMARY_PROMPT which contains "summarizer".
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						return {
 							content: 'Summary of conversation so far.',
 							toolCalls: [],
@@ -119,7 +136,7 @@ describe('context-compact plugin', () => {
 					inferenceCallCount++
 
 					// Summarization requests (from context-compact plugin)
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						return {
 							content: 'Conversation summary.',
 							toolCalls: [],
@@ -157,6 +174,121 @@ describe('context-compact plugin', () => {
 		})
 	})
 
+	// =========================================================================
+	// Pending tool results regression
+	// =========================================================================
+
+	describe('pending tool results', () => {
+		it('aux inference after a tool turn includes the tool_result before the summary instruction', async () => {
+			// Regression for the bug where context-compact's auxiliary inference call
+			// runs at a moment where `conversationHistory` ends with an assistant
+			// `tool_use` block but the corresponding tool_result is still in
+			// `pendingToolResults` (not yet committed to history). Sending
+			// `[..., assistant(tool_use), user(summary)]` to Anthropic 400s with
+			// "tool_use blocks must be followed by tool_result blocks".
+
+			const myTool = createTool({
+				name: 'my_tool',
+				description: 'returns a fixed value',
+				input: z.object({}),
+				execute: async () => ({ ok: true, value: 'tool result content' }),
+			})
+
+			const preset: Preset = {
+				id: 'test',
+				name: 'Tool Compaction Test',
+				orchestrator: {
+					system: 'You are a test agent.',
+					model: ModelId('mock'),
+					tools: [myTool],
+					agents: [],
+					debounceMs: 0,
+				},
+				agents: [],
+				plugins: [
+					contextCompactPlugin.configure({
+						compaction: {
+							model: ModelId('mock'),
+							maxTokens: 10,
+							// 1 so that after the tool turn, [user, assistant(tool_use)]
+							// splits into toCompact=[user], toKeep=[assistant(tool_use)] —
+							// the aux call actually runs and gets the buggy prefix.
+							keepRecentMessages: 1,
+						},
+					}),
+				],
+			}
+
+			let capturedAuxRequest: InferenceRequest | undefined
+
+			const harness = new TestHarness({
+				systemPlugins: [contextCompactPlugin],
+				presets: [preset],
+				mockHandler: (request) => {
+					if (isSummarizationRequest(request)) {
+						capturedAuxRequest = request
+						return {
+							content: 'Summary of conversation.',
+							toolCalls: [],
+							finishReason: 'stop',
+							metrics: MockLLMProvider.defaultMetrics(),
+						}
+					}
+					// First inference (no tool messages in history yet) → emit a tool call.
+					const hasToolMessages = request.messages.some((m) => m.role === 'tool')
+					if (!hasToolMessages) {
+						return {
+							content: '',
+							toolCalls: [{ id: ToolCallId('tc1'), name: 'my_tool', input: {} }],
+							finishReason: 'tool_calls',
+							metrics: MockLLMProvider.defaultMetrics(),
+						}
+					}
+					return {
+						content: 'Done.',
+						toolCalls: [],
+						finishReason: 'stop',
+						metrics: MockLLMProvider.defaultMetrics(),
+					}
+				},
+			})
+
+			const session = await harness.createSession('test')
+			await session.sendAndWaitForIdle('Please call my_tool')
+
+			expect(capturedAuxRequest).toBeDefined()
+
+			// Every assistant message with toolCalls must be followed by a contiguous
+			// run of tool messages covering each tool_use id before any further
+			// user/assistant message. This mirrors Anthropic's API contract.
+			const msgs = capturedAuxRequest!.messages
+			for (let i = 0; i < msgs.length; i++) {
+				const m = msgs[i]
+				if (m.role !== 'assistant' || !m.toolCalls?.length) continue
+
+				const expected = new Set(m.toolCalls.map((tc) => tc.id))
+				const seen = new Set<string>()
+				for (let j = i + 1; j < msgs.length; j++) {
+					const next = msgs[j]
+					if (next.role !== 'tool') break
+					seen.add(next.toolCallId)
+				}
+				for (const id of expected) {
+					expect(seen.has(id)).toBe(true)
+				}
+			}
+
+			// Compaction must have actually succeeded — pre-fix it would Err-out
+			// in production (mock accepts it but the assertion above already
+			// catches the malformed-prefix case).
+			const compactedEvents = await session.getEventsByType(contextEvents, 'context_compacted')
+			const actualCompactions = compactedEvents.filter((e) => e.messagesRemoved > 0)
+			expect(actualCompactions.length).toBeGreaterThanOrEqual(1)
+
+			await harness.shutdown()
+		})
+	})
+
 	// =========================================================================
 	// Compaction failure
 	// =========================================================================
@@ -170,7 +302,7 @@ describe('context-compact plugin', () => {
 				mockHandler: (request) => {
 					// Summarization requests — throw to simulate LLM failure.
 					// MockLLMProvider only returns Err() when the handler throws.
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						throw { type: 'server_error', message: 'LLM summarization failed' }
 					}