@namzu/sdk 3.0.0 → 3.2.0

package/src/runtime/query/iteration/index.ts

@@ -5,11 +5,13 @@ import {
 	DEFAULT_STRUCTURED_OUTPUT_RETRIES,
 	STRUCTURED_OUTPUT_REPROMPT,
 } from '../../../constants/tools/index.js'
+import { renderSkillsSection } from '../../../persona/assembler.js'
 import { collect } from '../../../provider/collect.js'
 import {
 	GENAI,
 	NAMZU,
 	agentIterationSpanName,
+	chatSpanName,
 	parentContext,
 } from '../../../telemetry/attributes.js'
 import { getTracer } from '../../../telemetry/runtime-accessors.js'
@@ -21,6 +23,7 @@ import {
 	createSystemMessage,
 	createUserMessage,
 } from '../../../types/message/index.js'
+import type { ToolChoice } from '../../../types/provider/chat.js'
 import { classifyProviderError } from '../../../types/provider/errors.js'
 import type { ChatCompletionResponse } from '../../../types/provider/index.js'
 import type { AnswerReview } from '../../../types/run/answer-review.js'
@@ -30,6 +33,8 @@ import type {
 	StepResult,
 	StopReason,
 } from '../../../types/run/index.js'
+import type { Skill } from '../../../types/skills/index.js'
+import type { LLMToolSchema, ToolRegistryContract } from '../../../types/tool/index.js'
 import { toErrorMessage } from '../../../utils/error.js'
 import { generateMessageId } from '../../../utils/id.js'
 import type { ToolCallOutcome } from '../executor.js'
@@ -149,23 +154,30 @@ export class IterationOrchestrator {
 				{},
 				parentContext(this.ctx.rootSpan),
 			)
