@namzu/sdk 23.0.0 → 26.0.0

package/src/connector/mcp/stdio.ts

@@ -13,6 +13,111 @@ import { type Logger, getRootLogger } from '../../utils/logger.js'
  */
 const TERMINATE_GRACE_MS = 2_000
 
+/**
+ * The variables a child needs in order to be a working process at all.
+ *
+ * This spawn used to pass `{ ...process.env, ...config.env }`, so a connected
+ * server received every credential the host happened to hold — measured at 119
+ * variables on a developer machine, including a planted secret the server had
+ * no reason to see. A server that needs one token was handed all of them, and
+ * nothing in the config said so.
+ *
+ * The list below is process plumbing, not secrets: where to find executables,
+ * where the home and temp directories are, what the locale is. Dropping any of
+ * it does not harden anything and does break servers — a child with no `PATH`
+ * cannot resolve its own interpreter.
+ *
+ * Anything else a server needs is now named: `env` gives it a literal value,
+ * and `inheritEnv` names a parent variable to pass through. Naming is the
+ * point — a grant that has to be written down is a grant somebody can review.
+ *
+ * Windows spellings are matched case-insensitively, because its environment is
+ * case-insensitive and a lookup for `Path` against a key stored as `PATH` would
+ * silently drop it — which would present as "the server does not start on
+ * Windows" rather than as anything to do with this list.
+ */
+const BASE_ENV_KEYS: readonly string[] = [
+	// Everywhere.
+	'PATH',
+	'LANG',
+	'LC_ALL',
+	'LC_CTYPE',
+	'TZ',
+	// POSIX.
+	'HOME',
+	'SHELL',
+	'TMPDIR',
+	'USER',
+	'LOGNAME',
+	// Windows. `SystemRoot` and `ComSpec` are load-bearing: without them a
+	// child cannot resolve system DLLs or the command interpreter.
+	'PATHEXT',
+	'SystemRoot',
+	'SystemDrive',
+	'ComSpec',
+	'WINDIR',
+	'TEMP',
+	'TMP',
+	'USERPROFILE',
+	'HOMEDRIVE',
+	'HOMEPATH',
+	'APPDATA',
+	'LOCALAPPDATA',
+	'PROGRAMDATA',
+	'PROGRAMFILES',
+	'NUMBER_OF_PROCESSORS',
+	'PROCESSOR_ARCHITECTURE',
+]
+
+/**
+ * Read one variable from the parent, honouring the platform's own casing rules.
+ *
+ * Node exposes `process.env` on Windows through a case-insensitive proxy, so a
+ * direct lookup already works there — but the KEY this returns has to be the
+ * one the parent actually uses, or a child comparing key names sees a spelling
+ * the host never set.
+ */
+function readParentVar(source: NodeJS.ProcessEnv, name: string): [string, string] | undefined {
+	const direct = source[name]
+	if (direct !== undefined) return [name, direct]
+	if (process.platform !== 'win32') return undefined
+	const lowered = name.toLowerCase()
+	for (const [key, value] of Object.entries(source)) {
+		if (key.toLowerCase() === lowered && value !== undefined) return [key, value]
+	}
+	return undefined
+}
+
+/**
+ * What the child is handed: plumbing, then the named inheritances, then the
+ * literal values.
+ *
+ * Later wins, and the order is the precedence an operator would guess: a
+ * literal `env` entry overrides an inherited one, and both override the base.
+ * Exported for the tests, which assert on the ENV rather than on the spawn —
+ * a test that only checked the config was accepted would have passed against
+ * the version this replaces.
+ */
+export function buildChildEnv(
+	config: Pick<MCPStdioTransportConfig, 'env' | 'inheritEnv'>,
+	source: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+	const env: Record<string, string> = {}
+	for (const name of BASE_ENV_KEYS) {
+		const found = readParentVar(source, name)
+		if (found) env[found[0]] = found[1]
+	}
+	for (const name of config.inheritEnv ?? []) {
+		const found = readParentVar(source, name)
+		// A named variable the parent does not hold is simply absent. Refusing
+		// the spawn would turn an optional credential into a startup failure,
+		// and inventing an empty string would tell the server it has one.
+		if (found) env[found[0]] = found[1]
+	}
+	for (const [name, value] of Object.entries(config.env ?? {})) env[name] = value
+	return env
+}
+
 export class StdioTransport implements MCPTransport {
 	private process: ChildProcess | null = null
 	private messageHandlers: Array<(message: MCPJsonRpcMessage) => void> = []
@@ -32,7 +137,7 @@ export class StdioTransport implements MCPTransport {
 		if (this.connected) return
 
 		this.process = spawn(this.config.command, this.config.args ?? [], {
-			env: { ...process.env, ...this.config.env },
+			env: buildChildEnv(this.config),
 			cwd: this.config.cwd,
 			stdio: ['pipe', 'pipe', 'pipe'],
 		})

package/src/constants/telemetry/index.ts

@@ -23,7 +23,22 @@ export const GENAI = {
 
 	TOOL_NAME: 'gen_ai.tool.name',
 	TOOL_TYPE: 'gen_ai.tool.type',
-	TOOL_CALL_ID: 'gen_ai.tool.call_id',
+
+	/**
+	 * The id of the tool call this span is about.
+	 *
+	 * Spelled `call.id`, matching the registry and matching the two
+	 * neighbours above — this read `gen_ai.tool.call_id`, one underscore
+	 * where the convention has a dot, so a consumer grouping by the
+	 * conventional name found nothing under it. Nothing errored, because a
+	 * span attribute is a free-form key and a wrong one is simply a key
+	 * nobody asked for.
+	 *
+	 * Pinned by `telemetry/__tests__/tool-call-id-attribute.test.ts`, which
+	 * also drives the emitter: the spelling was only half the defect, and
+	 * the constant had no writer at all.
+	 */
+	TOOL_CALL_ID: 'gen_ai.tool.call.id',
 
 	AGENT_NAME: 'gen_ai.agent.name',
 	AGENT_ID: 'gen_ai.agent.id',

package/src/provider/fallback.ts

@@ -382,7 +382,13 @@ export function withProviderFallback(
 		},
 		chatStream,
 		...(first.provider.listModels ? { listModels: () => first.provider.listModels?.() } : {}),
-		...(first.provider.healthCheck ? { healthCheck: () => first.provider.healthCheck?.() } : {}),
-		...(first.provider.doctorCheck ? { doctorCheck: () => first.provider.doctorCheck?.() } : {}),
+		// Forwarded for the reason `retry.ts` forwards it: a wrapper that drops
+		// the model turns a probe the caller could answer into one it cannot.
+		...(first.provider.healthCheck
+			? { healthCheck: (model?: string) => first.provider.healthCheck?.(model) }
+			: {}),
+		...(first.provider.doctorCheck
+			? { doctorCheck: (model?: string) => first.provider.doctorCheck?.(model) }
+			: {}),
 	} as LLMProvider
 }

package/src/provider/retry.ts

@@ -1,15 +1,20 @@
 import { classifyProviderError, isAbortError } from '../types/provider/errors.js'
 import type { ChatCompletionParams, LLMProvider, StreamChunk } from '../types/provider/index.js'
+import { type BackoffPolicy, backoffWithJitter, sleep } from '../utils/backoff.js'
 import type { Logger } from '../utils/logger.js'
 import { isProviderRequestError } from './errors.js'
 
-export interface ProviderRetryConfig {
+/**
+ * `BackoffPolicy` plus the provider-specific parts: how many attempts, and
+ * how long a server-directed wait may be honoured for.
+ *
+ * The curve itself lives in `utils/backoff.ts` and is shared with the tool
+ * executor's in-loop retry — which had no backoff at all while this one was
+ * being careful about jitter two directories away.
+ */
+export interface ProviderRetryConfig extends BackoffPolicy {
 	/** Retry attempts AFTER the initial try. `0` disables retrying. */
 	readonly maxRetries: number
-	/** First backoff, doubled each attempt. */
-	readonly initialDelayMs: number
-	/** Ceiling for a single backoff, before jitter. */
-	readonly maxDelayMs: number
 	/**
 	 * Cap on a server-directed `Retry-After`. A provider asking for 15
 	 * minutes should not silently park an interactive run for 15 minutes;
@@ -34,36 +39,6 @@ export const DEFAULT_PROVIDER_RETRY: ProviderRetryConfig = {
 	maxRetryAfterMs: 60_000,
 }
 
-/**
- * Full jitter (AWS's formulation): sleep a uniform random amount in
- * `[0, backoff]` rather than `backoff` exactly. Equal-jitter and no-jitter
- * both keep a fleet of clients that failed together retrying together;
- * full jitter is what actually spreads a thundering herd.
- */
-function backoffWithJitter(attempt: number, config: ProviderRetryConfig, random: () => number) {
-	const exponential = Math.min(config.initialDelayMs * 2 ** attempt, config.maxDelayMs)
-	return Math.round(random() * exponential)
-}
-
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-	if (ms <= 0) return Promise.resolve()
-	return new Promise<void>((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(signal.reason)
-			return
-		}
-		const timer = setTimeout(() => {
-			signal?.removeEventListener('abort', onAbort)
-			resolve()
-		}, ms)
-		const onAbort = () => {
-			clearTimeout(timer)
-			reject(signal?.reason)
-		}
-		signal?.addEventListener('abort', onAbort, { once: true })
-	})
-}
-
 export interface WithProviderRetryOptions {
 	readonly config?: Partial<ProviderRetryConfig>
 	readonly log?: Logger
@@ -256,7 +231,15 @@ export function withProviderRetry(
 		},
 		chatStream,
 		...(provider.listModels ? { listModels: () => provider.listModels?.() } : {}),
-		...(provider.healthCheck ? { healthCheck: () => provider.healthCheck?.() } : {}),
-		...(provider.doctorCheck ? { doctorCheck: () => provider.doctorCheck?.() } : {}),
+		// The model is forwarded, not dropped. A wrapper that swallowed it would
+		// leave the wrapped driver probing whatever it probes with no argument
+		// — which for at least one driver is "nothing", so the check would come
+		// back unanswerable purely because it was wrapped.
+		...(provider.healthCheck
+			? { healthCheck: (model?: string) => provider.healthCheck?.(model) }
+			: {}),
+		...(provider.doctorCheck
+			? { doctorCheck: (model?: string) => provider.doctorCheck?.(model) }
+			: {}),
 	} as LLMProvider
 }

