@namzu/sdk 53.2.2 → 55.0.0

package/src/runtime/cache-clock.ts

@@ -0,0 +1,67 @@
+import type { TokenUsage } from '../types/common/index.js'
+
+/** What the clock knows about the prompt cache after the latest model call. */
+export interface CacheClockState {
+	/** When the last call that touched the cache finished (ms since epoch). */
+	readonly lastActivityAt: number
+	/** How long the provider keeps the cache, as that call reported it. */
+	readonly ttlMs: number
+	/**
+	 * When the cache lapses: `lastActivityAt + ttlMs`. Only set when the call
+	 * actually read or wrote cache; a call that touched none leaves the cache
+	 * (and so its expiry) unknown rather than assumed.
+	 */
+	readonly expiresAt: number | null
+}
+
+/**
+ * Tracks when a conversation's prompt cache will lapse.
+ *
+ * Fed by each completed model call. The lifetime is never guessed: a call whose
+ * usage carries no `cacheTtlMs` (a driver that does not report one) clears the
+ * clock, so nothing downstream can act on a lifetime nobody stated. Pure of
+ * timers: the caller passes `now`.
+ */
+export class CacheClock {
+	#state: CacheClockState | null = null
+
+	/** Record a finished call. `usage` is that call's own usage, not a turn total. */
+	record(usage: TokenUsage, at: number): void {
+		if (usage.cacheTtlMs === undefined || !(usage.cacheTtlMs > 0)) {
+			this.#state = null
+			return
+		}
+		const touched = usage.cachedTokens + usage.cacheWriteTokens > 0
+		this.#state = {
+			lastActivityAt: at,
+			ttlMs: usage.cacheTtlMs,
+			expiresAt: touched ? at + usage.cacheTtlMs : null,
+		}
+	}
+
+	/** Forget everything (the conversation was replaced or its context rewritten). */
+	reset(): void {
+		this.#state = null
+	}
+
+	get state(): CacheClockState | null {
+		return this.#state
+	}
+
+	/** Whether the cache is still alive at `now`. False when unknown. */
+	warm(now: number): boolean {
+		const state = this.#state
+		return state !== null && state.expiresAt !== null && now < state.expiresAt
+	}
+
+	/**
+	 * The moment `fraction` of the cache's remaining life since the last
+	 * activity has passed: `lastActivityAt + (expiresAt - lastActivityAt) * fraction`.
+	 * `null` when the expiry is unknown.
+	 */
+	dueAt(fraction: number): number | null {
+		const state = this.#state
+		if (state === null || state.expiresAt === null) return null
+		return state.lastActivityAt + (state.expiresAt - state.lastActivityAt) * fraction
+	}
+}

package/src/runtime/query/checkpoint.ts

@@ -19,11 +19,12 @@ import {
 	type UserMessage,
 	createRuntimeContextMessage,
 } from '../../types/message/index.js'
+import { escapeNoticeFrame } from '../../types/message/notice-frame.js'
 import { CHECKPOINT_DOCUMENT_VERSION, type Checkpoint } from '../../types/session/checkpoint.js'
 import type { CheckpointListEntry } from '../../types/session/fork.js'
 import type { SessionRecord } from '../../types/session/records.js'
 import { asGoalId, generateCheckpointId } from '../../utils/id.js'