-			// Tool spans for this turn belong under this iteration.
-			this.ctx.toolExecutor.setParentSpan(iterSpan)
+			// Declared out here so the iteration's own finally can close it on
+			// any path that does not reach its success branch.
+			let chatSpan: Span | undefined
+			try {
+				// Tool spans for this turn belong under this iteration. Inside
+				// the try rather than before it: a throw from any of these left
+				// the span open, and an iteration span that never ends is a
+				// trace that never closes — the export is incomplete for exactly
+				// the run that failed.
+				this.ctx.toolExecutor.setParentSpan(iterSpan)
 
-			iterSpan.setAttributes({
-				[NAMZU.ITERATION]: iterationNum,
-				[NAMZU.RUN_ID]: runMgr.id,
-				[GENAI.REQUEST_MODEL]: model,
-			})
+				iterSpan.setAttributes({
+					[NAMZU.ITERATION]: iterationNum,
+					[NAMZU.RUN_ID]: runMgr.id,
+					[GENAI.REQUEST_MODEL]: model,
+				})
 
-			await this.ctx.emitEvent({
-				type: 'iteration_started',
-				runId: runMgr.id,
-				iteration: iterationNum,
-			})
-			yield* this.ctx.drainPending()
+				await this.ctx.emitEvent({
+					type: 'iteration_started',
+					runId: runMgr.id,
+					iteration: iterationNum,
+				})
+				yield* this.ctx.drainPending()
 
-			try {
 				if (this.ctx.pluginManager) {
 					const hookResults = await this.ctx.pluginManager.executeHooks(
 						'iteration_start',
@@ -200,6 +212,7 @@ export class IterationOrchestrator {
 				const step = await this.prepareStep(iterationNum)
 
 				const llmTools = this.ctx.tools.toLLMTools(step.allowedTools ?? this.ctx.allowedTools)
+				const enforceToolInputSchema = enforcedModelInputToolNames(this.ctx.tools, llmTools)
 				const stepModel = step.model ?? model
 
 				const baseMessages = forceFinalize
@@ -223,8 +236,17 @@ export class IterationOrchestrator {
 				// exactly this reason. Shallow is enough: the defect is array
 				// mutation, and per-iteration this is trivial next to the model
 				// call it precedes.
-				const messages = step.system
-					? [...baseMessages, createSystemMessage(step.system)]
+				// A step's skills and its guidance ride the same ephemeral
+				// trailing system message. Appending leaves the cached prefix
+				// intact; rewriting the run's own prompt to carry a phase's
+				// skills would invalidate it on every iteration.
+				// `renderSkillsSection` already answers null for an empty list, so
+				// there is no length check here — a second guard for the same
+				// case is one more thing to keep in agreement with the first.
+				const stepSkills = step.skills ? renderSkillsSection([...step.skills]) : null
+				const stepPreamble = [step.system, stepSkills].filter(Boolean).join('\n\n')
+				const messages = stepPreamble
+					? [...baseMessages, createSystemMessage(stepPreamble)]
 					: [...baseMessages]
 
 				if (this.ctx.pluginManager) {
@@ -260,13 +282,45 @@ export class IterationOrchestrator {
 				// aggregated `ChatCompletionResponse` for the legacy
 				// downstream paths (assistantMsg construction, working
 				// state extraction, telemetry attribute stamping).
+				// The model call gets its own span. There was none at all —
+				// `chatSpanName` shipped with zero call sites — so a run's traces
+				// carried no LLM latency whatsoever, and the one thing anybody
+				// opens a trace to find (which turn was slow, and why) was the
+				// one thing not in it.
+				chatSpan = tracer.startSpan(chatSpanName(stepModel), {}, parentContext(iterSpan))
+				chatSpan.setAttributes({
+					[GENAI.OPERATION_NAME]: 'chat',
+					[GENAI.SYSTEM]: this.ctx.provider.id,
+					[GENAI.REQUEST_MODEL]: stepModel,
+					...((step.temperature ?? runConfig.temperature) !== undefined
+						? { [GENAI.REQUEST_TEMPERATURE]: (step.temperature ?? runConfig.temperature) as number }
+						: {}),
+					...((step.maxResponseTokens ?? runConfig.maxResponseTokens) !== undefined
+						? {
+								[GENAI.REQUEST_MAX_TOKENS]: (step.maxResponseTokens ??
+									runConfig.maxResponseTokens) as number,
+							}
+						: {}),
+				})
+
 				const { response, messageId } = yield* streamProviderTurn(
 					this.ctx.provider,
 					{
 						model: stepModel,
 						messages,
 						tools: llmTools.length > 0 ? llmTools : undefined,
-						toolChoice: forceFinalize && llmTools.length > 0 ? 'none' : undefined,
+						...(enforceToolInputSchema ? { enforceToolInputSchema } : {}),
+						// The forced-final turn wins: a step that asked to force a
+						// tool cannot override the loop's own decision to stop
+						// asking for them. Otherwise the step's choice applies —
+						// and only to this step, because the next one is prepared
+						// from scratch.
+						toolChoice:
+							forceFinalize && llmTools.length > 0
+								? 'none'
+								: llmTools.length > 0
+									? step.toolChoice
+									: undefined,
 						temperature: step.temperature ?? runConfig.temperature,
 						maxTokens: step.maxResponseTokens ?? runConfig.maxResponseTokens,
 						cacheControl: { type: 'auto' },
@@ -285,6 +339,27 @@ export class IterationOrchestrator {
 					iterSpan,
 				)
 
+				// Stamped on the call that produced them. The token counts also
+				// stay on the iteration span below, where they have always been:
+				// moving them would silently break whatever reads them today,
+				// and one turn per iteration makes the two agree.
+				chatSpan.setAttributes({
+					[GENAI.RESPONSE_MODEL]: response.model || stepModel,
+					[GENAI.RESPONSE_ID]: response.id,
+					[GENAI.USAGE_INPUT_TOKENS]: response.usage.promptTokens,
+					[GENAI.USAGE_OUTPUT_TOKENS]: response.usage.completionTokens,
+					// An array, per the semantic convention: one call can finish
+					// several ways when a provider returns more than one choice.
+					[GENAI.RESPONSE_FINISH_REASONS]: [response.finishReason ?? 'stop'],
+					[NAMZU.CACHE_READ_TOKENS]: response.usage.cachedTokens ?? 0,
+					[NAMZU.CACHE_WRITE_TOKENS]: response.usage.cacheWriteTokens ?? 0,
+				})
+				chatSpan.setStatus({ code: SpanStatusCode.OK })
+				chatSpan.end()
+				// Closed here for an accurate duration, and cleared so the
+				// iteration finally does not close it a second time.
+				chatSpan = undefined
+
 				// Main-loop turn: also records the prompt size compaction reads.
 				runMgr.recordTurnUsage(response.usage)
 
@@ -443,7 +518,6 @@ export class IterationOrchestrator {
 							hasToolCalls: false,
 						})
 						yield* this.ctx.drainPending()
-						iterSpan.end()
 						continue
 					}
 
@@ -461,7 +535,6 @@ export class IterationOrchestrator {
 								attempts: attempt - 1,
 							})
 							runMgr.setStopReason('structured_output_failed')
-							iterSpan.end()
 							break
 						}
 						this.ctx.log.info('Re-prompting for structured output', {
@@ -477,7 +550,6 @@ export class IterationOrchestrator {
 							hasToolCalls: false,
 						})
 						yield* this.ctx.drainPending()
-						iterSpan.end()
 						continue
 					}
 
@@ -506,7 +578,6 @@ export class IterationOrchestrator {
 									limit,
 								})
 								runMgr.setStopReason('answer_rejected')
-								iterSpan.end()
 								break
 							}
 							this.ctx.log.info('Answer rejected — returning it to the model', {
@@ -522,7 +593,6 @@ export class IterationOrchestrator {
 								hasToolCalls: false,
 							})
 							yield* this.ctx.drainPending()
-							iterSpan.end()
 							continue
 						}
 					}
@@ -550,11 +620,9 @@ export class IterationOrchestrator {
 					if (this.ctx.abortController.signal.aborted) {
 						runMgr.setStopReason('cancelled')
 						runMgr.markCancelled()
-						iterSpan.end()
 						break
 					}
 					runMgr.setStopReason('end_turn')
-					iterSpan.end()
 					break
 				}
 
@@ -576,12 +644,10 @@ export class IterationOrchestrator {
 				})
 
 				if (reviewOutcome.decision === 'stop') {
-					iterSpan.end()
 					return
 				}
 
 				if (reviewOutcome.decision === 'rejected') {
-					iterSpan.end()
 					continue
 				}
 
@@ -601,7 +667,6 @@ export class IterationOrchestrator {
 						hasToolCalls: true,
 					})
 					yield* this.ctx.drainPending()
-					iterSpan.end()
 					break
 				}
 
