@roj-ai/sdk 0.1.29 → 0.1.31

package/src/plugins/agents/agents.integration.test.ts

@@ -805,4 +805,172 @@ describe('agents plugin', () => {
 			await harness.shutdown()
 		})
 	})
+
+	// =========================================================================
+	// resume_agent tool
+	// =========================================================================
+
+	describe('resume_agent tool', () => {
+		// A paused child never becomes idle, so waitForAllAgentsIdle can't be used here —
+		// wait for the effect instead.
+		const waitFor = async (predicate: () => boolean, timeoutMs = 5000): Promise<void> => {
+			const deadline = Date.now() + timeoutMs
+			while (Date.now() < deadline) {
+				if (predicate()) return
+				await new Promise(resolve => setTimeout(resolve, 10))
+			}
+			throw new Error('waitFor timed out')
+		}
+
+		const workerPreset = () => createMultiAgentPreset([
+			{ name: 'worker', system: 'Worker agent.', tools: [], agents: [] },
+		], { orchestratorSystem: 'Orchestrator agent.' })
+
+		it('is offered to an agent that can spawn, and not to a leaf', async () => {
+			const toolNames = new Map<string, string[]>()
+
+			const harness = new TestHarness({
+				presets: [workerPreset()],
+				mockHandler: (request) => {
+					const role = request.systemPrompt.includes('Orchestrator') ? 'orchestrator' : 'worker'
+					toolNames.set(role, (request.tools ?? []).map(tool => tool.name))
+					if (role === 'orchestrator' && !toolNames.has('worker')) {
+						return {
+							content: null,
+							toolCalls: [{ id: ToolCallId('tc1'), name: 'start_worker', input: { message: 'Work' } }],
+							finishReason: 'stop',
+							metrics: MockLLMProvider.defaultMetrics(),
+						}
+					}
+					return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
+				},
+			})
+
+			const session = await harness.createSession('test')
+			await session.sendAndWaitForIdle('Start')
+
+			expect(toolNames.get('orchestrator')).toContain('resume_agent')
+			expect(toolNames.get('worker')).not.toContain('resume_agent')
+
+			await harness.shutdown()
+		})
+
+		it('orchestrator resumes its paused child', async () => {
+			let started = false
+			let resumeIssued = false
+
+			const harness = new TestHarness({
+				presets: [workerPreset()],
+				mockHandler: (request) => {
+					if (request.systemPrompt.includes('Orchestrator')) {
+						const asked = JSON.stringify(request.messages).includes('Resume the worker')
+						if (asked && !resumeIssued) {
+							resumeIssued = true
+							return {
+								content: null,
+								toolCalls: [{ id: ToolCallId('tc2'), name: 'resume_agent', input: { agentId: 'worker_1' } }],
+								finishReason: 'stop',
+								metrics: MockLLMProvider.defaultMetrics(),
+							}
+						}
+						if (!started) {
+							started = true
+							return {
+								content: null,
+								toolCalls: [{ id: ToolCallId('tc1'), name: 'start_worker', input: { message: 'Work' } }],
+								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')
+
+			const pauseResult = await session.callPluginMethod('agents.pause', { agentId: 'worker_1' })
+			expect(pauseResult.ok).toBe(true)
+			expect(session.state.agents.get(AgentId('worker_1'))!.status).toBe('paused')
+
+			await session.sendMessage('Resume the worker')
+			await waitFor(() => session.state.agents.get(AgentId('worker_1'))!.status !== 'paused')
+
+			const resumedEvents = await session.getEventsByType(agentEvents, 'agent_resumed')
+			expect(resumedEvents.filter(e => e.agentId === AgentId('worker_1'))).toHaveLength(1)
+			expect(session.state.agents.get(AgentId('worker_1'))!.status).not.toBe('paused')
+
+			await harness.shutdown()
+		})
+
+		it('refuses an agent that is not the caller\'s child', async () => {
+			let delegated = false
+			let subDelegated = false
+			let resumeIssued = false
+			let toolResult = ''
+
+			const harness = new TestHarness({
+				presets: [createMultiAgentPreset([
+					{ name: 'worker_a', system: 'Worker A agent.', tools: [], agents: ['worker_b'] },
+					{ name: 'worker_b', system: 'Worker B agent.', tools: [], agents: [] },
+				], { orchestratorSystem: 'Orchestrator agent.' })],
+				mockHandler: (request) => {
+					if (request.systemPrompt.includes('Orchestrator')) {
+						const last = request.messages[request.messages.length - 1]
+						if (last?.role === 'tool' && resumeIssued) toolResult = JSON.stringify(last.content)
+
+						const asked = JSON.stringify(request.messages).includes('Resume the grandchild')
+						if (asked && !resumeIssued) {
+							resumeIssued = true
+							// worker_b is a grandchild — spawned by worker_a, not by the orchestrator
+							return {
+								content: null,
+								toolCalls: [{ id: ToolCallId('tc3'), name: 'resume_agent', input: { agentId: 'worker_b_1' } }],
+								finishReason: 'stop',
+								metrics: MockLLMProvider.defaultMetrics(),
+							}
+						}
+						if (!delegated) {
+							delegated = true
+							return {
+								content: null,
+								toolCalls: [{ id: ToolCallId('tc1'), name: 'start_worker_a', input: { message: 'Delegate' } }],
+								finishReason: 'stop',
+								metrics: MockLLMProvider.defaultMetrics(),
+							}
+						}
+						return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
+					}
+
+					if (request.systemPrompt.includes('Worker A')) {
+						if (subDelegated) {
+							return { content: 'Worker A done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
+						}
+						subDelegated = true
+						return {
+							content: null,
+							toolCalls: [{ id: ToolCallId('tc2'), name: 'start_worker_b', input: { message: 'Sub-task' } }],
+							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: 15_000 })
+
+			await session.callPluginMethod('agents.pause', { agentId: 'worker_b_1' })
+			await session.sendMessage('Resume the grandchild')
+			await waitFor(() => toolResult !== '')
+
+			expect(toolResult).toContain('not your child')
+			expect(session.state.agents.get(AgentId('worker_b_1'))!.status).toBe('paused')
+
+			await harness.shutdown()
+		}, 20_000)
+	})
 })

package/src/plugins/agents/plugin.ts

@@ -420,7 +420,7 @@ export const agentsPlugin = definePlugin('agents')
 - **New task** → spawn a new agent using \`start_<agent_name>\`. You will receive the agent's ID in the result — use it with \`send_message\` for follow-up communication.
 - **Follow-up on an existing task** → send a message to the existing agent via \`send_message\` with the agent's ID. Do NOT spawn a new agent for feedback, corrections, or additional instructions on a task already assigned.
 - Spawned agents communicate back to you via \`send_message\`. Check your incoming messages for their results and progress updates.
-- If a child pauses early it sends you a \`<child-paused agent="…">reason</child-paused>\` message (e.g. it hit a cost/limit budget). Decide what to do: resume it (after addressing the cause), reassign or drop the work, or stop.`
+- If a child pauses early it sends you a \`<child-paused agent="…">reason</child-paused>\` message (e.g. it hit a cost/limit budget). Decide what to do: resume it with \`resume_agent\` **after addressing the cause**, reassign or drop the work, or stop. Resuming does not grant more budget — a child that hit a cost or token limit will stop again immediately, so don't retry it in a loop.`
 
 		// Only include supervision instructions if supervision is actually enabled
 		// for this session — otherwise the section is misleading bloat.
@@ -438,7 +438,41 @@ Do NOT act on a supervision tick unless something is genuinely wrong (a child ha
 		const spawnableAgents = ctx.agentConfig.spawnableAgents
 		const agentDefs = ctx.pluginConfig.agentDefinitions
 
-		return spawnableAgents.map((agentName) => {
+		// The parent is told (see the `<child-paused>` line in the system prompt above) that it
+		// may resume a paused child. Without this tool that instruction had nothing behind it:
+		// `resume` existed only as a plugin method, reachable from outside the session via
+		// `agents.resume`, so a child that paused stayed paused until something external
+		// intervened. Only offered to agents that can actually have children.
+		const resumeTool = createTool({
+			name: 'resume_agent',
+			description:
+				'Resume one of your own child agents after it paused (you receive a <child-paused> message when that happens). '
+				+ 'Address the cause first — resuming does not grant more budget, so a child that hit a cost or token limit '
+				+ 'will stop again immediately unless the limit itself is raised.',
+			input: z.object({
+				agentId: agentIdSchema.describe('ID of the paused child agent, as given in the <child-paused> message'),
+			}),
+			execute: async (input, context) => {
+				const target = context.sessionState.agents.get(input.agentId)
+				if (!target) {
+					return Err({ message: `No agent "${input.agentId}" in this session.`, recoverable: false })
+				}
+				if (target.parentId !== context.agentId) {
+					return Err({ message: `Agent "${input.agentId}" is not your child — you can only resume agents you spawned.`, recoverable: false })
+				}
+				if (target.status !== 'paused' && target.status !== 'errored') {
+					return Err({ message: `Agent "${input.agentId}" is ${target.status}, not paused — nothing to resume.`, recoverable: false })
+				}
+
+				const result = await ctx.self.resume({ agentId: input.agentId })
+				if (!result.ok) {
+					return Err({ message: result.error.message, recoverable: false })
+				}
+				return Ok(`Agent "${input.agentId}" resumed.`)
+			},
+		})
+
+		const startTools = spawnableAgents.map((agentName) => {
 			const agentInfo = agentDefs.get(agentName) ?? { name: agentName }
 			const toolName = `start_${agentInfo.name}`
 			const description = agentInfo.description
@@ -469,5 +503,8 @@ Do NOT act on a supervision tick unless something is genuinely wrong (a child ha
 				},
 			})
 		})
+
+		// An agent with nothing to spawn has no children to resume either.
+		return spawnableAgents.length > 0 ? [...startTools, resumeTool] : []
 	})
 	.build()

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

@@ -3,7 +3,7 @@ import z from 'zod/v4'
 import { contextEvents } from '~/core/context/state.js'
 import { llmEvents } from '~/core/llm/state.js'
 import { MockLLMProvider } from '~/core/llm/mock.js'
-import type { InferenceRequest } from '~/core/llm/provider.js'
+import type { InferenceRequest, LLMMessage } 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'
@@ -48,6 +48,33 @@ function createCompactHarness(options: Omit<ConstructorParameters<typeof TestHar
 	return new TestHarness({ ...options, systemPlugins: [contextCompactPlugin] })
 }
 
+function expectToolPairing(messages: LLMMessage[]): void {
+	const declaredToolCallIds = new Set<string>()
+
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]
+		if (message.role === 'assistant' && message.toolCalls?.length) {
+			const expected = new Set(message.toolCalls.map((toolCall) => toolCall.id))
+			const seen = new Set<string>()
+			for (const toolCall of message.toolCalls) {
+				declaredToolCallIds.add(toolCall.id)
+			}
+			for (let j = i + 1; j < messages.length; j++) {
+				const next = messages[j]
+				if (next.role !== 'tool') break
+				seen.add(next.toolCallId)
+			}
+			for (const id of expected) {
+				expect(seen.has(id)).toBe(true)
+			}
+		}
+
+		if (message.role === 'tool') {
+			expect(declaredToolCallIds.has(message.toolCallId)).toBe(true)
+		}
+	}
+}
+
 // ============================================================================
 // Tests
 // ============================================================================
@@ -222,6 +249,7 @@ describe('context-compact plugin', () => {
 			}
 
 			let capturedAuxRequest: InferenceRequest | undefined
+			let capturedToolResultRequest: InferenceRequest | undefined
 
 			const harness = new TestHarness({
 				systemPlugins: [contextCompactPlugin],
@@ -246,6 +274,7 @@ describe('context-compact plugin', () => {
 							metrics: MockLLMProvider.defaultMetrics(),
 						}
 					}
+					capturedToolResultRequest = request
 					return {
 						content: 'Done.',
 						toolCalls: [],
@@ -259,26 +288,14 @@ describe('context-compact plugin', () => {
 			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)
-				}
-			}
+			if (!capturedAuxRequest) return
+			expectToolPairing(capturedAuxRequest.messages)
+
+			// The event reducer runs before pending tool results are appended to the
+			// regular inference request. Pairing must survive that reconstruction.
+			expect(capturedToolResultRequest).toBeDefined()
+			if (!capturedToolResultRequest) return
+			expectToolPairing(capturedToolResultRequest.messages)
 
 			// Compaction must have actually succeeded — pre-fix it would Err-out
 			// in production (mock accepts it but the assertion above already

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

@@ -1,10 +1,15 @@
 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'
@@ -315,12 +320,26 @@ describe('createContextCompactedEvent', () => {
 		expect(event.timestamp).toBeDefined()
 	})
 
-	it('converts tool role to system in history', () => {
+	it('preserves assistant tool calls and tool results in history', () => {
 		const sessionId = generateSessionId()
 		const agentId = generateTestAgentId()
 		const toolCallId = generateToolCallId()
 		const result: CompactionResult = {
-			compactedMessages: [{ role: 'tool', content: 'tool result', toolCallId }],
+			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,
@@ -330,8 +349,44 @@ describe('createContextCompactedEvent', () => {
 
 		const event = createContextCompactedEvent(sessionId, agentId, result)
 
-		// tool role should be converted to system
-		expect(event.newConversationHistory[0].role).toBe('system')
+		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 },
+		])
 	})
 })
 
@@ -614,6 +669,97 @@ describe('ContextCompactor with tool calls', () => {
 		// 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)
+	})
 })
 
 // ============================================================================

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

@@ -194,7 +194,7 @@ export class ContextCompactor {
 			count = 0
 			let tokens = 0
 			for (let i = messages.length - 1; i >= 0 && count < maxCount; i--) {
-				const msgTokens = estimateMessagesTokens([messages[i]])
+				const msgTokens = estimateConversationTokens([messages[i]])
 				if (tokens + msgTokens > tokenBudget) break
 				tokens += msgTokens
 				count++
@@ -206,6 +206,13 @@ export class ContextCompactor {
 			count--
 		}
 
+		// An incomplete tool turn at the tail has pending results outside history.
+		// Keep its assistant declaration even if count/token limits would drop it.
+		const openToolTurnStart = findOpenToolTurnStart(messages)
+		if (openToolTurnStart !== undefined) {
+			count = Math.max(count, messages.length - openToolTurnStart)
+		}
+
 		return count
 	}
 
@@ -220,7 +227,7 @@ export class ContextCompactor {
 	 * relying on it alone causes the trigger to never fire in long sessions.
 	 */
 	needsCompaction(messages: LLMMessage[], lastActualPromptTokens?: number): boolean {
-		const tokens = lastActualPromptTokens ?? estimateMessagesTokens(messages)
+		const tokens = lastActualPromptTokens ?? estimateConversationTokens(messages)
 		return tokens > this.config.maxTokens
 	}
 
@@ -256,7 +263,7 @@ export class ContextCompactor {
 		runInference: RunInferenceFn,
 		lastActualPromptTokens?: number,
 	): Promise<Result<CompactionResult, Error>> {
-		const originalTokens = lastActualPromptTokens ?? estimateMessagesTokens(messages)
+		const originalTokens = lastActualPromptTokens ?? estimateConversationTokens(messages)
 
 		this.logger.info('Starting context compaction', {
 			sessionId,
@@ -338,7 +345,7 @@ export class ContextCompactor {
 		}
 
 		const compactedMessages = [summaryMessage, ...toKeep]
-		const compactedTokens = estimateMessagesTokens(compactedMessages)
+		const compactedTokens = estimateConversationTokens(compactedMessages)
 
 		this.logger.info('Context compaction complete', {
 			sessionId,
@@ -362,6 +369,54 @@ export class ContextCompactor {
 	}
 }
 
+function findOpenToolTurnStart(messages: LLMMessage[]): number | undefined {
+	let assistantIndex = messages.length - 1
+	while (assistantIndex >= 0 && messages[assistantIndex].role === 'tool') {
+		assistantIndex--
+	}
+
+	const assistant = messages[assistantIndex]
+	if (assistant?.role !== 'assistant' || !assistant.toolCalls?.length) {
+		return undefined
+	}
+
+	const completedToolCallIds = new Set<string>()
+	for (let i = assistantIndex + 1; i < messages.length; i++) {
+		const message = messages[i]
+		if (message.role === 'tool') {
+			completedToolCallIds.add(message.toolCallId)
+		}
+	}
+	return assistant.toolCalls.some((toolCall) => !completedToolCallIds.has(toolCall.id))
+		? assistantIndex
+		: undefined
+}
+
+function estimateConversationTokens(messages: LLMMessage[]): number {
+	return estimateMessagesTokens(messages.map((message) => ({
+		role: message.role,
+		content: tokenEstimationContent(message),
+	})))
+}
+
+function tokenEstimationContent(message: LLMMessage): unknown {
+	switch (message.role) {
+		case 'assistant':
+			return message.toolCalls?.length
+				? { content: message.content, toolCalls: message.toolCalls }
+				: message.content
+		case 'tool':
+			return {
+				content: message.content,
+				toolCallId: message.toolCallId,
+				isError: message.isError,
+			}
+		case 'user':
+		case 'system':
+			return message.content
+	}
+}
+
 // ============================================================================
 // Event creation helper
 // ============================================================================
@@ -371,11 +426,7 @@ export function createContextCompactedEvent(
 	agentId: AgentId,
 	result: CompactionResult,
 ): ContextCompactedEvent {
-	// Convert LLMMessage[] to CompactedConversationMessage[]
-	const newConversationHistory: CompactedConversationMessage[] = result.compactedMessages.map((msg) => ({
-		role: msg.role === 'tool' ? 'system' : msg.role,
-		content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-	}))
+	const newConversationHistory: CompactedConversationMessage[] = result.compactedMessages
 
 	return withSessionId(
 		sessionId,
@@ -397,7 +448,10 @@ export function createContextCompactedEvent(
  * tool-call and tool-result detail in the rendered content. Used for the
  * compaction "input" snapshot shown in the debug UI — not for reconstruction.
  */
-function toDisplayMessage(msg: LLMMessage): CompactedConversationMessage {
+function toDisplayMessage(msg: LLMMessage): {
+	role: 'user' | 'assistant' | 'system'
+	content: string
+} {
 	if (msg.role === 'assistant') {
 		const parts: string[] = []
 		if (msg.content) parts.push(msg.content)

package/src/plugins/limits-guard/config.ts

@@ -23,6 +23,8 @@ export interface AgentLimits {
 	maxRepeatedToolCalls?: number
 	/** Maximum consecutive identical text-only responses. Default: 3 */
 	maxRepeatedResponses?: number
+	/** Maximum consecutive outbound-only turns without newly consumed inbound work. Default: 3 */
+	maxConsecutiveNoProgressTurns?: number
 	/**
 	 * Maximum cumulative LLM cost (USD) this agent may spend before it is paused.
 	 * Spend is summed from `inference_completed` metrics and, unlike the counter

package/src/plugins/limits-guard/limit-guard.test.ts

@@ -14,6 +14,7 @@ describe('resolveAgentLimits', () => {
 		expect(limits.softLimitRatio).toBe(0.8)
 		expect(limits.maxRepeatedToolCalls).toBe(3)
 		expect(limits.maxRepeatedResponses).toBe(3)
+		expect(limits.maxConsecutiveNoProgressTurns).toBe(3)
 		// Budgets and compaction cap are opt-in (unlimited by default)
 		expect(limits.maxCost).toBe(Number.POSITIVE_INFINITY)
 		expect(limits.maxTokens).toBe(Number.POSITIVE_INFINITY)
@@ -112,6 +113,18 @@ describe('checkLimits', () => {
 		}
 	})
 
+	it('detects consecutive no-progress turns', () => {
+		const result = checkLimits(
+			makeCounters({ consecutiveNoProgressTurns: 3 }),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxConsecutiveNoProgressTurns')
+			expect(result.reason).toContain('used only outbound communication')
+		}
+	})
+
 	it('detects consecutive tool failures', () => {
 		const result = checkLimits(
 			makeCounters({ consecutiveToolFailures: { read_file: { count: 3, lastError: 'file not found' } } }),