@namzu/sdk 52.0.0 → 52.1.0

package/src/runtime/query/index.ts

@@ -104,6 +104,13 @@ import { AwaitedJobs } from '../jobs/awaited-jobs.js'
 import type { BackgroundJobRegistry } from '../jobs/registry.js'
 import { catchUpFromCursor, settlePreStartCancellation } from './cancelled-before-start.js'
 import { CheckpointManager, findPendingCheckpoint } from './checkpoint.js'
+import {
+	type DeferredSandbox,
+	type SandboxAcquireMode,
+	type SandboxAcquisitionStop,
+	SandboxAcquisitionStopped,
+	createDeferredSandbox,
+} from './deferred-sandbox.js'
 import type { EventTranslator } from './events.js'
 import { finalizeTurn } from './finalize-turn.js'
 import { GuardCoordinator } from './guard.js'
@@ -1825,6 +1832,10 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			})
 
 			let sandbox: Sandbox | undefined
+			/** Set only for `sandbox.acquire: 'concurrent' | 'on-first-use'`. */
+			let deferredSandbox: DeferredSandbox | undefined
+			/** How a stopped acquisition settles the turn; set where the provider is known. */
+			let applyAcquisitionStop: (acquisition: SandboxAcquisitionStop) => void = () => {}
 			// Decided during checkpoint restore, executed after the sandbox
 			// exists — the approved tools may well need it.
 			let pendingResume: PendingResumePlan | null = null
@@ -2300,6 +2311,20 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 					yield* eventTranslator.drainPending()
 				}
 
+				// Checked whether or not a provider is present: a host that mistypes the
+				// option should hear about it before it wires a provider in, not after.
+				const acquireMode: SandboxAcquireMode = turnConfig.sandbox?.acquire ?? 'eager'
+				if (
+					acquireMode !== 'eager' &&
+					acquireMode !== 'concurrent' &&
+					acquireMode !== 'on-first-use'
+				) {
+					throw new NamzuError({
+						code: 'invalid_config',
+						message: `sandbox.acquire must be 'eager', 'concurrent' or 'on-first-use'; received ${String(acquireMode)}`,
+						details: { acquire: String(acquireMode) },
+					})
+				}
 				// --- Sandbox lifecycle: create before iteration loop ---
 				if (params.sandboxProvider) {
 					const rootAtCwd = turnConfig.sandbox?.workspace === 'working-directory'
@@ -2331,40 +2356,60 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 							},
 						})
 					}
