@namzu/sdk 61.3.0 → 62.0.0

package/src/provider/retry.ts

@@ -384,6 +384,14 @@ export function withProviderRetry(
 					supportsImageInputFor: (model: string) => provider.supportsImageInputFor?.(model) ?? true,
 				}
 			: {}),
+		...(provider.acceptsForcedToolChoiceFor
+			? {
+					acceptsForcedToolChoiceFor: (
+						model: string,
+						thinking?: Parameters<NonNullable<LLMProvider['acceptsForcedToolChoiceFor']>>[1],
+					) => provider.acceptsForcedToolChoiceFor?.(model, thinking) ?? true,
+				}
+			: {}),
 		...(provider.reasoningEffortLevelsFor
 			? {
 					reasoningEffortLevelsFor: (

package/src/provider/step-stopped.ts

@@ -0,0 +1,27 @@
+/**
+ * The reason a step is stopped on purpose, by the loop that is reading it.
+ *
+ * A step that has spent its whole reasoning allowance is cut short: the loop
+ * stops reading the stream and aborts the request it opened. That abort is the
+ * loop's own decision, not a caller's stop and not a transport failure, so it
+ * carries this class as its reason. A provider wrapper that sees an aborted
+ * request can tell the two apart with {@link isStepStopped} and must not retry
+ * it, fail over from it, or report it as an error.
+ */
+export class StepStopped extends Error {
+	override readonly name = 'StepStopped'
+
+	constructor() {
+		super('the step was stopped by the loop that was reading it')
+	}
+}
+
+/** Whether an abort reason, or an error that carries one, is a deliberate step stop. */
+export function isStepStopped(value: unknown): value is StepStopped {
+	return value instanceof StepStopped
+}
+
+/** Whether a request signal was aborted by a deliberate step stop. */
+export function stepWasStopped(signal: AbortSignal | undefined): boolean {
+	return signal?.aborted === true && isStepStopped(signal.reason)
+}

package/src/provider/token-budget.ts

@@ -6,6 +6,7 @@ import { ProviderError, classifyProviderError } from '../types/provider/errors.j
 import type { LLMProvider, StreamChunk } from '../types/provider/index.js'
 import { cancelCauseOf } from '../types/session/cancel-cause.js'
 import { isProviderRequestError } from './errors.js'
+import { isStepStopped } from './step-stopped.js'
 
 export class TokenBudgetAdmissionError extends ProviderError {
 	constructor() {
@@ -117,6 +118,7 @@ export function withTokenBudget(provider: LLMProvider, budget: SessionTokenBudge
 				}
 				if (Object.keys(chunk.delta).length > 0) outputObserved = true
 				if (typeof chunk.delta.content === 'string') streamedChars += chunk.delta.content.length
+				streamedChars += chunk.delta.reasoning?.text?.length ?? 0
 				if (chunk.error) throw new Error(chunk.error)
 				yield chunk
 			}
@@ -161,10 +163,13 @@ export function withTokenBudget(provider: LLMProvider, budget: SessionTokenBudge
 				// because of work somebody chose to stop. The estimate can under-count
 				// what the provider billed for the part it never reported; a failure
 				// that was not a cancellation keeps its marker as before.
+				//
+				// A step the loop stopped on purpose (it reached its reasoning cap) is
+				// closed the same way: nobody chose to lose track of that spend.
 				if (
 					usage === undefined &&
 					signal?.aborted === true &&
-					cancelCauseOf(signal.reason) === 'user' &&
+					(cancelCauseOf(signal.reason) === 'user' || isStepStopped(signal.reason)) &&
 					!uncertainRetry
 				) {
 					const prompt = estimateMessagesTokens(params.messages)

package/src/public-runtime.ts

@@ -1498,6 +1498,7 @@ export {
 	isReviewExempt,
 	isReviewMode,
 	modeReviewsAllowedCalls,
+	mustAskPerson,
 } from './runtime/query/review-policy.js'
 // The model that decides, in the `classify` review mode, what a person would
 // otherwise be asked. See `runtime/query/auto-review/`.
@@ -1529,8 +1530,6 @@ export {
 	PromptContributionRegistry,
 	SKILLS_CONTRIBUTION_ID,
 	codingAgentDoctrineContribution,
-	createResidentStepContributions,
-	createResidentStepContext,
 	skillsContribution,
 } from './prompt/index.js'
 
@@ -1671,6 +1670,10 @@ export type { SingleHandoffDeps } from './session/handoff/single.js'
 export type { InterventionChainLoader } from './session/intervention/prev-artifact.js'
 export type {
 	ActionInput,
+	ComputerUseAdvice,
+	ComputerUseAdvisor,
+	ComputerUseAdvisorCandidate,
+	ComputerUseAdvisorRequest,
 	ComputerUseTool,
 	ComputerUseToolOptions,
 	ImageSize,
@@ -1690,23 +1693,13 @@ export {
 	diffRequestContext,
 } from './runtime/query/request-context.js'
 
-export {
-	DiskResidentStore,
-	ResidentConflictError,
-} from './manager/resident/store.js'
-export { runResident, stepResident } from './manager/resident/loop.js'
-export { DiskResidentAgenda } from './manager/resident/agenda.js'
-export { inspectResidentConsumption } from './manager/resident/consumption.js'
-export { ResidentHost } from './manager/resident/host.js'
-
-export { createResidentSelector } from './manager/resident/initiative.js'
-export { validateResidentProposal } from './manager/resident/proposal.js'
-
-export { deliverResidentMessage } from './manager/resident/outbox.js'
-export { createResidentDeliveryWindow } from './manager/resident/delivery-window.js'
-
 export { hashLearningSkill, projectLearning } from './learning/skill.js'
 export { runLearningCycle } from './learning/cycle.js'
+export {
+	DiskLearningGuidance,
+	LearningGuidanceConflictError,
+	earlierGuidanceDirectory,
+} from './learning/guidance.js'
 export {
 	LEARNING_FLOOR_COMPONENTS,
 	LEARNING_SURFACE_KINDS,
@@ -1740,23 +1733,12 @@ export {
 	classifyEvidenceSource,
 	EVIDENCE_RECORD_GUIDANCE,
 } from './store/evidence/source-kind.js'
-export { createResidentToolEvidenceSource } from './manager/resident/tool-evidence.js'
-
-export { createResidentEvidenceRecallStep } from './manager/resident/evidence-recall.js'
 
 export {
 	SqliteLearningStore,
 	runStoredLearningCycle,
 	runStoredLearningFromObservations,
 } from './learning/store.js'
-export {
-	SqliteResidentLearningStore,
-	hashResidentSkill,
-	projectResidentLearning,
-	runResidentLearningCycle,
-	runStoredResidentLearningCycle,
-	runStoredResidentLearningFromObservations,
-} from './learning/deprecated.js'
 
 // ─── sessions, turns and the session log ─────────────────────────────────
 //

package/src/public-tools.ts

@@ -41,7 +41,6 @@ export type { UntrustedEnvelope, WrapUntrustedOptions } from './tools/untrusted-
 // ─── Built-in tools ──────────────────────────────────────────────────────
 
 export { getBuiltinTools } from './tools/builtins/index.js'
-export { buildResidentHistoryTools } from './tools/resident-history.js'
 // A host compiling operator permissions has a tool name and needs an argument
 // to attach a pattern to. Without one it can only match against the serialised
 // input, which is how an `allow` for `git status*` came to approve
@@ -270,7 +269,5 @@ export {
 	seedObservationLedger,
 } from './runtime/query/file-evidence-seed.js'
 
-export { buildResidentToolEvidenceTools } from './tools/resident-tool-evidence.js'
-
 export { createPalMessagingTools } from './pals/communication/tools.js'
 export { createPalOperatorMessagingTools } from './pals/communication/operator.js'

package/src/public-types.ts

@@ -457,6 +457,7 @@ export type {
 } from './runtime/query/auto-review/index.js'
 
 export type {
+	MustAskCall,
 	ReviewExemption,
 	ReviewMode,
 	ReviewPolicyOptions,
@@ -471,9 +472,6 @@ export type {
 	PromptContribution,
 	PromptContributionContext,
 	PromptPlacement,
-	ResidentStepPromptOptions,
-	ResidentStepContextOptions,
-	ResidentStepContextBundle,
 } from './prompt/index.js'
 
 export type {
@@ -532,89 +530,6 @@ export type {
 	RequestContextChange,
 } from './runtime/query/request-context.js'
 
-export type {
-	ResidentDecision,
-	ResidentState,
-	ResidentStore,
-} from './manager/resident/store.js'
-export type {
-	ResidentActivityScope,
-	ResidentAdmission,
-	ResidentSettlement,
-	ResidentActivityOptions,
-	ResidentActivityPage,
-	ResidentActivitySource,
-} from './manager/resident/activity.js'
-export type {
-	ResidentConsumptionReceipt,
-	ResidentConsumptionResolver,
-	ResidentConsumptionOptions,
-	ResidentConsumptionAttempt,
-	ResidentConsumptionReport,
-} from './manager/resident/consumption.js'
-export type {
-	ResidentHistoryScope,
-	ResidentHistoryAddress,
-	ResidentHistoryMatch,
-	ResidentHistorySearchOptions,
-	ResidentHistorySearchResult,
-	ResidentHistoryReadOptions,
-	ResidentHistoryText,
-	ResidentHistoryReadResult,
-	ResidentHistorySource,
-} from './manager/resident/history.js'
-export type {
-	ResidentStep,
-	ResidentStepResult,
-	ResidentLoopOptions,
-} from './manager/resident/loop.js'
-export type { ResidentExecutionStore } from './manager/resident/store.js'
-export type {
-	ResidentAgendaState,
-	ResidentAgendaStore,
-	ResidentPursuit,
-} from './manager/resident/agenda.js'
-export type {
-	ResidentHostResult,
-	ResidentHostRunOptions,
-	ResidentPursuitStep,
-} from './manager/resident/host.js'
-
-export type {
-	ResidentObservation,
-	ResidentFeedback,
-	ResidentSelectionConfig,
-	ResidentCandidate,
-	ResidentSelection,
-	ResidentSelector,
-} from './manager/resident/initiative.js'
-export type {
-	ResidentHostOptions,
-	ResidentObserver,
-} from './manager/resident/host.js'
-export type {
-	ResidentProposal,
-	ResidentProposalLimits,
-	ResidentProposalOrigin,
-} from './manager/resident/proposal.js'
-
-export type { ResidentMessageFactory } from './manager/resident/host.js'
-export type {
-	ResidentMessageInput,
-	ResidentOutboxMessage,
-	ResidentDeliveryOutcome,
-	ResidentOutboxStore,
-	ResidentDeliveryGate,
-	ResidentMessageTransport,
-	ResidentDeliveryOptions,
-	ResidentDeliveryResult,
-} from './manager/resident/outbox.js'
-export type { ResidentDeliveryWindowConfig } from './manager/resident/delivery-window.js'
-
-export type {
-	ResidentStepContext,
-	ResidentContextualStep,
-} from './manager/resident/host.js'
 export type {
 	LearningEvidence,
 	LearningSkillCandidate,
@@ -639,6 +554,10 @@ export type {
 	LearningCycleOptions,
 	LearningCycleResult,
 } from './learning/cycle.js'
+export type {
+	DiskLearningGuidanceOptions,
+	LearningGuidanceState,
+} from './learning/guidance.js'
 
 export type {
 	LearningModel,
@@ -669,13 +588,6 @@ export type {
 	LearningLeakSubject,
 } from './learning/leak-tripwire.js'
 
-export type {
-	ResidentArchiveRequest,
-	ResidentArchiveEntry,
-	ResidentArchivePage,
-	ResidentArchiveListOptions,
-} from './manager/resident/agenda.js'
-
 export type {
 	SessionEvidenceScope,
 	SessionEvidenceSourceOptions,
@@ -692,18 +604,7 @@ export type {
 	SessionTextEvidenceSource,
 } from './store/evidence/types.js'
 export type { EvidenceRecordKind } from './store/evidence/source-kind.js'
-export type {
-	ResidentToolEvidenceScope,
-	ResidentSettledInvocation,
-	ResidentToolEvidenceOptions,
-	ResidentToolEvidenceSearchOptions,
-	ResidentToolEvidenceSearchResult,
-	ResidentToolEvidenceReadOptions,
-	ResidentToolEvidenceReadResult,
-	ResidentToolEvidenceSource,
-} from './manager/resident/tool-evidence.js'
 
-export type { ResidentEvidenceRecallOptions } from './manager/resident/evidence-recall.js'
 export type {
 	JsonClaimValue,
 	JsonClaimRequirement,
@@ -871,36 +772,3 @@ export type {
 } from './pals/activity/subscription-policy.js'
 export type { PalActivitySubscriptionRunnerOptions } from './pals/activity/subscriptions.js'
 export type { PalActivityCausalityOptions } from './pals/activity/causality.js'
-
-// Deprecated resident-prefixed names, kept until the next major.
-export type {
-	ResidentLearningEvidence,
-	ResidentSkillCandidate,
-	ResidentLearnedSkill,
-	ResidentLearningState,
-	ResidentProfileUpdate,
-	ResidentSkillEvaluation,
-	ResidentLearningProjectionOptions,
-	ResidentLearningSource,
-	ResidentLearningProjection,
-	ResidentLearningStage,
-	ResidentLearningReceipt,
-	ResidentLearningConsumption,
-	ResidentLearningCycleEvent,
-	ResidentLearningCycleContext,
-	ResidentLearningGenerationContext,
-	ResidentLearningExplorationContext,
-	ResidentLearningExploration,
-	ResidentLearningEvaluationContext,
-	ResidentLearningCycleOptions,
-	ResidentLearningCycleResult,
-	SqliteResidentLearningStoreOptions,
-	ResidentLearningArtifact,
-	ResidentLearningRecordedUsage,
-	ResidentLearningCycleSummary,
-	ResidentLearningDiscoveryOptions,
-	ResidentLearningDiscoveryResult,
-	ResidentLearningObservation,
-	ResidentLearningObservationRecord,
-	ResidentLearningTarget,
-} from './learning/deprecated.js'

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

@@ -42,7 +42,7 @@ import {
 	createToolMessage,
 } from '../../../types/message/index.js'
 import { classifyProviderError, readOutputOverflow } from '../../../types/provider/errors.js'
-import type { ChatCompletionResponse } from '../../../types/provider/index.js'
+import type { ChatCompletionResponse, ReasoningEffort } from '../../../types/provider/index.js'
 import type { AnswerReview, AnswerReviewContext } from '../../../types/session/answer-review.js'
 import type {
 	SessionEvent,
@@ -75,6 +75,15 @@ import {
 } from '../request-rich-content.js'
 import { withoutVoidAssistantTurns } from '../request-void-turns.js'
 import { formatSteeringNote, isOperatorUserMessage } from '../steering.js'
+import { COMPLETION_AUDIT_MESSAGE, CompletionAudit } from '../turn/completion-audit.js'
+import {
+	FORCED_STEP_MESSAGE,
+	REASONING_CAPPED_MESSAGE,
+	REASONING_ONLY_MESSAGE,
+	StallMonitor,
+	callChangedState,
+	reasoningCapChars,
+} from '../turn/stall-monitor.js'
 import { effortForModel } from './effort-clamp.js'
 import { parseNativeCandidate } from './native-output.js'
 import {
@@ -119,6 +128,9 @@ import {
 } from './step-shaping.js'
 import { streamProviderTurn } from './stream-turn.js'
 
+/** Capped steps in a row after which the per-step cap stops applying for the turn's next step. */
+const MAX_CAPPED_STREAK = 3
+
 type ReviewRequest = Pick<AnswerReviewContext, 'requestMessages' | 'latestUserMessage'>
 
 /** A host reviewer is not the model transport, even when its cause is an HTTP failure. */
@@ -299,6 +311,16 @@ export class IterationOrchestrator {
 	private stopDeferredForOutstandingWork = false
 	/** Nudges sent since the model last finished a call without hitting its output cap. */
 	private outputContinuations = 0
+	/** Watches the turn's steps for reasoning that piles up while nothing changes. */
+	private readonly stallMonitor?: StallMonitor
+	/** Holds the turn back once when it changed files and checked nothing afterwards. */
+	private readonly completionAudit?: CompletionAudit
+	/** The next step must call a tool, at low effort: set by the stall monitor or a capped step. */
+	private forceActionNextStep = false
+	/** Steps in a row cut at the per-step reasoning cap; past a few the cap stops applying. */
+	private cappedStreak = 0
+	/** A reply that held only reasoning was already answered with one more request. */
+	private reasoningOnlyRetried = false
 	/**
 	 * The model a refused request moved to. Once set it replaces the model the
 	 * step asked for, for the rest of the turn: the request that was refused
@@ -393,6 +415,10 @@ export class IterationOrchestrator {
 				this.rememberUserMessage(createRuntimeContextMessage(text, 'steering'))
 			},
 		}
+		if (ctx.turnConfig.completionAudit === true) this.completionAudit = new CompletionAudit()
+		if (ctx.turnConfig.reasoning?.stall !== false) {
+			this.stallMonitor = new StallMonitor(ctx.turnConfig.reasoning?.stall || undefined)
+		}
 		ctx.checkpointMgr.setLatestUserMessageSource(() => this.latestUserMessage)
 		ctx.checkpointMgr.setAnswerReviewAttemptsSource?.(() => this.answerReviewAttempts)
 		ctx.checkpointMgr.setStructuredReviewAttemptsSource?.(() => this.structuredReviewAttempts)
@@ -1063,6 +1089,11 @@ export class IterationOrchestrator {
 					// died part-way has already emitted both `message_started` and
 					// `message_completed` under this id, which is the trail a
 					// reader wants most on exactly that turn.
+					// A step the loop forces to act runs at low effort with a tool call
+					// required, for this step only. Low is used only where the model
+					// is known to offer it; effort is refused, not clamped.
+					const forcedAction = this.forceActionNextStep && !forceFinalize && llmTools.length > 0
+					this.forceActionNextStep = false
 					stepMessageId = generateMessageId()
 					const requestedMember = this.ctx.servingMember?.() ?? {
 						index: 0,
@@ -1092,12 +1123,30 @@ export class IterationOrchestrator {
 							})
 						}
 					}
+					// A forced action step runs at low effort, where the model is known
+					// to offer it; effort is refused, not clamped.
+					const offeredEfforts = this.ctx.provider.reasoningEffortLevelsFor?.(stepModel)
+					const stepEffort: ReasoningEffort | undefined =
+						forcedAction && requestEffort && (offeredEfforts?.includes('low') ?? false)
+							? 'low'
+							: requestEffort
+					// A provider that refuses a forced tool choice (some models do, and
+					// so does manual extended thinking) is not sent one: the step keeps
+					// its low effort and asks in words, on this request only.
+					const forcedChoiceRefused =
+						forcedAction &&
+						this.ctx.provider.acceptsForcedToolChoiceFor?.(stepModel, turnConfig.thinking) === false
 					const operatorInputAtDispatch = this.latestUserMessage
 					const latestReviewUserMessage =
 						(this.ctx.reviewAnswer || this.ctx.structuredOutput?.review) && operatorInputAtDispatch
 							? structuredClone(operatorInputAtDispatch)
 							: undefined
-					const { response, messageId, requestMessages } = yield* streamProviderTurn(
+					const {
+						response,
+						messageId,
+						requestMessages,
+						reasoningCapped = false,
+					} = yield* streamProviderTurn(
 						this.ctx.provider,
 						{
 							model: stepModel,
@@ -1114,7 +1163,9 @@ export class IterationOrchestrator {
 									}
 								: {}),
 							providerRoute: requestedRoute,
-							messages,
+							messages: forcedChoiceRefused
+								? [...messages, createRuntimeContextMessage(FORCED_STEP_MESSAGE, 'progress-nudge')]
+								: messages,
 							tools: llmTools.length > 0 ? llmTools : undefined,
 							...(enforceToolInputSchema ? { enforceToolInputSchema } : {}),
 							// The forced-final turn wins: a step that asked to force a
@@ -1126,14 +1177,16 @@ export class IterationOrchestrator {
 								forceFinalize && llmTools.length > 0
 									? 'none'
 									: llmTools.length > 0
-										? step.toolChoice
+										? forcedAction && !forcedChoiceRefused
+											? (step.toolChoice ?? 'required')
+											: step.toolChoice
 										: undefined,
 							temperature: step.temperature ?? turnConfig.temperature,
 							maxTokens:
 								outputCapOverride ?? step.maxResponseTokens ?? turnConfig.maxResponseTokens,
 							cacheControl: { type: 'auto' },
 							...(turnConfig.thinking ? { thinking: turnConfig.thinking } : {}),
-							...(requestEffort ? { effort: requestEffort } : {}),
+							...(stepEffort ? { effort: stepEffort } : {}),
 							...(!forceFinalize && turnConfig.webSearch
 								? { webSearch: turnConfig.webSearch }
 								: {}),
@@ -1159,8 +1212,15 @@ export class IterationOrchestrator {
 							this.ctx.reviewAnswer || this.ctx.structuredOutput?.review || this.ctx.advisoryCtx,
 						),
 						recorder.sessionId,
+						// Applies only to a step that can act. Stops after a few capped
+						// steps in a row, so a model that cannot act within the allowance
+						// still gets to finish.
+						this.cappedStreak >= MAX_CAPPED_STREAK || forceFinalize || llmTools.length === 0
+							? undefined
+							: reasoningCapChars(turnConfig.reasoning, stepEffort),
 					)
 					stepResponse = response
+					this.cappedStreak = reasoningCapped ? this.cappedStreak + 1 : 0
 					const reviewRequest: ReviewRequest = {
 						...(requestMessages ? { requestMessages } : {}),
 						...(latestReviewUserMessage ? { latestUserMessage: latestReviewUserMessage } : {}),
@@ -1461,6 +1521,28 @@ export class IterationOrchestrator {
 							costBefore,
 						})
 
+						// The step spent its whole reasoning allowance before acting. Tell
+						// the model so and make the next step an action step.
+						if (reasoningCapped && !forceFinalize) {
+							this.ctx.log.info('Reasoning reached the per-step cap — asking the model to act', {
+								[NAMZU.TURN_ID]: recorder.turnId,
+								[NAMZU.ITERATION]: iterationNum,
+							})
+							recorder.pushMessage(
+								createRuntimeContextMessage(REASONING_CAPPED_MESSAGE, 'progress-nudge'),
+							)
+							this.forceActionNextStep = true
+							this.observeStall(response, [])
+							await this.ctx.emitEvent({
+								type: 'iteration_completed',
+								turnId: recorder.turnId,
+								iteration: iterationNum,
+								hasToolCalls: false,
+							})
+							yield* this.ctx.drainPending()
+							continue
+						}
+
 						if (this.ctx.structuredOutput?.mode === 'native') {
 							const candidate = await parseNativeCandidate(
 								this.ctx.structuredOutput.schema,
@@ -1745,6 +1827,28 @@ export class IterationOrchestrator {
 						let closingStopReason: StopReason | undefined = forceFinalize
 							? guardResult.stopReason
 							: undefined
+						const reasoningOnly = !hasContent && (response.message.reasoning?.length ?? 0) > 0
+						if (hasContent) this.reasoningOnlyRetried = false
+						// A reply of reasoning alone is not an end: ask once more, plainly,
+						// before the closing request below.
+						if (reasoningOnly && !forceFinalize && !this.reasoningOnlyRetried) {
+							this.reasoningOnlyRetried = true
+							this.ctx.log.warn('Reply held reasoning only — asking once more', {
+								[NAMZU.TURN_ID]: recorder.turnId,
+								[NAMZU.ITERATION]: iterationNum,
+							})
+							recorder.pushMessage(
+								createRuntimeContextMessage(REASONING_ONLY_MESSAGE, 'progress-nudge'),
+							)
+							await this.ctx.emitEvent({
+								type: 'iteration_completed',
+								turnId: recorder.turnId,
+								iteration: iterationNum,
+								hasToolCalls: false,
+							})
+							yield* this.ctx.drainPending()
+							continue
+						}
 						if (!hasContent && !forceFinalize) {
 							this.ctx.log.warn('Empty completion detected — requesting final summary', {
 								[NAMZU.ITERATION]: iterationNum,
@@ -1755,6 +1859,23 @@ export class IterationOrchestrator {
 								'end_turn',
 							)
 							yield* this.ctx.drainPending()
+							// Never end silently: if even the closing request produced nothing,
+							// say so in plain words and how to go on.
+							if (
+								reasoningOnly &&
+								closingStopReason === undefined &&
+								!(
+									(
+										[...recorder.messages].reverse().find((m) => m.role === 'assistant') as
+											| { content?: string | null }
+											| undefined
+									)?.content ?? ''
+								).length
+							) {
+								recorder.setLastError(
+									'The model stopped after thinking without giving an answer or taking an action, even when asked again. Say "continue" and it will pick the work up from here.',
+								)
+							}
 						}
 
 						await this.ctx.emitEvent({
@@ -1787,6 +1908,21 @@ export class IterationOrchestrator {
 						// The model is done and has no tool calls. A `turn_end` (or
 						// `subagent_stop`) hook may refuse to let it be: its reason goes
 						// back to the model and the turn goes on.
+						// Files were changed and nothing checked them afterwards: ask once
+						// for a check before the turn is allowed to end.
+						if (
+							!forceFinalize &&
+							closingStopReason === undefined &&
+							this.completionAudit?.takeBlock()
+						) {
+							this.ctx.log.info('Files changed and nothing checked them — asking for a check', {
+								[NAMZU.TURN_ID]: recorder.turnId,
+							})
+							recorder.pushMessage(
+								createRuntimeContextMessage(COMPLETION_AUDIT_MESSAGE, 'progress-nudge'),
+							)
+							continue
+						}
 						if (!forceFinalize && closingStopReason === undefined) {
 							const feedback = yield* this.askStopHooks()
 							const stoppedByHook = this.ctx.toolExecutor.takeHalt?.()
@@ -1833,6 +1969,9 @@ export class IterationOrchestrator {
 						usageBefore,
 						costBefore,
 					})
+					this.reasoningOnlyRetried = false
+					this.observeStall(response, reviewOutcome.results)
+					this.observeAudit(response, reviewOutcome.results)
 
 					if (reviewOutcome.decision === 'stop') {
 						return
@@ -3118,6 +3257,69 @@ export class IterationOrchestrator {
 		}
 	}
 
+	/** Feed the completion audit the calls of one finished step. */
+	private observeAudit(
+		response: ChatCompletionResponse,
+		results: readonly ToolCallOutcome[],
+	): void {
+		const audit = this.completionAudit
+		if (!audit) return
+		const calls = new Map((response.message.toolCalls ?? []).map((c) => [c.id, c]))
+		audit.observe(
+			results.map((result) => {
+				let input: unknown
+				try {
+					const call = calls.get(result.toolCallId)
+					input = call ? JSON.parse(call.function.arguments) : undefined
+				} catch {
+					input = undefined
+				}
+				return { toolName: result.toolName, input, isError: result.isError }
+			}),
+		)
+	}
+
+	/**
+	 * Feed the stall monitor one finished step and act on its verdict: a nudge
+	 * is recorded as a message, a force makes the next step an action step.
+	 */
+	private observeStall(
+		response: ChatCompletionResponse,
+		results: readonly ToolCallOutcome[],
+	): void {
+		const monitor = this.stallMonitor
+		if (!monitor) return
+		const calls = new Map((response.message.toolCalls ?? []).map((c) => [c.id, c]))
+		let changedState = false
+		for (const result of results) {
+			const call = calls.get(result.toolCallId)
+			let readOnly: boolean | undefined
+			try {
+				const input = call ? JSON.parse(call.function.arguments) : undefined
+				readOnly = this.ctx.tools.get(result.toolName)?.isReadOnly?.(input)
+			} catch {
+				readOnly = undefined
+			}
+			if (callChangedState(result.toolName, readOnly, result.isError)) changedState = true
+		}
+		const reasoningChars = (response.message.reasoning ?? []).reduce(
+			(n, block) => n + (block.text?.length ?? 0),
+			0,
+		)
+		const directive = monitor.observe({ reasoningChars, changedState })
+		if (directive.kind === 'nudge') {
+			this.ctx.log.info('Many steps without a change — nudging the model to act', {
+				[NAMZU.TURN_ID]: this.ctx.recorder.turnId,
+			})
+			this.ctx.recorder.pushMessage(createRuntimeContextMessage(directive.text, 'progress-nudge'))
+		} else if (directive.kind === 'force') {
+			this.ctx.log.info('Still no change after the nudge — forcing an action step', {
+				[NAMZU.TURN_ID]: this.ctx.recorder.turnId,
+			})
+			this.forceActionNextStep = true
+		}
+	}
+
 	private async requestFinalResponse(
 		model: string,
 		reason: StopReason,