@@ -628,7 +693,6 @@ export class IterationOrchestrator {
 						hasToolCalls: true,
 					})
 					yield* this.ctx.drainPending()
-					iterSpan.end()
 					break
 				}
 
@@ -648,13 +712,11 @@ export class IterationOrchestrator {
 						hasToolCalls: true,
 					})
 					yield* this.ctx.drainPending()
-					iterSpan.end()
 					break
 				}
 
 				const checkpointSignal = yield* runIterationCheckpoint(this.ctx, iterationNum)
 				if (checkpointSignal === 'stop') {
-					iterSpan.end()
 					return
 				}
 
@@ -677,7 +739,6 @@ export class IterationOrchestrator {
 					hasToolCalls: true,
 				})
 				yield* this.ctx.drainPending()
-				iterSpan.end()
 			} catch (err) {
 				// A Stop that aborted the in-flight turn surfaces here as a
 				// thrown abort (the provider stream was raced against the run
@@ -689,7 +750,6 @@ export class IterationOrchestrator {
 				if (this.ctx.abortController.signal.aborted) {
 					runMgr.setStopReason('cancelled')
 					runMgr.markCancelled()
-					iterSpan.end()
 					break
 				}
 
@@ -719,7 +779,6 @@ export class IterationOrchestrator {
 						if (iterationActivity) {
 							this.ctx.activityStore.complete(iterationActivity.id)
 						}
-						iterSpan.end()
 						continue
 					}
 				}
@@ -733,8 +792,15 @@ export class IterationOrchestrator {
 					message: toErrorMessage(err),
 				})
 				iterSpan.recordException(err instanceof Error ? err : new Error(String(err)))
-				iterSpan.end()
 				throw err
+			} finally {
+				// A model call that threw never reached its own close above.
+				chatSpan?.end()
+				// The only place the iteration span ends. It used to be ended at each of
+				// seventeen exits, which is a rule every future edit has to
+				// remember; a generator abandoned by its consumer never reached
+				// any of them.
+				iterSpan.end()
 			}
 		}
 	}
