@namzu/sdk 51.0.0 → 52.0.0

package/src/runtime/query/executor.ts

@@ -32,7 +32,7 @@ import {
 	createToolMessage,
 } from '../../types/message/index.js'
 import type { PermissionMode } from '../../types/permission/index.js'
-import type { PluginHookResult } from '../../types/plugin/index.js'
+import type { PluginHookPermission, PluginHookResult } from '../../types/plugin/index.js'
 import type { ChatCompletionResponse } from '../../types/provider/index.js'
 import type { Sandbox } from '../../types/sandbox/index.js'
 import type { AuditEventInput } from '../../types/session/audit.js'
@@ -65,6 +65,7 @@ import { type BackgroundJobRegistry, type JobProcess, bindOwner } from '../jobs/
 import {
 	type ToolAdmissionHost,
 	formatFailedToolOutput,
+	hookNote,
 	isUnregistered,
 	prepareDirectCall,
 	runPreToolHook,
@@ -73,14 +74,17 @@ import {
 import { describeVisibleFileEvidence } from './file-evidence-context.js'
 import { seedObservationLedger } from './file-evidence-seed.js'
 import { DEFAULT_TOOL_RESULT_GUARDRAILS } from './guardrail-presets.js'
+import { declaredWriteEscalation, shellEscalations } from './path-escalation.js'
 import type { ToolResultObservation } from './project-instructions.js'
 import { savedPresentation } from './saved-presentation.js'
 import { ToolCallBudget, assertMaxToolCalls } from './tool-call-budget.js'
 import {
 	DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+	DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE,
 	type ToolOutputBudgetResult,
 	applyToolOutputBudget,
 	describeDroppedContent,
+	fitResultsToMessageBudget,
 	measureContentBytes,
 } from './tool-output-budget.js'
 
@@ -94,6 +98,7 @@ export type PreparedDirectCall =
 			readonly toolName: string
 			readonly input: unknown
 			readonly prepared: PreparedToolExecution
+			readonly hook?: PreToolHookNotes
 	  }
 	| {
 			readonly kind: 'legacy'
@@ -101,6 +106,7 @@ export type PreparedDirectCall =
 			readonly toolName: string
 			readonly input: unknown
 			readonly inputFailure?: CompletedToolRecord['inputFailure']
+			readonly hook?: PreToolHookNotes
 	  }
 	| {
 			readonly kind: 'synthetic'
@@ -129,6 +135,8 @@ export interface PreparedToolBatch {
 		readonly input: unknown
 		/** What the prepared value reaches past the turn's boundary; see `ToolCallSummary.escalation`. */
 		readonly escalation?: ToolCallEscalation
+		/** What a `pre_tool_use` hook asked for this call's approval; see `ToolCallSummary.hookPermission`. */
+		readonly hookPermission?: PluginHookPermission
 	}[]
 }
 
@@ -137,6 +145,16 @@ interface OwnedPreparedToolBatch extends PreparedToolBatch {
 	readonly escalations: ReadonlyMap<string, ToolCallEscalation>
 }
 
+/**
+ * A nested call cannot open a review from inside the tool that issued it, so
+ * a hook that asked for a person to approve it can only be answered with a
+ * refusal. Silence would run the call the hook wanted a person to see.
+ */
+function askedNestedMessage(toolName: string, outcome: PreToolHookOutcome): string | undefined {
+	if (outcome.kind !== 'continue' || outcome.permission?.decision !== 'ask') return undefined
+	return `Blocked: a hook asked that a person approve "${toolName}", and an approval cannot be requested from inside another tool. Call it directly.`
+}
+
 function assertUniqueToolCallIds(toolCalls: readonly ToolCall[]): void {
 	const seen = new Set<string>()
 	for (const [index, toolCall] of toolCalls.entries()) {
@@ -420,6 +438,8 @@ export interface ToolExecutorConfig {
 	 * {@link DEFAULT_MAX_TOOL_OUTPUT_CHARS}; set `0` to disable.
 	 */
 	maxToolOutputChars?: number
+	/** See QueryParams.maxToolOutputCharsPerMessage. */
+	maxToolOutputCharsPerMessage?: number
 	/** See QueryParams.retainedToolPreviewChars; applies to the recorded host output. */
 	retainedToolPreviewChars?: number
 
@@ -493,8 +513,16 @@ interface PostToolOverride {
 	readonly content?: ToolResultContent
 }
 
+/** What `pre_tool_use` hooks said about a call beyond running it or not. */
+export interface PreToolHookNotes {
+	/** The strictest permission answer among the hooks: `ask` outranks `allow`. */
+	readonly permission?: PluginHookPermission
+	/** Hook text for the model, appended to what it reads of this call. */
+	readonly context?: string
+}
+
 export type PreToolHookOutcome =
-	| { kind: 'continue'; input: unknown; modified: boolean }
+	| ({ kind: 'continue'; input: unknown; modified: boolean } & PreToolHookNotes)
 	| { kind: 'skip'; input: unknown; output: string }
 	| { kind: 'error'; input: unknown; output: string }
 
@@ -1003,11 +1031,80 @@ export class ToolExecutor {
 			tool.sandboxEscapeArgument !== undefined &&
 			input[tool.sandboxEscapeArgument] === true
 		const unknownProgram = this.unknownProgramOf(tool, input, sandboxed)
-		if (!outsidePaths && !sandboxEscape && unknownProgram === undefined) return undefined
+		const reaches = await this.pathEscalationsOf(tool, input, sandboxed)
+		if (reaches.outsidePaths.length > 0) {
+			outsidePaths = [...new Set([...(outsidePaths ?? []), ...reaches.outsidePaths])]
+		}
+		const protectedPaths = reaches.protectedPaths
+		const removal = reaches.dangerousRemoval
+		if (
+			!outsidePaths &&
+			!sandboxEscape &&
+			unknownProgram === undefined &&
+			protectedPaths.length === 0 &&
+			removal === undefined
+		) {
+			return undefined
+		}
 		return {
 			...(outsidePaths ? { outsidePaths } : {}),
 			...(sandboxEscape ? { sandboxEscape: true as const } : {}),
 			...(unknownProgram !== undefined ? { unknownProgram } : {}),
+			...(protectedPaths.length > 0 ? { protectedPaths } : {}),
+			...(removal !== undefined ? { dangerousRemoval: removal } : {}),
+		}
+	}
+
+	/**
+	 * What the call's own arguments write or remove that no mode may approve in
+	 * advance, and, for a shell line, the paths outside the roots it names.
+	 *
+	 * The protected-path and removal floors hold whether or not the turn reviews
+	 * outside paths and whether or not it is sandboxed: they are about what the
+	 * write plants and what the removal destroys, not about where the turn is
+	 * allowed to look. The outside-path half follows `outsideRootAccess`, as the
+	 * file tools' own does.
+	 */
+	private async pathEscalationsOf(
+		tool: Pick<
+			ToolDefinition,
+			'pathArgument' | 'commandArgument' | 'commandDialect' | 'isReadOnly'
+		>,
+		input: Record<string, unknown>,
+		sandboxed: boolean,
+	): Promise<{
+		outsidePaths: readonly string[]
+		protectedPaths: readonly string[]
+		dangerousRemoval?: string
+	}> {
+		const roots = toolRoots(this.config)
+		const protectedPaths: string[] = []
+		let outsidePaths: readonly string[] = []
+		let removal: string | undefined
+		if (tool.pathArgument !== undefined && tool.isReadOnly?.(input) !== true) {
+			const value = input[tool.pathArgument]
+			if (typeof value === 'string') {
+				const hit = await declaredWriteEscalation(roots, value)
+				if (hit !== undefined) protectedPaths.push(hit)
+			}
+		}
+		if (tool.commandArgument !== undefined) {
+			const line = input[tool.commandArgument]
+			if (typeof line === 'string') {
+				const dialect = tool.commandDialect?.({ sandboxed }) ?? 'sh'
+				const found = await shellEscalations(line, dialect, {
+					roots,
+					reviewOutside: this.config.outsideRootAccess === 'review' && !sandboxed,
+				})
+				protectedPaths.push(...found.protectedPaths)
+				outsidePaths = found.outsidePaths
+				removal = found.dangerousRemoval
+			}
+		}
+		return {
+			outsidePaths,
+			protectedPaths: [...new Set(protectedPaths)],
+			...(removal !== undefined ? { dangerousRemoval: removal } : {}),
 		}
 	}
 
@@ -1022,7 +1119,10 @@ export class ToolExecutor {
 	 * outside one.
 	 */
 	private unknownProgramOf(
-		tool: { commandArgument?: string; commandDialect?: ToolDefinition['commandDialect'] },
+		tool: {
+			commandArgument?: string
+			commandDialect?: ToolDefinition['commandDialect']
+		},
 		input: Record<string, unknown>,
 		sandboxed: boolean,
 	): string | undefined {
@@ -1069,11 +1169,13 @@ export class ToolExecutor {
 			)
 			.map((call) => {
 				const escalation = escalations.get(call.toolCall.id)
+				const hookPermission = call.hook?.permission
 				return {
 					id: call.toolCall.id,
 					name: call.toolName,
 					input: call.input,
 					...(escalation ? { escalation } : {}),
+					...(hookPermission ? { hookPermission } : {}),
 				}
 			})
 		const batch: OwnedPreparedToolBatch = Object.freeze({
@@ -1327,6 +1429,8 @@ export class ToolExecutor {
 			})
 		}
 
+		this.fitBatchToMessageBudget(results)
+
 		// isError and rich content were computed and then discarded here: the
 		// tuple narrowed to {toolCallId, output} BEFORE the message was built,
 		// so the failure signal and any image block were structurally lost at
@@ -1338,6 +1442,51 @@ export class ToolExecutor {
 		return { messages, results, observations }
 	}
 
+	/**
+	 * Hold the batch's combined result text under the per-message cap.
+	 *
+	 * Runs once, on the settled batch and before the results become history
+	 * messages, so what it writes is what every later request replays.
+	 */
+	private fitBatchToMessageBudget(results: ToolCallOutcome[]): void {
+		const maxChars =
+			this.config.maxToolOutputCharsPerMessage ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE
+		const replacements = fitResultsToMessageBudget(
+			results.map((r) => ({
+				toolCallId: r.toolCallId,
+				toolName: r.toolName,
+				output: r.output,
+				// A result carrying rich content or a structured-output copy is
+				// not text the model reads alone, and a self-limiting tool has
+				// already decided its own size.
+				replaceable:
+					r.content === undefined &&
+					r.structuredResultJson === undefined &&
+					this.config.tools.get(r.toolName)?.selfLimitingOutput !== true,
+			})),
+			{
+				maxChars,
+				spillDir: this.outputDirectory(),
+				onError: (message) =>
+					this.log.warn('Failed to retain a tool output replaced for the message budget', {
+						[NAMZU.TURN_ID]: this.config.turnId,
+						'exception.message': message,
+					}),
+			},
+		)
+		if (replacements.size === 0) return
+		for (const [i, r] of results.entries()) {
+			const replacement = replacements.get(r.toolCallId)
+			if (replacement === undefined) continue
+			results[i] = { ...r, output: replacement.output }
+		}
+		this.log.warn("Tool results exceeded the message's combined budget", {
+			[NAMZU.TURN_ID]: this.config.turnId,
+			'namzu.runtime.replaced_count': replacements.size,
+			'namzu.runtime.message_budget_chars': maxChars,
+		})
+	}
+
 	/**
 	 * Run a tool on behalf of another tool, and put it on the record.
 	 *
@@ -1802,8 +1951,10 @@ export class ToolExecutor {
 		let input: unknown
 		let prepared: PreparedToolExecution | undefined
 		let inputFailure: ToolCallOutcome['inputFailure']
+		let preparedHookContext: string | undefined
 
 		if (preparedCall?.kind === 'ready' || preparedCall?.kind === 'legacy') {
+			preparedHookContext = preparedCall.hook?.context
 			input = preparedCall.input
 			prepared = preparedCall.kind === 'ready' ? preparedCall.prepared : undefined
 			if (preparedCall.kind === 'legacy') inputFailure = preparedCall.inputFailure
@@ -1824,6 +1975,7 @@ export class ToolExecutor {
 			if (admitted.kind === 'synthetic') return this.recordSyntheticPreparation(admitted)
 			toolName = admitted.toolName
 			input = admitted.input
+			preparedHookContext = admitted.hook?.context
 			prepared = admitted.kind === 'ready' ? admitted.prepared : undefined
 			if (admitted.kind === 'legacy') inputFailure = admitted.inputFailure
 		}
@@ -2029,7 +2181,11 @@ export class ToolExecutor {
 				]
 			}
 		}
-		const maxToolOutputChars = this.config.maxToolOutputChars ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS
+		// A tool that bounds its own output is exempt from the DEFAULT per-result
+		// cap only; a host that set the cap explicitly still gets it.
+		const maxToolOutputChars =
+			this.config.maxToolOutputChars ??
+			(executedDefinition?.selfLimitingOutput === true ? 0 : DEFAULT_MAX_TOOL_OUTPUT_CHARS)
 		const sourceOutput = output
 		// This owner-bound channel follows the selected receipt after both result
 		// screening and post-tool replacement. ToolResult.data and raw input can
@@ -2085,13 +2241,26 @@ export class ToolExecutor {
 			})
 		}
 		output = budgeted.output
-		const modelContent =
+		let modelContent =
 			selectedContent === undefined
 				? undefined
 				: this.budgetContent(selectedContent, toolName, toolCall.id, {
 						sourceOutput,
 						budgeted,
 					})
+		// What hooks said about this call rides with its result, in the model's
+		// receipt and the host's alike, framed as a hook's words. Added after
+		// the output budget so a bounded result is never trimmed to make room
+		// for it; the note has its own bound (`hookNote`).
+		const hookTexts = [preparedHookContext, post.context].filter(
+			(text): text is string => text !== undefined && text.length > 0,
+		)
+		if (hookTexts.length > 0) {
+			const note = hookNote(hookTexts)
+			output = `${output}\n\n${note}`
+			if (typeof modelContent === 'string') modelContent = `${modelContent}\n\n${note}`
+			else if (modelContent) modelContent = [...modelContent, { type: 'text', text: note }]
+		}
 
 		// A failed call, or an override that says the call failed. A `replace`
 		// says the opposite, and reading it as a failure is what made redaction
@@ -2438,9 +2607,25 @@ export class ToolExecutor {
 			emitEvent: this.emitEvent,
 			log: this.log,
 			allowedTools: this.effectiveAllowedTools(),
+			requestHalt: (reason) => this.requestHalt(reason),
 		}
 	}
 
+	/** Why a hook asked for the turn to stop, until the iteration loop reads it. */
+	private haltReason: string | undefined
+
+	/** The first request wins: a later hook does not rewrite why the turn stopped. */
+	requestHalt(reason: string): void {
+		this.haltReason ??= reason
+	}
+
+	/** Read and clear a hook's request to stop the turn. */
+	takeHalt(): string | undefined {
+		const reason = this.haltReason
+		this.haltReason = undefined
+		return reason
+	}
+
 	private async prepareNestedCall(
 		toolName: string,
 		input: unknown,
@@ -2468,6 +2653,14 @@ export class ToolExecutor {
 					...(preOutcome.kind === 'skip' ? { skipped: true as const } : {}),
 				}
 			}
+			const nestedAsk = askedNestedMessage(toolName, preOutcome)
+			if (nestedAsk)
+				return {
+					kind: 'synthetic',
+					input: preOutcome.input,
+					message: nestedAsk,
+					isError: true,
+				}
 			return { kind: 'legacy', input: preOutcome.input }
 		}
 
@@ -2513,6 +2706,15 @@ export class ToolExecutor {
 				...(preOutcome.kind === 'skip' ? { skipped: true as const } : {}),
 			}
 		}
+		const nestedAsk = askedNestedMessage(toolName, preOutcome)
+		if (nestedAsk) {
+			return {
+				kind: 'synthetic',
+				input: preOutcome.input,
+				message: nestedAsk,
+				isError: true,
+			}
+		}
 		if (!preOutcome.modified) {
 			return {
 				kind: 'ready',
@@ -2571,12 +2773,17 @@ export class ToolExecutor {
 	/**
 	 * @returns `override` — text replacing the tool's output, or `null`.
 	 *   `retry` — the hook asked for the tool to run again.
+	 *   `context` — what the hooks want the model to read beside the result.
 	 */
 	private async runPostToolHook(
 		toolName: string,
 		input: unknown,
 		toolResult: ToolResult,
-	): Promise<{ override: PostToolOverride | null; retry: boolean }> {
+	): Promise<{
+		override: PostToolOverride | null
+		retry: boolean
+		context?: string
+	}> {
 		if (!this.config.pluginManager) return { override: null, retry: false }
 		let results: PluginHookResult[]
 		try {
@@ -2592,6 +2799,26 @@ export class ToolExecutor {
 				},
 				this.emitEvent,
 			)
+			// A failed call is announced a second time, by name, so a hook that
+			// only cares about failures need not read every result. After
+			// `post_tool_use`, so the existing hooks see exactly what they saw.
+			if (!toolResult.success) {
+				results = [
+					...results,
+					...(await this.config.pluginManager.executeHooks(
+						'post_tool_use_failure',
+						{
+							sessionId: this.config.sessionId,
+							turnId: this.config.turnId,
+							toolName,
+							toolInput: input,
+							toolResult,
+							signal: this.config.abortSignal,
+						},
+						this.emitEvent,
+					)),
+				]
+			}
 		} catch (error) {
 			if (!this.config.abortSignal.aborted) throw error
 			// The tool has already returned. Cancellation of a later redaction
@@ -2608,9 +2835,12 @@ export class ToolExecutor {
 		}
 		let override: PostToolOverride | null = null
 		let retry = false
+		const contexts: string[] = []
 		for (const result of results) {
 			switch (result.action) {
 				case 'continue':
+					if (result.context) contexts.push(result.context)
+					if (result.halt) this.requestHalt(result.halt.reason)
 					continue
 				case 'error':
 					override = { output: `Error: ${result.message}`, isError: true }
@@ -2646,7 +2876,11 @@ export class ToolExecutor {
 				}
 			}
 		}
-		return { override, retry }
+		return {
+			override,
+			retry,
+			...(contexts.length > 0 ? { context: contexts.join('\n') } : {}),
+		}
 	}
 
 	/**

package/src/runtime/query/finalize-turn.ts

@@ -53,6 +53,12 @@ export interface TurnFinalization {
 	 * immediately before the record is written.
 	 */
 	readonly takeSteps: () => readonly StepResult[]
+	/**
+	 * Whether the loop already fired `turn_end` (and `subagent_stop`) when the
+	 * model finished, so a hook could keep the turn going. Fired there, it is
+	 * not fired again here.
+	 */
+	readonly turnEndHooksFired?: () => boolean
 	readonly workingStateManager: WorkingStateManager | undefined
 	readonly resultAssembler: ResultAssembler
 	readonly rootSpan: Span
@@ -71,7 +77,7 @@ export async function* finalizeTurn(
 		rootSpan,
 	} = finalization
 
-	if (params.pluginManager) {
+	if (params.pluginManager && finalization.turnEndHooksFired?.() !== true) {
 		const hookResults = await params.pluginManager.executeHooks(
 			'turn_end',
 			{ sessionId: ctx.sessionId, turnId: ctx.turnId, signal: ctx.abortController.signal },

package/src/runtime/query/index.ts

@@ -331,6 +331,17 @@ export interface QueryParams {
 	maxToolConcurrency?: number
 	/** Per-turn cumulative tool attempt limit, including nested calls and retries. Unset is unlimited. Re-supply on resume; durable reservations are never refunded. */
 	maxToolCalls?: number
+	/**
+	 * How many times in a row the loop nudges the model to carry on after a
+	 * reply was cut off at its output limit, before the turn stops with an
+	 * error naming the limit. The count restarts after any call that finishes
+	 * on its own.
+	 *
+	 * Unset keeps the earlier behaviour: nudge every time, bounded only by
+	 * `maxIterations`. Opt-in because a cap is a stop a host did not have
+	 * before; `0` stops at the first cut-off.
+	 */
+	maxOutputContinuations?: number
 
 	/**
 	 * Model-visible size cap for a single tool result. Over-budget output is
@@ -339,6 +350,18 @@ export interface QueryParams {
 	 * agent decides the rest is worth re-reading. Set `0` to disable.
 	 */
 	maxToolOutputChars?: number
+	/**
+	 * Cap on the COMBINED model-visible text of every tool result one assistant
+	 * message produced. Defaults to {@link DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE}
+	 * (200,000 characters); `0` disables it. When a batch exceeds it, the
+	 * largest results are replaced, largest first, by a short preview that
+	 * names where the full text was kept, until the batch fits. The
+	 * replacement is written into the result before it reaches the history, so
+	 * it never changes afterwards and the prompt-cache prefix stays stable.
+	 * Tools that bound their own output (`selfLimitingOutput`) are never
+	 * replaced.
+	 */
+	maxToolOutputCharsPerMessage?: number
 	/**
 	 * Screens to run against every tool result. The turn builds its manager
 	 * from `toolsets` and gives it this policy.
@@ -726,6 +749,13 @@ export interface QueryParams {
 	 * started. See `BaseAgentConfig.inboundMessages` for what it closes.
 	 */
 	inboundMessages?: () => import('../../types/message/index.js').Message[]
+	/**
+	 * Hidden reminders a host feeds into the conversation, asked for before
+	 * every model request of the turn. Opt-in: omitted, a turn carries none.
+	 * See {@link ReminderSource}.
+	 */
+	reminders?: import('./reminders.js').ReminderSource
+
 	/**
 	 * Wake a background-task hold when operator input is available, without draining it.
 	 * Resolve immediately if input is already pending. Otherwise wait for its arrival;
@@ -1407,6 +1437,11 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 				...(params.maxToolOutputChars !== undefined
 					? { maxToolOutputChars: params.maxToolOutputChars }
 					: {}),
+				...(params.maxToolOutputCharsPerMessage !== undefined
+					? {
+							maxToolOutputCharsPerMessage: params.maxToolOutputCharsPerMessage,
+						}
+					: {}),
 				...(params.toolResultGuardrails !== undefined
 					? { toolResultGuardrails: params.toolResultGuardrails }
 					: {}),
@@ -1474,9 +1509,9 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 		// Normalised once, defaults applied. A host that passes a partial
 		// object — a strategy and a window, nothing else — used to reach the
 		// phase with `triggerThreshold` undefined, and `usage < undefined` is
-		// false: the pass ran on every iteration and the salience strategy fell
-		// through to the stale-result clearing it exists to replace. The eval
-		// suite that passed exactly that object found it.
+		// false: the pass ran on every iteration. An absent threshold now means
+		// the derived trigger (`resolveTriggerThreshold`), resolved where it is
+		// compared.
 		const compactionConfig = params.compactionConfig
 			? CompactionConfigSchema.parse(params.compactionConfig)
 			: undefined
@@ -1635,7 +1670,11 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			// would leak exactly that way.
 			...(params.repeatCallAdvisory === false ? {} : { repeatCalls: new RepeatCallTracker() }),
 			compactionConfig,
+			...(params.maxOutputContinuations !== undefined
+				? { maxOutputContinuations: params.maxOutputContinuations }
+				: {}),
 			...(params.inboundMessages ? { inboundMessages: params.inboundMessages } : {}),
+			...(params.reminders ? { reminders: params.reminders } : {}),
 			...(params.durableInbound ? { durableInbound: params.durableInbound } : {}),
 			...(params.resumeFromCheckpoint ? { resumedInput: queuedForThisRun } : {}),
 			...(params.waitForInbound ? { waitForInbound: params.waitForInbound } : {}),
@@ -1666,6 +1705,8 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			agentBus: params.agentBus,
 			verificationGate,
 			pluginManager: params.pluginManager,
+			...(params.parentSessionId !== undefined ? { parentSessionId: params.parentSessionId } : {}),
+			...(params.parentTurnId !== undefined ? { parentTurnId: params.parentTurnId } : {}),
 		})
 
 		const tracer = getTracer()
@@ -2489,6 +2530,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 					params,
 					eventTranslator,
 					takeSteps: () => iterationOrchestrator.getSteps(),
+					turnEndHooksFired: () => iterationOrchestrator.turnEndHooksFired,
 					workingStateManager,
 					resultAssembler,
 					rootSpan,