package/src/public-runtime.ts

@@ -357,6 +357,11 @@ export type {
 	WithProviderFallbackOptions,
 	WithProviderRetryOptions,
 } from './provider/index.js'
+// The curve `ProviderRetryConfig` extends and `query({ toolRetryBackoff })`
+// takes a partial of. Both public surfaces name it, so a consumer has to be
+// able to name it too — a type reachable only through an inline `import(...)`
+// in a `.d.ts` is not a type anyone writes down.
+export type { BackoffPolicy } from './utils/backoff.js'
 
 export {
 	assertIsolation,

package/src/registry/tool/execute.ts

@@ -415,9 +415,21 @@ Executable tool names, descriptions, and JSON input schemas are attached through
 
 		return tracer.startActiveSpan(toolSpanName(toolName), {}, parentCtx, async (span) => {
 			try {
+				// The call id joins this span to the assistant block that asked
+				// for it. Without it a trace shows that `Bash` ran four times
+				// this turn and cannot say which span answers which
+				// `tool_use` — and the id was already in hand here, threaded
+				// through `ToolContext` for the tools that reply
+				// asynchronously.
+				//
+				// Conditional because `toolUseId` is optional: a host calling
+				// a tool directly, outside a run, has no call to correlate to,
+				// and an attribute set to `undefined` is worse than an absent
+				// one — it reaches the exporter as a key with no value.
 				span.setAttributes({
 					[GENAI.TOOL_NAME]: toolName,
 					[GENAI.TOOL_TYPE]: 'function',
+					...(context.toolUseId !== undefined ? { [GENAI.TOOL_CALL_ID]: context.toolUseId } : {}),
 				})
 
 				const tool = this.getOrThrow(toolName)

package/src/runtime/query/executor.ts

@@ -34,6 +34,7 @@ import type {
 	ToolCallRepairReason,
 } from '../../types/tool/repair.js'
 import { abortReasonText } from '../../utils/abort.js'
+import { type BackoffPolicy, backoffWithJitter, sleep } from '../../utils/backoff.js'
 import { toErrorMessage } from '../../utils/error.js'
 import type { Logger } from '../../utils/logger.js'
 import { compressShellOutput } from '../../utils/shell-compress.js'
@@ -74,6 +75,33 @@ export const DEFAULT_TOOL_CONCURRENCY = 8
  */
 export const HOOK_RETRY_BUDGET = 1
 
+/**
+ * Wait between in-loop tool retry attempts.
+ *
+ * There was none. A tool that declared itself retryable was re-run the
+ * instant it failed, as many times as its budget allowed — and the failures
+ * worth retrying are the ones an immediate retry makes worse: a rate limit
+ * answers the second call faster than it recovers, a contended lock is still
+ * held, a connection that has not finished opening has not finished opening.
+ *
+ * The numbers are the provider policy's, deliberately, and not because a tool
+ * is a model call. Nothing here has been measured against tools specifically,
+ * and inventing a second curve to look considered would be a guess wearing
+ * different digits; the shared one is at least the curve this codebase has
+ * already run in anger. Full jitter draws each wait from `[0, curve]`, so the
+ * first retry of a tool with the shipped budget waits under half a second on
+ * average.
+ *
+ * The ceiling is inert at the budgets anyone sets — a tool declaring
+ * `maxRetries: 3` never reaches 2s — and binds only a host that sets a large
+ * one. Override with {@link ToolExecutorConfig.toolRetryBackoff}; set
+ * `initialDelayMs: 0` for the previous no-wait behaviour.
+ */
+export const DEFAULT_TOOL_RETRY_BACKOFF: BackoffPolicy = {
+	initialDelayMs: 500,
+	maxDelayMs: 16_000,
+}
+
 /**
  * An empty arguments string means "no arguments", not "malformed" — the
  * shape a no-parameter tool arrives in.
@@ -95,6 +123,16 @@ export interface ToolExecutorConfig {
 	pluginManager?: PluginLifecycleManager
 	/** Run-level default deadline; per-tool `timeoutMs` overrides it. */
 	toolTimeoutMs?: number
+	/**
+	 * Wait between in-loop retries of a failed tool call. Defaults to
+	 * {@link DEFAULT_TOOL_RETRY_BACKOFF}.
+	 *
+	 * Applies only to a tool that opted into retrying at all
+	 * ({@link ToolDefinition.maxRetries}) or to a `post_tool_use` hook that
+	 * asked for one, so a run whose tools all take the shipped default of
+	 * zero retries never sleeps here.
+	 */
+	toolRetryBackoff?: Partial<BackoffPolicy>
 	/** Max concurrently-executing concurrency-safe tools. */
 	maxToolConcurrency?: number
 
@@ -648,6 +686,10 @@ export class ToolExecutor {
 		// because the SDK cannot know a tool is idempotent — silently
 		// re-running a write or a payment is worse than never retrying.
 		const maxRetries = Math.max(0, this.config.tools.get(toolName)?.maxRetries ?? 0)
+		const backoff: BackoffPolicy = {
+			...DEFAULT_TOOL_RETRY_BACKOFF,
+			...this.config.toolRetryBackoff,
+		}
 		for (let attempt = 1; ; attempt++) {
 			// A missing file will not appear on the second attempt; burning
 			// the budget on it only delays the error the model needs to see.
@@ -664,14 +706,46 @@ export class ToolExecutor {
 			const budget = post.retry ? Math.max(maxRetries, HOOK_RETRY_BUDGET) : maxRetries
 			if (attempt > budget) break
 
+			// Wait before trying again, on the curve the provider path has
+			// used all along. This loop had NO delay: a tool failing on a
+			// transient condition — a rate-limited HTTP call, a lock, a cold
+			// connection — was re-run immediately, several times, which is the
+			// pattern most likely to prolong the very condition it is retrying
+			// against.
+			//
+			// Full jitter rather than a fixed wait, and the concurrency that
+			// makes it matter is one this loop creates itself: a model emits a
+			// batch of parallel calls, `executeBatch` runs up to
+			// DEFAULT_TOOL_CONCURRENCY of them at once, they hit the same
+			// rate-limited endpoint and fail together. A fixed backoff would
+			// resynchronise that batch on every attempt.
+			//
+			// `attempt` is 1-based here and `backoffWithJitter` is 0-based, so
+			// the first retry draws from `[0, initialDelayMs]`.
+			const delayMs = backoffWithJitter(attempt - 1, backoff)
+
 			this.log.info('Retrying a failed tool call', {
 				runId: this.config.runId,
 				tool: toolName,
 				attempt,
 				budget,
 				requestedByHook: post.retry,
+				delayMs,
 				error: result.error,
 			})
+
+			try {
+				await sleep(delayMs, this.config.abortSignal)
+			} catch {
+				// Stopped mid-backoff. Give up retrying and let the failure
+				// already in `result` be this call's answer, rather than
+				// throwing: every `tool_use` must be answered by a
+				// `tool_result` with the same id, and an abort escaping from
+				// here would leave this one open in the transcript for a
+				// resume to trip over.
+				break
+			}
+
 			result = await this.runOnce(toolName, input, toolContext)
 			post = await this.runPostToolHook(toolName, input, result)
 		}

package/src/runtime/query/index.ts

@@ -83,6 +83,7 @@ import type { TaskStore } from '../../types/task/index.js'
 import type { ToolRegistryContract } from '../../types/tool/index.js'
 import type { RepairToolCall } from '../../types/tool/repair.js'
 import type { VerificationGateConfig } from '../../types/verification/index.js'
+import type { BackoffPolicy } from '../../utils/backoff.js'
 import type { ModelPricing } from '../../utils/cost.js'
 import { getRootLogger } from '../../utils/logger.js'
 import { VerificationGate } from '../../verification/gate.js'
@@ -98,7 +99,7 @@ import { isWorkingMemoryMessage } from './iteration/phases/working-memory.js'
 import { applyLifecycleHookResults } from './plugin-hooks.js'
 import { PromptBuilder } from './prompt.js'
 import type { PromptSegments } from './prompt.js'
-import type { PendingAnswers, QuestionParkBinding } from './question-park.js'
+import { PendingAnswers, QuestionParkBinding } from './question-park.js'
 import { ResultAssembler } from './result.js'
 import {
 	type PendingResumePlan,
@@ -168,14 +169,20 @@ export interface QueryParams {
 	emergencySave?: boolean
 
 	/**
-	 * Durability for questions raised from inside a tool.
+	 * Durability for questions raised by a tool that closed over its
+	 * binding before the run existed.
 	 *
-	 * The tool that asks is built before the run exists, so the binding is
-	 * created by whoever builds the tools and attached here — that is what
-	 * lets one tool instance be durable inside a run and inert outside one.
-	 * Without it, a question park exists only as a suspended `await`: kill
-	 * the process while somebody is looking at the card and the answer can
-	 * never be applied.
+	 * The built-in `ask_user_question` is built with the agent's tool
+	 * registry, so only whoever builds the tools can hand it one — that is
+	 * what lets a single tool instance be durable inside a run and inert
+	 * outside one. Without it, THAT tool's park is only a suspended
+	 * `await`: kill the process while somebody is looking at the card and
+	 * the answer can never be applied.
+	 *
+	 * Not required for `ToolContext.requestPause`. The run builds that
+	 * seam per call and binds its own recorder when none is passed, so a
+	 * pause raised from a host-authored tool is durable on every surface
+	 * rather than only on the one agent class that supplies this.
 	 */
 	questionParks?: QuestionParkBinding
 
@@ -192,16 +199,28 @@ export interface QueryParams {
 	/**
 	 * The registry a re-entered `ask_user_question` reads its answer from.
 	 *
-	 * Same shape as {@link questionParks}: the tool is built before the run
-	 * exists, so the instance is created by whoever builds the tools and
-	 * filled here on the resume path. Without it a resumed run re-asks a
-	 * question the user already answered.
+	 * Same shape, same reason and same limit as {@link questionParks}: it
+	 * exists for a tool that closed over the instance before the run did,
+	 * and without it a resumed run re-asks that tool's question. A pause
+	 * from `ToolContext.requestPause` needs none, because the run fills
+	 * its own on the resume path.
 	 */
 	pendingAnswers?: PendingAnswers
 
 	/** Default per-tool execution deadline. See {@link ToolDefinition.timeoutMs}. */
 	toolTimeoutMs?: number
 
+	/**
+	 * Wait between in-loop retries of a failed tool call, with full jitter.
+	 * Defaults to {@link DEFAULT_TOOL_RETRY_BACKOFF}.
+	 *
+	 * Only reached by a tool that opted into retrying
+	 * ({@link ToolDefinition.maxRetries}) or a `post_tool_use` hook that asked
+	 * for one. Set `initialDelayMs: 0` for the retry-immediately behaviour
+	 * this loop had before it had any backoff at all.
+	 */
+	toolRetryBackoff?: Partial<BackoffPolicy>
+
 	/** Max concurrently-executing concurrency-safe tools in one batch. */
 	maxToolConcurrency?: number
 
@@ -874,6 +893,25 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		? []
 		: withDeferredDiscoveryTool(params.tools, params.allowedTools)
 
+	// The two halves of a durable pause, owned by the RUN when the host
+	// does not own them.
+	//
+	// `SupervisorAgent` builds both before the run exists, because the
+	// tools it builds close over them, and it passes them in. Nothing else
+	// could: neither type is exported from `public-runtime.ts`, so a host
+	// on `ReactiveAgent`, `drainQuery` or `resumeRun` had no way to supply
+	// either — and `ToolContext.requestPause`, which every tool author is
+	// handed, silently wrote no checkpoint and could receive no answer on
+	// those surfaces. Which agent class the host happened to pick is not
+	// visible at the call site, so the degradation was invisible too.
+	//
+	// A run-local pair is enough for the general seam because `query()`
+	// builds its `createToolPause` itself, below, and can hand it the
+	// run's own. Pinned by the "a pause is durable on any surface" cases
+	// in `__tests__/tool-pause-resume.test.ts`.
+	const questionParks = params.questionParks ?? new QuestionParkBinding()
+	const pendingAnswers = params.pendingAnswers ?? new PendingAnswers()
+
 	//  is null only when the run has no disk layout (tests,
 	// in-memory hosts); the budget then degrades to middle-elision.
 	const runDirForTools = ctx.runMgr.getRunDir()
@@ -891,6 +929,9 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			invocationState: params.invocationState,
 			pluginManager: params.pluginManager,
 			...(params.toolTimeoutMs !== undefined ? { toolTimeoutMs: params.toolTimeoutMs } : {}),
+			...(params.toolRetryBackoff !== undefined
+				? { toolRetryBackoff: params.toolRetryBackoff }
+				: {}),
 			...(params.maxToolConcurrency !== undefined
 				? { maxToolConcurrency: params.maxToolConcurrency }
 				: {}),
@@ -915,8 +956,8 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 					runId: ctx.runId,
 					toolUseId,
 					parkHandler: params.resumeHandler,
-					...(params.questionParks ? { recorder: params.questionParks } : {}),
-					...(params.pendingAnswers ? { pendingAnswers: params.pendingAnswers } : {}),
+					recorder: questionParks,
+					pendingAnswers,
 				}),
 		},
 		ctx.activityStore,
@@ -1130,7 +1171,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		// the checkpoint did not exist: nothing on disk said a human owed
 		// this run an answer, and a remote host could not observe the
 		// question at all.
-		params.questionParks?.bind({
+		questionParks.bind({
 			record: async (question) => {
 				try {
 					const checkpoint = await checkpointMgr.create(ctx.runMgr, ctx.runMgr.currentIteration)
@@ -1537,9 +1578,9 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 				// closed over its registry when the agent was constructed,
 				// long before this run existed, so the answers are copied in
 				// rather than passed down.
-				if (pendingResume.answers && params.pendingAnswers) {
+				if (pendingResume.answers) {
 					for (const [questionId, answer] of pendingResume.answers.entries()) {
-						params.pendingAnswers.set(questionId, answer)
+						pendingAnswers.set(questionId, answer)
 					}
 				}
 
@@ -1642,7 +1683,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			// Same reasoning for the question channel: the tools outlive the
 			// run that bound them, so leaving it attached would have a later
 			// run's question written into this run's checkpoint store.
-			params.questionParks?.unbind()
+			questionParks.unbind()
 
 			// Offer what the run learned to whoever decides what is worth
 			// keeping. In `finally` and awaited: a run that failed still