-import { formatSteeringNote, readSteeringNote } from './steering.js'
+import { readSteeringNote } from './steering.js'
 
 /** Keep intent text/provenance without copying attachment payloads into a second slot. */
 function snapshotUserIntent(value: unknown): UserMessage {
@@ -460,8 +461,8 @@ export class CheckpointManager {
 
 	/**
 	 * The id of the record that carries a message's text: its own record,
-	 * or — for operator guidance delivered attached to a tool result — the
-	 * record of the tool result that carries it.
+	 * or, for the operator's message sent while a tool ran, the record of the
+	 * framed message that carries it.
 	 */
 	private messageIdOf(recorder: TurnRecorder, message: Message): MessageId | undefined {
 		if (message === this.restoredUserMessage) return this.restoredUserMessageId
@@ -483,14 +484,17 @@ export class CheckpointManager {
 		) {
 			return undefined
 		}
-		const note = formatSteeringNote(message.content)
+		// The operator's words were sent as a framed message of their own whose
+		// marker is random, so it is found by what its frame holds.
+		const wanted = escapeNoticeFrame(message.content)
 		const messages = recorder.messages
 		for (let i = messages.length - 1; i >= 0; i--) {
 			const candidate = messages[i] as Message
 			if (
-				candidate.role === 'tool' &&
+				candidate.role === 'user' &&
 				typeof candidate.content === 'string' &&
-				candidate.content.endsWith(note)
+				(candidate as UserMessage).source?.type === 'runtime-context' &&
+				readSteeringNote(candidate.content) === wanted
 			) {
 				const id = recorder.recordedIdOf(candidate)
 				if (id) this.steeringCarriers.set(message, id)
@@ -578,6 +582,42 @@ export class CheckpointManager {
 		return park
 	}
 
+	/**
+	 * End the parks that were the other questions of a batch whose decision has
+	 * just been applied (the per-call review parks one question per call).
+	 *
+	 * The batch is answered now, so a question about one of its calls is moot;
+	 * left open, an approval queue would keep serving it and a host resuming it
+	 * would rewind the turn to a batch that has long since been carried out.
+	 * Recorded as superseded, not as an answer: nobody gave one.
+	 */
+	async supersedeBatchParks(
+		callIds: ReadonlySet<string>,
+		except: CheckpointId,
+		superseding: HITLResumeDecision,
+	): Promise<number> {
+		await this.recorder.flush()
+		const parks = await readParks(this.recorder.log, {
+			turnId: this.scope.turnId,
+		})
+		let ended = 0
+		for (const park of parks) {
+			const request = park.pending.request
+			if (
+				park.checkpointId === except ||
+				park.pending.resolvedAt !== undefined ||
+				request.type !== 'tool_review' ||
+				request.perCall !== true ||
+				!request.toolCalls.every((call) => callIds.has(call.id))
+			) {
+				continue
+			}
+			await this.unpark(park.checkpointId, superseding)
+			ended += 1
+		}
+		return ended
+	}
+
 	private async openPark(checkpointId: CheckpointId): Promise<RecordedPark | null> {
 		await this.recorder.flush()
 		const parks = await readParks(this.recorder.log, { turnId: this.scope.turnId })
@@ -693,9 +733,10 @@ export async function restoreCheckpointContext(
 			`Checkpoint latestUserMessage names message ${intentId}, which its session log does not hold`,
 		)
 	}
-	// Guidance delivered attached to a tool result: the intent is the note.
+	// Guidance the operator sent while a tool ran: the intent is the note, whether
+	// it is a message of its own or, in an older session, the end of a tool result.
 	const guidance =
-		intent?.role === 'tool' && typeof intent.content === 'string'
+		(intent?.role === 'tool' || intent?.role === 'user') && typeof intent.content === 'string'
 			? readSteeringNote(intent.content)
 			: undefined
 	const operatorIntent =

package/src/runtime/query/compact-session.ts

@@ -1,4 +1,9 @@
-import { type CompactNowInput, type CompactionResult, compactNow } from '../../compaction/manual.js'
+import {
+	type CompactNowInput,
+	type CompactionResult,
+	compactNow,
+	compactRegion,
+} from '../../compaction/manual.js'
 import { readFoldedHistory } from '../../manager/session/turn-recorder.js'
 import { NamzuError } from '../../types/errors/index.js'
 import type { MessageId, SessionId } from '../../types/ids/index.js'
@@ -10,13 +15,19 @@ import { type SessionLocatorOptions, locateSessionLog, withSessionLease } from '
 /** A compaction a host asks for between turns. */
 export interface CompactSessionParams extends Omit<CompactNowInput, 'messages' | 'onShed'> {
 	readonly sessionId: SessionId
+	/**
+	 * Who asked. `'manual'` (the default) is a person's request; `'idle'` is a
+	 * host compacting a conversation nobody is using before its prompt cache
+	 * lapses. Recorded on the `compaction` record.
+	 */
+	readonly trigger?: 'manual' | 'idle'
 	/** Where to find the session's log, and the lease to append under. */
 	readonly locator?: SessionLocatorOptions
 }
 
 /**
  * Compact a session outside any turn. Reads the session's context from its
- * log, compacts it, and appends a `compaction{ trigger: 'manual' }` record
+ * log, compacts it, and appends a `compaction{ trigger }` record (`'manual'` unless the host says `'idle'`)
  * with no `turnId`: the messages the pass kept are named by id, the summary
  * is recorded in full, and the shed messages stay in the log for audit.
  *
@@ -26,7 +37,7 @@ export interface CompactSessionParams extends Omit<CompactNowInput, 'messages' |
 export async function compactSession(
 	params: CompactSessionParams,
 ): Promise<CompactionResult | null> {
-	const { sessionId, locator = {}, ...input } = params
+	const { sessionId, locator = {}, trigger = 'manual', ...input } = params
 	const log = await locateSessionLog(sessionId, locator)
 	return withSessionLease(log, locator.lease, async (lease) => {
 		const active = await log.activeTurn({ lease })
@@ -47,6 +58,93 @@ export async function compactSession(
 			})
 		}
 		const { summary, keptMessageIds } = compactionShape(result.messages, ids)
+		await log.append(lease, {
+			type: 'compaction',
+			compactionId: generateMessageId(),
+			strategy: input.config.strategy,
+			trigger,
+			replacesSeqRange: [1, head.pointer.seq],
+			summary,
+			keptMessageIds,
+			tokensBefore: 0,
+			tokensAfter: 0,
+		})
+		return result
+	})
+}
+
+/** A compaction of one span of a session's context, asked for between turns. */
+export interface CompactSessionRangeParams extends CompactSessionParams {
+	/**
+	 * The first message to summarise, by the id the log recorded it under.
+	 * Omitted: the span starts at the beginning of the context.
+	 */
+	readonly from?: MessageId
+	/**
+	 * The message the span stops before; it and everything after it stay as
+	 * they are. Omitted: the span runs to the end of the context.
+	 */
+	readonly until?: MessageId
+}
+
+/**
+ * Compact one span of a session's context outside any turn.
+ *
+ * Like {@link compactSession}, but only the messages from `from` up to (not
+ * including) `until` are summarised; the rest of the context stays verbatim.
+ * A host uses it to fold away "everything before this message" or "this
+ * message and everything after it" without touching the other side. Pinned
+ * (`retain`) messages inside the span stay as they are.
+ *
+ * Throws `not_found` when `from` or `until` is not in the session's current
+ * context (a compaction may already have folded it away), and
+ * `invalid_config` when a boundary would split a tool call from its result.
+ * `null` when the span holds nothing worth summarising; nothing is appended
+ * then. Refused while a turn is active (`TurnInProgressError`).
+ */
+export async function compactSessionRange(
+	params: CompactSessionRangeParams,
+): Promise<CompactionResult | null> {
+	const { sessionId, locator = {}, from, until, ...input } = params
+	const log = await locateSessionLog(sessionId, locator)
+	return withSessionLease(log, locator.lease, async (lease) => {
+		const active = await log.activeTurn({ lease })
+		if (active) {
+			throw new TurnInProgressError({ sessionId, activeTurnId: active.turnId, state: active.state })
+		}
+		const history = await readFoldedHistory(log)
+		const position = (id: MessageId | undefined, fallback: number): number => {
+			if (id === undefined) return fallback
+			const at = history.findIndex((entry) => entry.messageId === id)
+			if (at < 0) {
+				throw new NamzuError({
+					code: 'not_found',
+					message: `Message ${id} is not in session ${sessionId}'s current context; it may already have been summarised.`,
+					details: { sessionId, messageId: id },
+				})
+			}
+			return at
+		}
+		const start = position(from, 0)
+		const end = position(until, history.length)
+		const ids = new Map<Message, MessageId>()
+		for (const entry of history) if (entry.messageId) ids.set(entry.message, entry.messageId)
+		const result = await compactRegion({
+			...input,
+			messages: history.map((entry) => entry.message),
+			start,
+			end,
+		})
+		if (!result) return null
+		const head = await log.head()
+		if (!head) {
+			throw new NamzuError({
+				code: 'not_found',
+				message: `Session ${sessionId} has an empty log; there is nothing to compact.`,
+				details: { sessionId },
+			})
+		}
+		const { summary, keptMessageIds } = compactionShape(result.messages, ids)
 		await log.append(lease, {
 			type: 'compaction',
 			compactionId: generateMessageId(),

package/src/runtime/query/executor/tool-call-admission.ts

@@ -290,6 +290,9 @@ export async function prepareDirectCall(
 			...(providerInput && !repairUsed && preparation.inputFailure
 				? { inputFailure: preparation.inputFailure }
 				: {}),
+			// The registry's typed reason (e.g. invalid arguments) is what a
+			// host keys its short label on; the message alone is wording.
+			...(preparation.result.facts ? { facts: preparation.result.facts } : {}),
 		}
 	}
 

package/src/runtime/query/executor.ts

@@ -567,6 +567,43 @@ export interface ToolCallOutcome {
 	revealedTools?: readonly ToolRevealReceipt[]
 }
 
+/** What the per-call review decided about one call that reached the front of the walk. */
+export type CallAdmission =
+	| { readonly run: true }
+	| {
+			readonly run: false
+			readonly reason: string
+			readonly declined?: ToolCallDeclined
+	  }
+
+/**
+ * The per-call review, as the executor sees it: a batch executed while its
+ * calls are still being asked about.
+ *
+ * The executor walks the calls in the model's order. A call that is safe to run
+ * beside others starts as soon as every call already in flight is also safe;
+ * any other call starts only when nothing is in flight, so it never overlaps an
+ * earlier call, and nothing after it starts before it does. Starting a call
+ * means asking `admit` and, on a yes, running it right away.
+ */
+export interface ReviewedExecution {
+	admit(call: ToolCall, index: number): Promise<CallAdmission>
+	/**
+	 * Aborts when a refusal ends the turn. Calls that are running are cancelled
+	 * through it, and a call that has not started is refused without `admit`
+	 * being consulted for a yes.
+	 */
+	readonly ended: AbortSignal
+}
+
+interface ReviewUnit {
+	readonly index: number
+	readonly toolCall: ToolCall
+	readonly preparedCall?: PreparedDirectCall
+	readonly safe: boolean
+	readonly run: () => Promise<void>
+}
+
 export interface ToolExecutionBatch {
 	messages: Message[]
 	results: ToolCallOutcome[]
@@ -1268,6 +1305,7 @@ export class ToolExecutor {
 		prior?: PriorToolResults,
 		preparedBatch?: PreparedToolBatch,
 		declines?: ToolCallDeclines,
+		review?: ReviewedExecution,
 	): Promise<ToolExecutionBatch> {
 		const toolCalls = response.message.toolCalls
 		if (!toolCalls) {
@@ -1294,9 +1332,9 @@ export class ToolExecutor {
 			if (refusal) {
 				const refused = new Map(denials)
 				for (const call of toolCalls) if (!refused.has(call.id)) refused.set(call.id, refusal)
-				return await this.runBatch(toolCalls, refused, prior, owned, declines)
+				return await this.runBatch(toolCalls, refused, prior, owned, declines, review)
 			}
-			return await this.runBatch(toolCalls, denials, prior, owned, declines)
+			return await this.runBatch(toolCalls, denials, prior, owned, declines, review)
 		} finally {
 			// Cleared so a later single execution outside a batch resolves
 			// live rather than inheriting the last batch's sample.
@@ -1310,6 +1348,7 @@ export class ToolExecutor {
 		prior?: PriorToolResults,
 		preparedBatch?: OwnedPreparedToolBatch,
 		declines?: ToolCallDeclines,
+		review?: ReviewedExecution,
 	): Promise<ToolExecutionBatch> {
 		this.log.debug('Executing tool batch', {
 			[NAMZU.TURN_ID]: this.config.turnId,
@@ -1370,6 +1409,9 @@ export class ToolExecutor {
 		// gate keeps that at a working-set size while preserving completion
 		// order independence.
 		const gate = new Semaphore(this.config.maxToolConcurrency ?? DEFAULT_TOOL_CONCURRENCY)
+		// Under a per-call review the calls to run are collected here and walked
+		// afterwards; refusals that were settled before the review need no walk.
+		const reviewUnits: ReviewUnit[] = []
 		toolCalls.forEach((toolCall, i) => {
 			const preparedCall = preparedBatch?.calls.get(toolCall.id)
 			const tool = this.config.tools.get(preparedCall?.toolName ?? toolCall.function.name)
@@ -1391,7 +1433,7 @@ export class ToolExecutor {
 						? { structuredResultJson: recovered.structuredResultJson }
 						: {}),
 				}
-				if (isBarrier) schedule(async () => {}, true, true)
+				if (isBarrier && !review) schedule(async () => {}, true, true)
 				return
 			}
 
@@ -1400,18 +1442,16 @@ export class ToolExecutor {
 				// Denied calls never touch the tool; they still get a result
 				// message so the assistant turn stays fully answered. They can
 				// overlap other calls within a segment, respecting its barriers.
-				schedule(
-					async () => {
-						results[i] = await this.recordDenial(
-							toolCall,
-							denialReason,
-							preparedCall,
-							declines?.get(toolCall.id),
-						)
-					},
-					true,
-					isBarrier,
-				)
+				const recordDenied = async () => {
+					results[i] = await this.recordDenial(
+						toolCall,
+						denialReason,
+						preparedCall,
+						declines?.get(toolCall.id),
+					)
+				}
+				if (review) parallel.push(recordDenied())
+				else schedule(recordDenied, true, isBarrier)
 				return
 			}
 			// Per-call, because the event has to name which call it is about:
@@ -1436,6 +1476,13 @@ export class ToolExecutor {
 				...(escalation?.outsidePaths ? { approvedPaths: escalation.outsidePaths } : {}),
 				...(escalation?.sandboxEscape ? { sandboxEscapeApproved: true } : {}),
 				source: { kind: 'direct' },
+				// A refusal that ends the turn cancels what is running, through the
+				// same signal a tool already honours for a cancelled turn.
+				...(review
+					? {
+							abortSignal: AbortSignal.any([baseContext.abortSignal, review.ended]),
+						}
+					: {}),
 				// Overridden per call, so a nested dispatch can name the call
 				// that made it. The base context has no `toolUseId`, and a
 				// closure built there would report every nested call as
@@ -1477,8 +1524,19 @@ export class ToolExecutor {
 				// non-JSON args → treat as unsafe (serialize), the conservative path
 			}
 			const safe = tool?.isConcurrencySafe?.(input) === true
+			if (review) {
+				reviewUnits.push({
+					index: i,
+					toolCall,
+					...(preparedCall ? { preparedCall } : {}),
+					safe: safe && !isBarrier,
+					run: safe ? gated : run,
+				})
+				return
+			}
 			schedule(safe ? gated : run, safe, isBarrier)
 		})
+		if (review) await this.walkReviewed(reviewUnits, results, review)
 		await Promise.all([...parallel, serial])
 
 		// Whatever failed above left a hole in `results`; fill every one, so
@@ -1518,6 +1576,98 @@ export class ToolExecutor {
 		return { messages, results, observations }
 	}
 
+	/**
+	 * Walk the calls of a batch in the model's order, asking about each as it
+	 * reaches the front and running it right after a yes.
+	 *
+	 * A call may start when nothing is in flight, or when it and every call in
+	 * flight are safe to run side by side. The walk stops at the first call that
+	 * may not start yet, so an unsafe call is never overtaken by one that came
+	 * after it. Once a refusal has ended the turn, nothing waits: every call that
+	 * has not started is refused at once and the ones in flight are cancelled.
+	 */
+	private async walkReviewed(
+		units: readonly ReviewUnit[],
+		results: ToolCallOutcome[],
+		review: ReviewedExecution,
+	): Promise<void> {
+		const inFlight = new Set<ReviewUnit>()
+		let cursor = 0
+		let failure: { readonly error: unknown } | undefined
+		// Once the turn has ended, a refusal is written only after every call
+		// before it has settled, so the transcript lists the calls in the order the
+		// model wrote them: the declined call before the ones refused unasked.
+		const settledUnits = new Map<number, Promise<void>>()
+		const refusedAfterEnd =
+			'An earlier call in this batch was refused and the turn was stopped, so this call was not run.'
+		await new Promise<void>((resolve) => {
+			const start = (unit: ReviewUnit): void => {
+				inFlight.add(unit)
+				let settledUnit!: () => void
+				settledUnits.set(
+					unit.index,
+					new Promise<void>((done) => {
+						settledUnit = done
+					}),
+				)
+				void (async () => {
+					try {
+						let admission: CallAdmission
+						try {
+							admission = await review.admit(unit.toolCall, unit.index)
+						} catch {
+							// An answer that could not be obtained is not a yes.
+							admission = {
+								run: false,
+								reason: 'The approval for this call could not be completed, so it was not run.',
+							}
+						}
+						if (admission.run && !review.ended.aborted) {
+							await unit.run()
+						} else {
+							const refusal = admission.run
+								? { reason: refusedAfterEnd }
+								: { reason: admission.reason, declined: admission.declined }
+							if (review.ended.aborted) {
+								await Promise.all(
+									[...settledUnits].filter(([index]) => index < unit.index).map(([, done]) => done),
+								)
+							}
+							results[unit.index] = await this.recordDenial(
+								unit.toolCall,
+								refusal.reason,
+								unit.preparedCall,
+								'declined' in refusal ? refusal.declined : undefined,
+							)
+						}
+					} catch (error) {
+						failure ??= { error }
+					} finally {
+						settledUnit()
+						inFlight.delete(unit)
+						pump()
+					}
+				})()
+			}
+			const pump = (): void => {
+				while (cursor < units.length) {
+					const unit = units[cursor] as ReviewUnit
+					if (!review.ended.aborted) {
+						const mayStart =
+							inFlight.size === 0 || (unit.safe && [...inFlight].every((other) => other.safe))
+						if (!mayStart) break
+					}
+					cursor++
+					start(unit)
+				}
+				if (cursor >= units.length && inFlight.size === 0) resolve()
+			}
+			review.ended.addEventListener('abort', pump, { once: true })
+			pump()
+		})
+		if (failure) throw failure.error
+	}
+
 	/**
 	 * Hold the batch's combined result text under the per-message cap.
 	 *

package/src/runtime/query/index.ts

@@ -786,6 +786,15 @@ export interface QueryParams {
 	 * See {@link ReminderSource}.
 	 */
 	reminders?: import('./reminders.js').ReminderSource
+	/**
+	 * Whether the kernel tells the model, once, that the approval policy
+	 * changed ("Approval policy changed from X to Y ..."), as request-only
+	 * context after the history. Default `true`. A host that already tells the
+	 * model about a mode change itself (through `reminders`) sets `false` so
+	 * the model hears it once; the `approval_policy_changed` event is
+	 * recorded either way.
+	 */
+	announceApprovalPolicyChange?: boolean
 
 	/**
 	 * Wake a background-task hold when operator input is available, without draining it.
@@ -840,6 +849,16 @@ export interface QueryParams {
 	 */
 	reviewAllowedCalls?: () => boolean
 
+	/**
+	 * Ask about one call at a time while the batch runs, instead of reviewing the
+	 * whole batch as a unit. Opt-in; absent, nothing about review changes. See
+	 * {@link import('../../types/hitl/index.js').PerCallReviewConfig}.
+	 *
+	 * Only this turn is affected: a delegated child reviews its own batches as
+	 * it did before.
+	 */
+	perCallReview?: import('../../types/hitl/index.js').PerCallReviewConfig
+
 	/**
 	 * A name for the policy `resumeHandler` implements.
 	 *
@@ -1770,7 +1789,11 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			// Read through the box on every call, so a swap lands on the next
 			// question rather than the next turn.
 			resumeHandler: (request, context) => approvalPolicy.current.handler(request, context),
-			takeApprovalPolicyChange: () => approvalPolicy.takeUnannouncedChange(),
+			takeApprovalPolicyChange: () => {
+				// Taken either way, so the change is not left pending for a later turn.
+				const change = approvalPolicy.takeUnannouncedChange()
+				return params.announceApprovalPolicyChange === false ? undefined : change
+			},
 			promptContributions,
 			...(params.steering ? { steering: params.steering } : {}),
 			...(jobNotices ? { jobNotices } : {}),
@@ -1788,6 +1811,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			toolGrants: new ToolGrantSet(),
 			skillGrants,
 			...(params.reviewAllowedCalls ? { reviewAllowedCalls: params.reviewAllowedCalls } : {}),
+			...(params.perCallReview ? { perCallReview: params.perCallReview } : {}),
 			// Turn-scoped for the same reason. A repeat count carried into a later
 			// run is a claim about work nobody repeated, and a module-level map
 			// would leak exactly that way.
@@ -2690,6 +2714,26 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 							})
 							return null
 						})
+					// A decision about one call of a batch answered the batch: the
+					// batch's other open questions are moot.
+					if (pendingResume?.partial && params.pendingDecision) {
+						const batchIds = new Set(
+							pendingResume.response.message.toolCalls?.map((call) => call.id) ?? [],
+						)
+						await checkpointMgr
+							.supersedeBatchParks(
+								batchIds,
+								resolvedCheckpointId,
+								supersededByRecovery(params.pendingDecision),
+							)
+							.catch((err: unknown) => {
+								ctx.log.error('Applied a pending decision but failed to clear its sibling parks', {
+									[NAMZU.TURN_ID]: ctx.turnId,
+									'exception.message': err instanceof Error ? err.message : String(err),
+								})
+								return 0
+							})
+					}
 				}
 
 				yield* iterationOrchestrator.runLoop()