@@ -749,8 +815,10 @@ export class IterationOrchestrator {
 	 */
 	private async prepareStep(stepNumber: number): Promise<{
 		allowedTools?: string[]
+		toolChoice?: ToolChoice
 		model?: string
 		system?: string
+		skills?: readonly Skill[]
 		temperature?: number
 		maxResponseTokens?: number
 	}> {
@@ -786,8 +854,10 @@ export class IterationOrchestrator {
 
 		const prepared: {
 			allowedTools?: string[]
+			toolChoice?: ToolChoice
 			model?: string
 			system?: string
+			skills?: readonly Skill[]
 			temperature?: number
 			maxResponseTokens?: number
 		} = {}
@@ -806,8 +876,10 @@ export class IterationOrchestrator {
 			}
 			prepared.allowedTools = known
 		}
+		if (result.toolChoice !== undefined) prepared.toolChoice = result.toolChoice
 		if (result.model !== undefined) prepared.model = result.model
 		if (result.system !== undefined) prepared.system = result.system
+		if (result.skills !== undefined) prepared.skills = result.skills
 		if (result.temperature !== undefined) prepared.temperature = result.temperature
 		if (result.maxResponseTokens !== undefined) {
 			prepared.maxResponseTokens = result.maxResponseTokens
@@ -1042,11 +1114,13 @@ export class IterationOrchestrator {
 			// tools param identical to prior iterations (cache prefix intact,
 			// no 400 on tool blocks in history) and forbid use via tool_choice.
 			const finalTools = this.ctx.tools.toLLMTools(this.ctx.allowedTools)
+			const finalEnforced = enforcedModelInputToolNames(this.ctx.tools, finalTools)
 			const response = await collect(
 				this.ctx.provider.chatStream({
 					model,
 					messages: finalMessages,
 					tools: finalTools.length > 0 ? finalTools : undefined,
+					...(finalEnforced ? { enforceToolInputSchema: finalEnforced } : {}),
 					toolChoice: finalTools.length > 0 ? 'none' : undefined,
 					temperature: this.ctx.runConfig.temperature,
 					maxTokens: this.ctx.runConfig.maxResponseTokens,
@@ -1102,3 +1176,25 @@ function subtractUsage(after: TokenUsage, before: TokenUsage): TokenUsage {
 function round6(n: number): number {
 	return Math.round(n * 1e6) / 1e6
 }
+
+/**
+ * Which of the tools going out on this request have a closed model schema.
+ *
+ * A driver reads `enforceToolInputSchema` to decide which tool schemas to
+ * constrain generation against. Nothing populated it, so every driver that
+ * consumed it — three of them — was reading a permanently undefined field
+ * and `enforceModelInput: true` on a tool meant nothing end to end.
+ *
+ * Computed per request rather than once, because the allowed set changes:
+ * a deferred tool activated mid-run has to start being enforced from the
+ * next call, not the next process.
+ */
+function enforcedModelInputToolNames(
+	registry: ToolRegistryContract,
+	tools: readonly LLMToolSchema[],
+): readonly string[] | undefined {
+	const names = tools
+		.map((tool) => tool.function.name)
+		.filter((name) => registry.get(name)?.enforceModelInput === true)
+	return names.length > 0 ? names : undefined
+}

package/src/runtime/query/iteration/phases/compaction-model-routing.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { WorkingStateManager } from '../../../../compaction/manager.js'
+import { CompactionConfigSchema } from '../../../../config/runtime.js'
+import type { CompactionConfig } from '../../../../config/runtime.js'
+import type { Message } from '../../../../types/message/index.js'
+import type { TaskRouterConfig } from '../../../../types/router/index.js'
+import { runCompactionCheck } from './compaction.js'
+import type { IterationContext } from './context.js'
+
+/**
+ * The compaction summary is the only model call a run makes that nobody
+ * asked for, and it was hardwired to the primary model. `taskRouter` had been
+ * accepted, schema-validated and threaded through four types since it was
+ * added, with `resolveTaskModel` exported and never called — so a host who
+ * pointed compaction at a cheap model kept paying the expensive one.
+ */
+
+function harness(taskRouter?: TaskRouterConfig): {
+	ctx: IterationContext
+	modelsUsed: string[]
+} {
+	const messages: Message[] = [
+		{ role: 'system', content: 'prompt', timestamp: 1 },
+		...Array.from({ length: 40 }, (_, i) => ({
+			role: 'user' as const,
+			content: `turn ${i} `.repeat(200),
+			timestamp: 1,
+		})),
+	]
+	const config: CompactionConfig = {
+		...CompactionConfigSchema.parse({}),
+		contextWindowTokens: 1_000,
+		keepRecentMessages: 4,
+		llmVerification: true,
+		// Keep the slot count under the rich-state threshold so the verified
+		// summary path — the one that calls a model — is the one taken.
+		richStateThreshold: 1_000,
+	}
+	const modelsUsed: string[] = []
+
+	const ctx = {
+		compactionConfig: config,
+		workingStateManager: new WorkingStateManager(config),
+		runConfig: { model: 'primary-model' },
+		...(taskRouter ? { taskRouter } : {}),
+		runMgr: {
+			id: 'run_routing',
+			messages,
+			accumulateUsage: vi.fn(),
+			clearLastPromptTokens: vi.fn(),
+		},
+		provider: {
+			chatStream: async function* (params: { model: string }) {
+				modelsUsed.push(params.model)
+				yield { id: 'c1', delta: { content: 'a summary' } }
+				yield {
+					id: 'c1',
+					delta: {},
+					finishReason: 'stop',
+					usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2 },
+				}
+			},
+		},
+		log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+	} as unknown as IterationContext
+
+	return { ctx, modelsUsed }
+}
+
+describe('the compaction summary goes to the model a host routed it to', () => {
+	it('uses the primary model when nothing is routed', async () => {
+		const h = harness()
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['primary-model'])
+	})
+
+	it('uses the compaction model when one is named', async () => {
+		const h = harness({ compaction: 'small-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['small-model'])
+	})
+
+	it('falls back to the router default', async () => {
+		const h = harness({ default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['fallback-model'])
+	})
+
+	it('prefers the specific key over the default', async () => {
+		const h = harness({ compaction: 'small-model', default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['small-model'])
+	})
+
+	it('ignores a key that names no model', async () => {
+		// `null` is what the schema produces for an explicitly cleared key, and
+		// it has to mean "unrouted" rather than "route to nothing" — sending an
+		// empty model id is an endpoint error on backends where the id IS the
+		// endpoint.
+		const h = harness({ compaction: null, default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['fallback-model'])
+	})
+
+	it('does not route a key the runtime does not consult', async () => {
+		// `coding` is documented as inert. Pinning that keeps the docs honest:
+		// if a future change starts consulting it, this test says so.
+		const h = harness({ coding: 'coding-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['primary-model'])
+	})
+})

package/src/runtime/query/iteration/phases/compaction.ts

@@ -1,10 +1,13 @@
 import { resolveContextWindow } from '../../../../compaction/context-window.js'
-import { findSafeTrimIndex } from '../../../../compaction/dangling.js'
+import { findDanglingMessages, findSafeTrimIndex } from '../../../../compaction/dangling.js'
+import type { ContextReducer, ContextReduction } from '../../../../compaction/reducer.js'
+import { createSlidingWindowReducer } from '../../../../compaction/reducer.js'
 import { findRetainedIndices } from '../../../../compaction/retention.js'
 import { serializeState } from '../../../../compaction/serializer.js'
 import { clearStaleToolResults } from '../../../../compaction/tool-result-editing.js'
 import { buildVerifiedSummary } from '../../../../compaction/verifier.js'
 import { CHARS_PER_TOKEN } from '../../../../constants/limits.js'
+import { resolveTaskModel } from '../../../../router/task-router.js'
 import type { Message } from '../../../../types/message/index.js'
 import { createSystemMessage } from '../../../../types/message/index.js'
 import type { IterationContext } from './context.js'
@@ -202,6 +205,78 @@ function totalChars(messages: readonly { content: unknown }[]): number {
 	return total
 }
 
+/**
+ * Run a reducer and install what it returns, or leave the history alone.
+ *
+ * Three ways to decline, all of them ending the same way — the run keeps its
+ * full history. `undefined` is the reducer saying so; a throw is treated as
+ * the same answer, because a broken reduction hook should not kill a healthy
+ * run any more than a broken `prepareStep` should; and a result that splits a
+ * tool pair is REFUSED rather than repaired.
+ *
+ * That last one is the least obvious and the most important. `tool_result`
+ * without its `tool_use` is a provider 400 on the next turn, so quietly
+ * repairing it would trade a clear "this reducer split a tool pair" for an
+ * opaque rejection a call later, with the reducer never implicated. The
+ * invariant is written on {@link ContextReducer}; enforcing it where it is
+ * violated is what makes it true rather than aspirational.
+ */
+async function applyReducer(
+	ctx: IterationContext,
+	reducer: ContextReducer,
+	reduction: ContextReduction,
+): Promise<void> {
+	const messages = ctx.runMgr.messages
+	const before = messages.length
+	const beforeChars = totalChars(messages)
+
+	let next: readonly Message[] | undefined
+	try {
+		next = await reducer(reduction)
+	} catch (error) {
+		ctx.log.warn('Context reducer threw — keeping the full history', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			error: error instanceof Error ? error.message : String(error),
+		})
+		return
+	}
+
+	if (!next || next.length >= before) {
+		ctx.log.debug('Context reducer shed nothing', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			messages: before,
+		})
+		return
+	}
+
+	if (!findDanglingMessages([...next]).isValid) {
+		ctx.log.warn('Context reducer split a tool pair — refusing its result', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			hint: 'use findSafeTrimIndex to move a cut off a tool_use/tool_result boundary',
+		})
+		return
+	}
+
+	messages.length = 0
+	for (const message of next) messages.push(message)
+
+	// The provider's count described the pre-reduction prompt. Same reasoning
+	// as the structured path: leaving it would have the next trigger check
+	// compare an old size against the new history and reduce again.
+	ctx.runMgr.clearLastPromptTokens?.()
+
+	ctx.log.info('Context reduced', {
+		runId: ctx.runMgr.id,
+		reason: reduction.reason,
+		oldMessageCount: before,
+		newMessageCount: messages.length,
+		charsShed: beforeChars - totalChars(messages),
+	})
+}
+
 export async function runCompactionCheck(
 	ctx: IterationContext,
 	options?: { force?: boolean },
@@ -210,9 +285,6 @@ export async function runCompactionCheck(
 	if (!config) return
 	if (config.strategy === 'disabled') return
 
-	const manager = ctx.workingStateManager
-	if (!manager) return
-
 	const measured = measureContext(ctx)
 	const estimatedTokens = measured.tokens
 
@@ -232,6 +304,29 @@ export async function runCompactionCheck(
 	// rejected the prompt, which is stronger evidence than any estimate.
 	if (!options?.force && usage < config.triggerThreshold) return
 
+	// A reducer, when the run has one, OWNS reduction — the structured pass
+	// below does not also run. `strategy: 'sliding-window'` resolves to the
+	// built-in one; a host-supplied reducer outranks the strategy entirely,
+	// because someone who wrote a reducer has said what they want more
+	// specifically than an enum can.
+	const reducer =
+		ctx.contextReducer ??
+		(config.strategy === 'sliding-window' ? createSlidingWindowReducer() : undefined)
+	if (reducer) {
+		await applyReducer(ctx, reducer, {
+			messages: ctx.runMgr.messages,
+			reason: options?.force ? 'overflow' : 'threshold',
+			estimatedTokens,
+			contextWindowTokens: budget,
+			model: ctx.runConfig.model,
+			keepRecentMessages: config.keepRecentMessages,
+		})
+		return
+	}
+
+	const manager = ctx.workingStateManager
+	if (!manager) return
+
 	ctx.log.info('Compaction threshold reached — compacting context', {
 		runId: ctx.runMgr.id,
 		contextTokens: estimatedTokens,
@@ -380,7 +475,13 @@ export async function runCompactionCheck(
 			ctx.provider,
 			config,
 			(usage) => ctx.runMgr.accumulateUsage(usage),
-			ctx.runConfig.model,
+			// The one model call a run makes that the user never asked for. It
+			// reads a transcript and writes a summary, which is the cheapest
+			// thing a small model does well, and it fires on exactly the long
+			// runs where the primary model is most expensive. `taskRouter` had
+			// been accepted, validated and threaded through four types since it
+			// was added, and nothing ever consulted it.
+			resolveTaskModel('compaction', ctx.taskRouter, ctx.runConfig.model),
 		)
 	} else {
 		compactedContent = serializeState(manager.getState())