-					const acquisition = await acquireSandbox({
-						provider: params.sandboxProvider,
-						config: {
-							...(rootAtCwd ? { workingDirectory: ctx.cwd } : {}),
-							...(rootAtCwd && params.additionalDirectories?.length
-								? { additionalDirectories: params.additionalDirectories }
-								: {}),
-							timeoutMs: turnConfig.sandbox?.timeoutMs,
-							memoryLimitMb: turnConfig.sandbox?.memoryLimitMb,
-							maxProcesses: turnConfig.sandbox?.maxProcesses,
-						},
-						signal: ctx.abortController.signal,
-						timeoutMs: guard.remainingUntilTimeoutMs(),
-						teardownTimeoutMs: sandboxTeardownTimeoutMs,
-						onLateTeardown: (result) => {
-							if (result.kind === 'destroyed') {
-								ctx.log.info('Late sandbox allocation was destroyed after the turn stopped', {
+					const sandboxProvider = params.sandboxProvider
+					const startAcquisition = (signal: AbortSignal) =>
+						acquireSandbox({
+							provider: sandboxProvider,
+							config: {
+								...(rootAtCwd ? { workingDirectory: ctx.cwd } : {}),
+								...(rootAtCwd && params.additionalDirectories?.length
+									? { additionalDirectories: params.additionalDirectories }
+									: {}),
+								timeoutMs: turnConfig.sandbox?.timeoutMs,
+								memoryLimitMb: turnConfig.sandbox?.memoryLimitMb,
+								maxProcesses: turnConfig.sandbox?.maxProcesses,
+							},
+							signal,
+							timeoutMs: guard.remainingUntilTimeoutMs(),
+							teardownTimeoutMs: sandboxTeardownTimeoutMs,
+							onLateTeardown: (result) => {
+								if (result.kind === 'destroyed') {
+									ctx.log.info('Late sandbox allocation was destroyed after the turn stopped', {
+										[NAMZU.TURN_ID]: ctx.turnId,
+									})
+									return
+								}
+								ctx.log.error('Late sandbox allocation did not stop cleanly', {
 									[NAMZU.TURN_ID]: ctx.turnId,
+									...errorAttributes(result.error),
 								})
-								return
-							}
-							ctx.log.error('Late sandbox allocation did not stop cleanly', {
-								[NAMZU.TURN_ID]: ctx.turnId,
-								...errorAttributes(result.error),
-							})
-						},
-					})
-					if (acquisition.kind !== 'created') {
+							},
+						})
+					const publishSandbox = async (acquired: Sandbox): Promise<void> => {
+						sandbox = acquired
+						toolExecutor.setSandbox(acquired)
+
+						await eventTranslator.emitEvent({
+							type: 'sandbox_created',
+							turnId: ctx.turnId,
+							sandboxId: acquired.id,
+							environment: acquired.environment,
+						})
+					}
+					const logSandboxCreated = (acquired: Sandbox): void => {
+						ctx.log.info('Sandbox created for run', {
+							'namzu.sandbox.id': acquired.id,
+							'namzu.execution.environment': acquired.environment,
+							'namzu.runtime.root_dir': acquired.rootDir,
+						})
+					}
+					applyAcquisitionStop = (acquisition) => {
 						if (acquisition.createPending) {
 							ctx.log.warn(
 								'Sandbox creation was unsettled when the turn stopped; any returned handle will be released, but a remote allocation hidden behind a lost response requires provider-side reconciliation or a fleet reaper',
 								{
 									[NAMZU.TURN_ID]: ctx.turnId,
-									'namzu.sandbox.provider_id': params.sandboxProvider.id,
+									'namzu.sandbox.provider_id': sandboxProvider.id,
 								},
 							)
 						}
@@ -2374,32 +2419,40 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 							ctx.recorder.setStopReason('timeout')
 							ctx.log.warn('Sandbox creation exhausted the turn timeout', {
 								[NAMZU.TURN_ID]: ctx.turnId,
-								'namzu.sandbox.provider_id': params.sandboxProvider.id,
+								'namzu.sandbox.provider_id': sandboxProvider.id,
 								...errorAttributes(acquisition.error),
 							})
 						}
-						yield* resultAssembler.completeTurn(rootSpan)
-						// The turn HAS settled, so the outer `finally` must not read
-						// this as an abandonment — it would persist a second time.
-						settled = true
-						return await resultAssembler.finalize()
 					}
-					sandbox = acquisition.sandbox
-					toolExecutor.setSandbox(sandbox)
-
-					await eventTranslator.emitEvent({
-						type: 'sandbox_created',
-						turnId: ctx.turnId,
-						sandboxId: sandbox.id,
-						environment: sandbox.environment,
-					})
-					yield* eventTranslator.drainPending()
-
-					ctx.log.info('Sandbox created for run', {
-						'namzu.sandbox.id': sandbox.id,
-						'namzu.execution.environment': sandbox.environment,
-						'namzu.runtime.root_dir': sandbox.rootDir,
-					})
+					if (acquireMode === 'eager') {
+						const acquisition = await startAcquisition(ctx.abortController.signal)
+						if (acquisition.kind !== 'created') {
+							applyAcquisitionStop(acquisition)
+							yield* resultAssembler.completeTurn(rootSpan)
+							// The turn HAS settled, so the outer `finally` must not read
+							// this as an abandonment — it would persist a second time.
+							settled = true
+							return await resultAssembler.finalize()
+						}
+						await publishSandbox(acquisition.sandbox)
+						yield* eventTranslator.drainPending()
+						logSandboxCreated(acquisition.sandbox)
+					} else {
+						// The handle is published, and `sandbox_created` emitted, when
+						// the provider answers. Until then the executor holds tool
+						// admission on the gate, so nothing runs without it.
+						const deferred = createDeferredSandbox({
+							turnSignal: ctx.abortController.signal,
+							acquire: startAcquisition,
+							publish: async (acquired) => {
+								await publishSandbox(acquired)
+								logSandboxCreated(acquired)
+							},
+						})
+						deferredSandbox = deferred
+						toolExecutor.setSandboxGate(() => deferred.ensure())
+						if (acquireMode === 'concurrent') deferred.start()
+					}
 				}
 
 				// Before the first model call: the cheapest place to refuse, since
@@ -2525,6 +2578,14 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 
 				yield* iterationOrchestrator.runLoop()
 
+				// A turn that never needed the sandbox still settles it: a failure or
+				// a timeout ends the turn the way an eager acquisition would have, and
+				// a handle that arrives after that is released by the lifecycle.
+				if (deferredSandbox) {
+					await deferredSandbox.settle()
+					yield* eventTranslator.drainPending()
+				}
+
 				yield* finalizeTurn({
 					ctx,
 					params,
@@ -2536,6 +2597,16 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 					rootSpan,
 				})
 			} catch (err) {
+				// A deferred acquisition stopped (cancelled, or out of time) and the
+				// turn found out at its first tool call or at its end. Settled the
+				// way the eager path settles it, with nothing else to report.
+				if (err instanceof SandboxAcquisitionStopped) {
+					applyAcquisitionStop(err.acquisition)
+					yield* eventTranslator.drainPending()
+					yield* resultAssembler.completeTurn(rootSpan)
+					settled = true
+					return await resultAssembler.finalize()
+				}
 				// Another turn is active in this session: nothing of this turn was
 				// written, so there is nothing to settle. The caller gets the
 				// refusal itself.
@@ -2546,6 +2617,10 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 				yield* eventTranslator.drainPending()
 				yield* resultAssembler.handleError(err, rootSpan)
 			} finally {
+				// A pending acquisition is withdrawn and awaited first, so a handle
+				// that arrives now is either published (and released below) or
+				// handed to the late-teardown path. Nothing is left allocated.
+				await deferredSandbox?.cancel()
 				yield* releaseTurnResources({
 					ctx,
 					eventTranslator,

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

@@ -15,7 +15,7 @@ import {
 } from '../../../constants/tools/index.js'
 import { withStreamedMessageIdentity } from '../../../manager/session/streamed-message-identity.js'
 import { renderSkillsSection } from '../../../persona/assembler.js'
-import { resolveProviderCapabilities } from '../../../provider/capabilities.js'
+import { modelReadsImages, resolveProviderCapabilities } from '../../../provider/capabilities.js'
 import { collectChatCompletion } from '../../../provider/collect-chat-completion.js'
 import { renderToolSchema } from '../../../registry/tool/schema.js'
 import { formatCompletionNotification } from '../../../scheduler/completion-inbox.js'
@@ -54,6 +54,7 @@ import { stableDigest } from '../../../utils/hash.js'
 import { generateMessageId } from '../../../utils/id.js'
 import { parseStructuredResultJson } from '../../../utils/structured-result-json.js'
 import { createCallbackInference } from '../callback-inference.js'
+import { SandboxAcquisitionStopped } from '../deferred-sandbox.js'
 import { deliverDurableInbound } from '../durable-inbound.js'
 import type { ToolCallOutcome } from '../executor.js'
 import { projectObservationContext } from '../observation-context.js'
@@ -80,17 +81,27 @@ import { runAdvisoryPhase } from './phases/advisory.js'
 import { runIterationCheckpoint } from './phases/checkpoint.js'
 import { compactionBreaker } from './phases/compaction-breaker.js'
 import {
+	AUTOMATIC_COMPACTION_FAILED,
+	OVERFLOW_RELIEF_LIMIT,
 	activeContextWindow,
+	clearCompactionErrorNote,
+	compactionErrorNote,
 	measureContext,
 	relieveOverflow,
 	runCompactionCheck,
+	stopOnRefill,
 } from './phases/compaction.js'
 import { runHandoffPause } from './phases/handoff.js'
 import type { IterationContext } from './phases/index.js'
 import { runPlanGate } from './phases/plan.js'
 import { runToolReview } from './phases/tool-review.js'
 import { refreshWorkingMemory, splitWorkingMemoryForRequest } from './phases/working-memory.js'
-import { streamWithProviderRejectedImageRecovery } from './provider-rejected-image.js'
+import {
+	type TextOnlyModelRecovery,
+	type TextOnlyModelRefusal,
+	streamWithProviderRejectedImageRecovery,
+} from './provider-rejected-image.js'
+import { type MediaRemoval, RequestRepair } from './request-repair.js'
 import {
 	type StepShaping,
 	appendWorkContext,
@@ -141,6 +152,11 @@ const CLOSING_RESPONSE_GUIDANCE =
 
 export { awaitedJobGraceMs, settleGraceMs } from './outstanding-work.js'
 
+/** One provider's model, as {@link IterationOrchestrator} remembers it. */
+function textOnlyKey(providerId: string, model: string): string {
+	return `${providerId}\u0000${model}`
+}
+
 export class IterationOrchestrator {
 	private ctx: IterationContext
 	private advisoryTurn:
@@ -188,6 +204,73 @@ export class IterationOrchestrator {
 	}
 	/** Rich tool blocks already reported; durable history is scanned every turn. */
 	private readonly warnedRichToolResults = new Set<string>()
+	/** What this run has learned about requests its provider rejects as invalid, and how to repair them. */
+	private readonly requestRepair = new RequestRepair({
+		debug: (message) => this.ctx.log.debug(message),
+		onMediaRemoved: (removal) => this.noteMediaRemoved(removal),
+		servedBy: () => this.ctx.servingMember?.(),
+	})
+	/**
+	 * Provider and model pairs that refused a request for holding an image; they
+	 * get none for the rest of the run. Keyed by both: one model id can be served
+	 * by two members of a fallback chain, and only the one that refused is known.
+	 */
+	private readonly textOnlyModels = new Set<string>()
+
+	/**
+	 * The member a request for `model` goes to first. A fallback chain keeps
+	 * serving from the member it last moved to, so that member, not the head,
+	 * is the one whose reading of images counts.
+	 */
+	private servingModel(model: string): { readonly providerId: string; readonly model: string } {
+		const serving = this.ctx.servingMember?.()
+		return {
+			providerId: serving?.providerId ?? this.ctx.provider.id,
+			model: serving?.model ?? model,
+		}
+	}
+
+	/** Whether a request for `model` may carry images: the driver's catalogue and this run's own evidence agree. */
+	private modelReadsImages(model: string): boolean {
+		const serving = this.servingModel(model)
+		return (
+			!this.textOnlyModels.has(textOnlyKey(serving.providerId, serving.model)) &&
+			modelReadsImages(this.ctx.provider, model)
+		)
+	}
+
+	/** What a request for `model` does when its model turns out to read text only. */
+	private textOnlyRecovery(model: string): TextOnlyModelRecovery {
+		return {
+			servedBy: () => this.servingModel(model),
+			onAccepted: (refused) => this.noteTextOnlyModel(refused),
+		}
+	}
+
+	/**
+	 * A provider refused a request for holding an image its model cannot read, and
+	 * the retry without images was accepted. Stop sending images to it, and say so
+	 * once, so the host can remember the model beyond this run.
+	 */
+	private async noteTextOnlyModel(refused: TextOnlyModelRefusal): Promise<void> {
+		const key = textOnlyKey(refused.providerId, refused.model ?? '')
+		if (this.textOnlyModels.has(key)) return
+		this.textOnlyModels.add(key)
+		const { providerId, model } = refused
+		this.ctx.log.warn('Capability mismatch: the model cannot read images', {
+			[GENAI.SYSTEM]: providerId,
+			[GENAI.REQUEST_MODEL]: model ?? '',
+		})
+		await this.ctx.emitEvent?.({
+			type: 'capability_warning',
+			turnId: this.ctx.recorder.turnId,
+			capability: 'vision',
+			contentSource: 'history',
+			providerId,
+			...(model !== undefined ? { model } : {}),
+			message: `Model '${model ?? 'unknown'}' on provider '${providerId}' refused a request that held an image, so images are left out of its requests. They stay in the conversation and are sent again to a model that reads them.`,
+		})
+	}
 	/**
 	 * The previous iteration held a `stopWhen` decision open for a worker.
 	 *
@@ -442,16 +525,19 @@ export class IterationOrchestrator {
 		// checkpoint names the message the turn is answering.
 		await this.ctx.checkpointMgr.markLoopStart?.(recorder)
 
-		// One context-overflow relief per *stuck point*, not per turn.
+		// Context-overflow relief is a two-rung ladder per *stuck point*, not per
+		// turn, as in the reference terminal (at most two reactive compactions per
+		// overflow): the first relief, then one deeper pass if the retry still
+		// overflows.
 		//
-		// The latch exists so that a second overflow immediately after a
-		// successful compaction — meaning the prompt is irreducible — stops
-		// instead of looping. It was never meant to disarm the mechanism for
-		// the rest of the turn, which is what a turn-scoped flag did: one
-		// relief at iteration 3 left iteration 40 to die on an overflow with
-		// obvious moves left. It is cleared by a turn that actually
-		// succeeded, which is the evidence that the turn is no longer stuck.
-		let overflowRelieved = false
+		// The limit exists so that an overflow that survives both rungs — an
+		// irreducible prompt — stops instead of looping. It was never meant to
+		// disarm the mechanism for the rest of the turn, which is what a
+		// turn-scoped flag did: one relief at iteration 3 left iteration 40 to die
+		// on an overflow with obvious moves left. The count is cleared by a turn
+		// that actually succeeded, which is the evidence that the turn is no
+		// longer stuck.
+		let overflowReliefs = 0
 		// The output cap a provider told us fits beside this prompt. One request's
 		// worth: it is cleared by a call that went through.
 		let outputCapOverride: number | undefined
@@ -814,6 +900,7 @@ export class IterationOrchestrator {
 						this.projectObservations(requestHistory),
 						this.ctx.turnConfig.maxRequestRichContentBytes ??
 							DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+						{ imagesReadable: this.modelReadsImages(stepModel) },
 					)
 					appendWorkContext(shaping, messages, iterationNum, step)
 					if (closingDirective) messages.push(closingDirective)
@@ -989,6 +1076,8 @@ export class IterationOrchestrator {
 						stepMessageId,
 						{
 							onAccepted: (identity) => this.acceptProviderRejectedImage(identity),
+							textOnly: this.textOnlyRecovery(stepModel),
+							repair: this.requestRepair,
 						},
 						Boolean(
 							this.ctx.reviewAnswer || this.ctx.structuredOutput?.review || this.ctx.advisoryCtx,
@@ -1042,7 +1131,8 @@ export class IterationOrchestrator {
 
 					// The turn went through, so the turn is not sitting on an
 					// irreducible prompt any more. Re-arm relief for the next one.
-					overflowRelieved = false
+					overflowReliefs = 0
+					clearCompactionErrorNote(this.ctx)
 					outputCapOverride = undefined
 					if (response.finishReason !== 'length') this.outputContinuations = 0
 
@@ -1895,6 +1985,12 @@ export class IterationOrchestrator {
 					yield* this.ctx.drainPending()
 				} catch (err) {
 					const cancelled = this.ctx.abortController.signal.aborted
+					// A deferred sandbox that was cancelled or ran out of time. The
+					// turn settles it as `cancelled` / `timeout` in `query()`, which is
+					// not a failure of this iteration: it is recorded the way a turn
+					// stopped by its own abort or timeout is (a cancelled step, no
+					// error span), so the ledger and the stop reason agree.
+					const sandboxStopped = err instanceof SandboxAcquisitionStopped
 
 					// This iteration gets a step too, and it is the one the
 					// argument three hundred lines above was actually about.
@@ -1955,12 +2051,13 @@ export class IterationOrchestrator {
 							startedAt: stepStartedAt,
 							usageBefore,
 							costBefore,
-							unfinished: cancelled
-								? { finishReason: 'cancelled' }
-								: {
-										finishReason: 'error',
-										failure: describeStepFailure(err, this.ctx.provider.id),
-									},
+							unfinished:
+								cancelled || sandboxStopped
+									? { finishReason: 'cancelled' }
+									: {
+											finishReason: 'error',
+											failure: describeStepFailure(err, this.ctx.provider.id),
+										},
 						})
 					}
 
@@ -2020,22 +2117,58 @@ export class IterationOrchestrator {
 					}
 
 					if (
-						!overflowRelieved &&
 						!(err instanceof AnswerReviewFailure) &&
 						classifyProviderError(err, this.ctx.provider.id).code === 'context_length_exceeded'
 					) {
-						overflowRelieved = true
-						const shed = await relieveOverflow(this.ctx)
+						// The rapid-refill check comes first, before the first reactive relief
+						// of an overflow, as in the reference terminal. A relief that follows
+						// the previous compaction within the refill window counts toward the
+						// limit, so a tool that re-fills the window every time it is called
+						// stops the turn instead of being cleared and called again without end.
+						// The deeper rung of the same overflow is not counted again.
+						if (overflowReliefs === 0 && (await stopOnRefill(this.ctx))) {
+							if (iterationActivity) {
+								this.ctx.activityStore.fail(iterationActivity.id, toErrorMessage(err))
+							}
+							if (this.stopForCompactionBreaker()) break
+						}
+						// A rung that sheds too little to change the verdict is not worth a
+						// provider call; climb to the next one at once.
+						let shed = false
+						while (!shed && overflowReliefs < OVERFLOW_RELIEF_LIMIT) {
+							overflowReliefs++
+							shed = await relieveOverflow(this.ctx, { deeper: overflowReliefs > 1 })
+						}
 						if (shed) {
+							// Clearing results is a compaction too: only summaries and reducers
+							// recorded themselves, so a clear-only relief was invisible to the
+							// breaker.
+							compactionBreaker(this.ctx)?.recordCompaction(iterationNum)
 							this.ctx.log.info('Retrying the turn after relieving a context overflow', {
 								[NAMZU.TURN_ID]: recorder.turnId,
 								[NAMZU.ITERATION]: iterationNum,
+								'namzu.runtime.relief_rung': overflowReliefs,
 							})
 							if (iterationActivity) {
 								this.ctx.activityStore.complete(iterationActivity.id)
 							}
 							continue
 						}
+						// Out of rungs. The conversation is kept; say why compaction could not
+						// make room when it errored, as the reference does.
+						const cause = compactionErrorNote(this.ctx)
+						if (cause !== undefined && err instanceof Error) {
+							try {
+								err.message = `${err.message}${AUTOMATIC_COMPACTION_FAILED}${cause}`
+							} catch {
+								// A frozen error keeps its own message; the cause stays in the log.
+							}
+						}
+					}
+
+					if (sandboxStopped) {
+						if (iterationActivity) this.ctx.activityStore.complete(iterationActivity.id)
+						throw err
 					}
 
 					if (iterationActivity) {
@@ -2643,6 +2776,32 @@ export class IterationOrchestrator {
 			.some((t) => t.state !== 'completed' && t.state !== 'failed' && t.state !== 'canceled')
 	}
 
+	/** Media the provider could not process was left out of a request that then went through. */
+	private async noteMediaRemoved(removal: MediaRemoval): Promise<void> {
+		this.ctx.log.warn('Media the provider rejected was left out of the request', {
+			[GENAI.SYSTEM]: this.ctx.provider.id,
+			'namzu.request.media_removed': removal.count,
+		})
+		const noun = removal.count === 1 ? 'a file' : `${removal.count} files`
+		const it = removal.count === 1 ? 'it' : 'they'
+		await this.ctx.emitEvent?.({
+			type: 'capability_warning',
+			turnId: this.ctx.recorder.turnId,
+			capability: removal.kind === 'document' ? 'documents' : 'vision',
+			// The person's own latest attachment is named as such; a count limit is
+			// not a fault in any file.
+			contentSource: removal.current
+				? 'media-removed-current'
+				: removal.limit
+					? 'media-limit'
+					: 'media-removed',
+			providerId: this.ctx.provider.id,
+			message: removal.limit
+				? `The conversation holds more files than the provider accepts at once, so ${noun} (the oldest) ${removal.count === 1 ? 'was' : 'were'} left out of the request. The conversation still holds ${it}.`
+				: `The provider could not process ${noun}${removal.current ? ' attached to your latest message' : ' in this conversation'}, so ${it} ${removal.count === 1 ? 'was' : 'were'} left out of the request. The conversation still holds ${it}.`,
+		})
+	}
+
 	private async acceptProviderRejectedImage(identity: RequestImageIdentity): Promise<void> {
 		const repaired = markProviderRejectedImage(this.ctx.recorder.messages, identity)
 		if (repaired.count === 0) {
@@ -2700,6 +2859,7 @@ export class IterationOrchestrator {
 			const finalMessages = projectRequestRichContent(
 				this.projectObservations(finalHistory),
 				this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+				{ imagesReadable: this.modelReadsImages(model) },
 			)
 			appendWorkContext(this.stepShaping(), finalMessages, this.steps.length + 1, { model })
 			// The closing directive is the last thing the model reads: after
@@ -2746,8 +2906,13 @@ export class IterationOrchestrator {
 				signal: this.ctx.abortController.signal,
 			} satisfies import('../../../types/provider/index.js').ChatCompletionParams
 			const response = await collectChatCompletion(
-				streamWithProviderRejectedImageRecovery(this.ctx.provider, finalParams, (identity) =>
-					this.acceptProviderRejectedImage(identity),
+				streamWithProviderRejectedImageRecovery(
+					this.ctx.provider,
+					finalParams,
+					(identity) => this.acceptProviderRejectedImage(identity),
+					undefined,
+					this.textOnlyRecovery(model),
+					this.requestRepair,
 				),
 			)
 

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

@@ -3,9 +3,10 @@
  *
  * - Three failures in a row (a pass that ran and shed nothing): every one of
  *   them paid for a summary or a reducer call and left the history as it was,
- *   so a fourth would do the same. Compaction is skipped from then on and the
- *   turn carries on; a pass the provider forces by rejecting the prompt is not
- *   gated.
+ *   so a fourth would do the same. Proactive compaction is skipped from then on
+ *   and the turn carries on, silently as far as the person is concerned (a log
+ *   line and a `breaker_open` event, no sentence); a pass the provider forces
+ *   by rejecting the prompt is not gated, so the reactive ladder still runs.
  * - Three compactions in a row, each followed by the context filling back up
  *   within three iterations: something in the loop (a huge file read, a tool
  *   that prints without limit) refills the window faster than any summary can
@@ -27,12 +28,13 @@ export const COMPACTION_REFILL_ITERATIONS = 3
 /** Consecutive refills that stop the turn. */
 export const COMPACTION_REFILL_LIMIT = 3
 
-/** One short line, shown once, when the turn stops on refills. */
+/**
+ * One short line, shown once, when the turn stops on refills. It names the
+ * cause and a step that keeps the conversation: the reference terminal also
+ * offers to start over here, and Namzu never does.
+ */
 export const COMPACTION_REFILL_MESSAGE =
-	'The context filled up again right after being compacted, three times in a row. A file or tool output is probably too big for the window: read it in smaller parts, or start fresh with /clear.'
-/** One short line, shown once, when compaction stops after failures. */
-export const COMPACTION_FAILURE_MESSAGE =
-	'Automatic compaction stopped after three failed attempts. Run /compact yourself, or start fresh with /clear.'
+	'The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large for the context window. Try reading it in smaller parts.'
 
 export class CompactionBreaker {
 	private failures = 0