@namzu/sdk 51.1.0 → 52.1.0

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

@@ -0,0 +1,108 @@
+/**
+ * Two ways automatic compaction gives up for the rest of a turn.
+ *
+ * - Three failures in a row (a pass that ran and shed nothing): every one of
+ *   them paid for a summary or a reducer call and left the history as it was,
+ *   so a fourth would do the same. Proactive compaction is skipped from then on
+ *   and the turn carries on, silently as far as the person is concerned (a log
+ *   line and a `breaker_open` event, no sentence); a pass the provider forces
+ *   by rejecting the prompt is not gated, so the reactive ladder still runs.
+ * - Three compactions in a row, each followed by the context filling back up
+ *   within three iterations: something in the loop (a huge file read, a tool
+ *   that prints without limit) refills the window faster than any summary can
+ *   empty it. The turn stops, because carrying on only buys the same wall.
+ *
+ * Off unless `compactionConfig.circuitBreaker` is true: stopping compaction,
+ * and above all stopping a turn, is not something a host had before.
+ *
+ * State is per turn, held against the turn's recorder, so two turns never
+ * share a count.
+ */
+
+import type { IterationContext } from './context.js'
+
+/** Consecutive failed passes after which automatic compaction stops. */
+export const COMPACTION_FAILURE_LIMIT = 3
+/** A compaction followed by a trigger sooner than this many iterations is a refill. */
+export const COMPACTION_REFILL_ITERATIONS = 3
+/** Consecutive refills that stop the turn. */
+export const COMPACTION_REFILL_LIMIT = 3
+
+/**
+ * One short line, shown once, when the turn stops on refills. It names the
+ * cause and a step that keeps the conversation: the reference terminal also
+ * offers to start over here, and Namzu never does.
+ */
+export const COMPACTION_REFILL_MESSAGE =
+	'The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large for the context window. Try reading it in smaller parts.'
+
+export class CompactionBreaker {
+	private failures = 0
+	private refills = 0
+	private pendingRefills = 0
+	private lastCompactedIteration: number | undefined
+	private failureNoticeSent = false
+	private stopReason: string | undefined
+
+	/** Whether three failures in a row have switched automatic compaction off. */
+	get failuresOpen(): boolean {
+		return this.failures >= COMPACTION_FAILURE_LIMIT
+	}
+
+	/** Mark the failure notice sent; true the first time only. */
+	takeFailureNotice(): boolean {
+		if (this.failureNoticeSent) return false
+		this.failureNoticeSent = true
+		return true
+	}
+
+	recordFailure(): void {
+		this.failures++
+	}
+
+	/** A pass committed an edit; failures start over. */
+	recordRelief(): void {
+		this.failures = 0
+	}
+
+	/**
+	 * A summary or reducer pass is about to run at `iteration`. True when it
+	 * would be the third refill in a row, in which case it must not run.
+	 */
+	wouldTrip(iteration: number): boolean {
+		const quick =
+			this.lastCompactedIteration !== undefined &&
+			iteration - this.lastCompactedIteration < COMPACTION_REFILL_ITERATIONS
+		this.pendingRefills = quick ? this.refills + 1 : 0
+		return this.pendingRefills >= COMPACTION_REFILL_LIMIT
+	}
+
+	/** The pass that `wouldTrip` allowed completed at `iteration`. */
+	recordCompaction(iteration: number): void {
+		this.refills = this.pendingRefills
+		this.lastCompactedIteration = iteration
+		this.recordRelief()
+	}
+
+	stopTurn(message: string): void {
+		this.stopReason ??= message
+	}
+
+	/** The reason the turn must stop, when a breaker has asked for it. */
+	get stop(): string | undefined {
+		return this.stopReason
+	}
+}
+
+const breakers = new WeakMap<object, CompactionBreaker>()
+
+/** The turn's breaker, or `undefined` when the host did not opt in. */
+export function compactionBreaker(ctx: IterationContext): CompactionBreaker | undefined {
+	if (ctx.compactionConfig?.circuitBreaker !== true) return undefined
+	let breaker = breakers.get(ctx.recorder)
+	if (!breaker) {
+		breaker = new CompactionBreaker()
+		breakers.set(ctx.recorder, breaker)
+	}
+	return breaker
+}

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

@@ -1,4 +1,7 @@
-import { resolveContextWindow } from '../../../../compaction/context-window.js'
+import {
+	resolveContextWindow,
+	resolveTriggerThreshold,
+} from '../../../../compaction/context-window.js'
 import { findDanglingMessages } from '../../../../compaction/dangling.js'
 import {
 	type CompactionPlan,
@@ -13,12 +16,14 @@ import { serializeState } from '../../../../compaction/serializer.js'
 import { buildCompactionMessage, isCompactionMessage } from '../../../../compaction/summary.js'
 import { estimateMessagesTokens } from '../../../../compaction/token-estimate.js'
 import { buildVerifiedSummaryWithBoundedProvider } from '../../../../compaction/verifier.js'
+import type { CompactionConfig } from '../../../../config/runtime.js'
 import { CHARS_PER_TOKEN } from '../../../../constants/limits.js'
 import { NAMZU } from '../../../../constants/telemetry/index.js'
 import { invariants } from '../../../../invariants/index.js'
 import { resolveTaskModel } from '../../../../model-router/task-router.js'
 import type { Message } from '../../../../types/message/index.js'
 import { applyLifecycleHookResults } from '../../plugin-hooks.js'
+import { COMPACTION_REFILL_MESSAGE, compactionBreaker } from './compaction-breaker.js'
 import type { IterationContext } from './context.js'
 import { isWorkingMemoryMessage } from './working-memory.js'
 
@@ -169,6 +174,7 @@ async function commitToolResultClear(
 	ctx.recorder.clearLastPromptTokens?.()
 	await emitToolResultClear(ctx, plan)
 	await emitContextUsageSnapshot(ctx, estimateTokens(ctx), contextWindowTokens, windowSource)
+	compactionBreaker(ctx)?.recordRelief()
 }
 
 /**
@@ -214,6 +220,73 @@ export function measureContext(ctx: IterationContext): {
 	return { tokens: estimateTokens(ctx), source: 'estimate' }
 }
 
+/**
+ * Reactive compactions allowed for one overflow, as in the reference
+ * terminal: the first relief, then at most one deeper pass.
+ */
+export const OVERFLOW_RELIEF_LIMIT = 2
+
+/** Round-groups that must remain for the deeper pass to be worth running. */
+export const DEEPER_PASS_MIN_GROUPS = 3
+
+export interface OverflowReliefOptions {
+	/**
+	 * The second rung. Keep only the newest round-group verbatim instead of the
+	 * configured recent window (when at least {@link DEEPER_PASS_MIN_GROUPS}
+	 * groups remain), and clear oversized tool results even inside the recent
+	 * window, with the same placeholder and spill pointer a stale result gets.
+	 */
+	readonly deeper?: boolean
+}
+
+/**
+ * A round-group starts at each assistant message and runs to the next one, so
+ * its tool results stay with the call that made them. The newest group is the
+ * last assistant message and everything after it; the opening user messages
+ * ride with the first group.
+ */
+function roundGroups(messages: readonly Message[]): number {
+	let groups = 0
+	for (const message of messages) if (message.role === 'assistant') groups++
+	return groups
+}
+
+/**
+ * The deeper rung's configuration: no tool result protected, and a recent
+ * window no larger than the first rung's. With three or more groups the
+ * window shrinks to the newest group, but never grows past what the
+ * configuration already kept: a newest group bigger than that would make the
+ * "deeper" pass shed less than the first one.
+ */
+export function deepenConfig(
+	config: CompactionConfig,
+	messages: readonly Message[],
+): CompactionConfig {
+	let lastAssistant = -1
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (messages[i]?.role === 'assistant') {
+			lastAssistant = i
+			break
+		}
+	}
+	const deeper = { ...config, keepRecentToolResults: 0 }
+	if (lastAssistant < 0 || roundGroups(messages) < DEEPER_PASS_MIN_GROUPS) return deeper
+	const newest = messages.slice(lastAssistant)
+	if (config.keepRecentTokens !== undefined) {
+		return {
+			...deeper,
+			keepRecentTokens: Math.max(
+				1,
+				Math.min(config.keepRecentTokens, estimateMessagesTokens(newest)),
+			),
+		}
+	}
+	return {
+		...deeper,
+		keepRecentMessages: Math.max(1, Math.min(config.keepRecentMessages, newest.length)),
+	}
+}
+
 /**
  * Shed history because the PROVIDER said the prompt is too long.
  *
@@ -232,12 +305,18 @@ export function measureContext(ctx: IterationContext): {
  * @returns whether anything was actually shed. `false` means retrying would
  *   send the same prompt again, so the caller must not.
  */
-export async function relieveOverflow(ctx: IterationContext): Promise<boolean> {
+export async function relieveOverflow(
+	ctx: IterationContext,
+	options: OverflowReliefOptions = {},
+): Promise<boolean> {
+	// The cause belongs to the rung that is about to run: an earlier rung's
+	// summary failure must not be blamed for a later rung that compacted cleanly.
+	clearCompactionErrorNote(ctx)
 	const before = ctx.recorder.messages.length
 	const beforeChars = totalChars(ctx.recorder.messages)
 	const beforeTokens = estimateMessagesTokens(ctx.recorder.messages)
 
-	await runCompactionCheck(ctx, { force: true })
+	await runCompactionCheck(ctx, { force: true, ...(options.deeper ? { deeper: true } : {}) })
 
 	const shed = beforeChars - totalChars(ctx.recorder.messages)
 	const tokensShed = beforeTokens - estimateMessagesTokens(ctx.recorder.messages)
@@ -269,6 +348,31 @@ export async function relieveOverflow(ctx: IterationContext): Promise<boolean> {
 	return true
 }
 
+/**
+ * Why the last compaction attempt errored, kept for the turn so that when
+ * relief runs out the failure it ends on can say so, as the reference
+ * terminal's " · automatic compaction failed: <cause>" does.
+ */
+const compactionErrors = new WeakMap<object, string>()
+const MAX_COMPACTION_CAUSE_CHARS = 300
+/** The sentence the cause is appended with. */
+export const AUTOMATIC_COMPACTION_FAILED = ' · automatic compaction failed: '
+
+function noteCompactionError(ctx: IterationContext, error: unknown): void {
+	const text = error instanceof Error ? error.message : String(error)
+	if (text.length > 0) compactionErrors.set(ctx.recorder, text.slice(0, MAX_COMPACTION_CAUSE_CHARS))
+}
+
+/** The turn's last compaction error, or `undefined` when none errored. */
+export function compactionErrorNote(ctx: IterationContext): string | undefined {
+	return compactionErrors.get(ctx.recorder)
+}
+
+/** A turn that got through has nothing left to explain. */
+export function clearCompactionErrorNote(ctx: IterationContext): void {
+	compactionErrors.delete(ctx.recorder)
+}
+
 function totalChars(messages: readonly { content: unknown }[]): number {
 	let total = 0
 	for (const msg of messages) total += measureContentChars(msg.content)
@@ -312,6 +416,7 @@ async function declined(
 	messages: number,
 	error?: string,
 ): Promise<void> {
+	compactionBreaker(ctx)?.recordFailure()
 	await ctx.emitEvent?.({
 		type: 'compaction_failed',
 		turnId: ctx.recorder.turnId,
@@ -322,6 +427,35 @@ async function declined(
 	})
 }
 
+/**
+ * The third refill in a row: stop the turn instead of compacting again.
+ * Returns true when this pass must not run. Only with `circuitBreaker`.
+ * The loop also asks it before the first reactive relief of an overflow, as
+ * the reference terminal does (`rhr` runs first in its withheld-overflow
+ * handling), so a re-read loop made only of overflows is counted too.
+ */
+export async function stopOnRefill(ctx: IterationContext): Promise<boolean> {
+	const breaker = compactionBreaker(ctx)
+	if (!breaker) return false
+	// Already announced: the turn is on its way out; do not say it twice.
+	if (breaker.stop !== undefined) return true
+	if (!breaker.wouldTrip(ctx.recorder.currentIteration)) return false
+	ctx.log.warn('Compaction keeps refilling — stopping the turn', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
+		[NAMZU.ITERATION]: ctx.recorder.currentIteration,
+	})
+	breaker.stopTurn(COMPACTION_REFILL_MESSAGE)
+	await ctx.emitEvent?.({
+		type: 'compaction_failed',
+		turnId: ctx.recorder.turnId,
+		iteration: ctx.recorder.currentIteration,
+		cause: 'refilling',
+		messages: ctx.recorder.messages.length,
+		error: COMPACTION_REFILL_MESSAGE,
+	})
+	return true
+}
+
 /**
  * Ctx for `compaction:no-split-tool-pair`, registered just below: the
  * candidate history a reducer just returned, not yet installed. Passed on
@@ -382,6 +516,7 @@ async function applyReducer(
 			'namzu.runtime.reason': reduction.reason,
 			'exception.message': message,
 		})
+		noteCompactionError(ctx, error)
 		await declined(ctx, 'reducer_threw', before, message)
 		return
 	}
@@ -456,6 +591,7 @@ async function applyReducer(
 		reduction.contextWindowTokens,
 		measurement.windowSource,
 	)
+	compactionBreaker(ctx)?.recordCompaction(ctx.recorder.currentIteration)
 }
 
 /**
@@ -498,9 +634,10 @@ async function recordShed(
 
 /**
  * A pass, once the check decided to run one, is bracketed by the
- * `pre_compact` and `post_compact` hooks. Observational: a hook sees the
- * numbers and cannot stop the pass, because a context the provider will
- * reject is not a thing a hook may insist on.
+ * `pre_compact` and `post_compact` hooks. A hook sees the numbers and may
+ * cancel a pass the threshold asked for (`skip`), and cannot stop one the
+ * provider forced, because a context the provider will reject is not a thing
+ * a hook may insist on.
  */
 interface CompactionPass {
 	attempted: boolean
@@ -511,7 +648,7 @@ interface CompactionPass {
 
 export async function runCompactionCheck(
 	ctx: IterationContext,
-	options?: { force?: boolean },
+	options?: { force?: boolean; deeper?: boolean },
 ): Promise<void> {
 	const pass: CompactionPass = {
 		attempted: false,
@@ -547,11 +684,12 @@ export async function runCompactionCheck(
 async function runCompactionCheckInner(
 	ctx: IterationContext,
 	pass: CompactionPass,
-	options?: { force?: boolean },
+	options?: { force?: boolean; deeper?: boolean },
 ): Promise<void> {
-	const config = ctx.compactionConfig
-	if (!config) return
-	if (config.strategy === 'disabled') return
+	const configured = ctx.compactionConfig
+	if (!configured) return
+	if (configured.strategy === 'disabled') return
+	const config = options?.deeper ? deepenConfig(configured, ctx.recorder.messages) : configured
 
 	const measured = measureContext(ctx)
 	const estimatedTokens = measured.tokens
@@ -573,11 +711,33 @@ async function runCompactionCheckInner(
 	// The salience strategy starts holding the context at `softTarget`,
 	// well before the summary trigger; every other strategy waits for it.
 	const salience = config.strategy === 'salience'
-	const startAt = salience
-		? Math.min(config.softTarget ?? DEFAULT_SOFT_TARGET, config.triggerThreshold)
-		: config.triggerThreshold
+	const maxOutputTokens = ctx.providerCapabilities?.maxOutputTokens
+	const trigger = resolveTriggerThreshold(config.triggerThreshold, budget, maxOutputTokens)
+	const startAt = salience ? Math.min(config.softTarget ?? DEFAULT_SOFT_TARGET, trigger) : trigger
 	if (!options?.force && usage < startAt) return
 
+	// Three failed passes in a row: stop proactive compaction for the rest of
+	// the turn. A pass the provider forced is never gated.
+	const breaker = compactionBreaker(ctx)
+	if (breaker?.failuresOpen && !options?.force) {
+		if (breaker.takeFailureNotice()) {
+			// Silent for the person, as in the reference terminal: a log line and the
+			// event for a host that wants it, but no sentence to show. Only the
+			// proactive pass stops; a real overflow still runs the reactive ladder.
+			ctx.log.warn('Compaction failed three times in a row — switched off for this turn', {
+				[NAMZU.TURN_ID]: ctx.recorder.turnId,
+			})
+			await ctx.emitEvent?.({
+				type: 'compaction_failed',
+				turnId: ctx.recorder.turnId,
+				iteration: ctx.recorder.currentIteration,
+				cause: 'breaker_open',
+				messages: ctx.recorder.messages.length,
+			})
+		}
+		return
+	}
+
 	pass.attempted = true
 	pass.tokensBefore = estimatedTokens
 	pass.contextWindowTokens = budget
@@ -598,6 +758,25 @@ async function runCompactionCheckInner(
 			ctx.emitEvent,
 		)
 		applyLifecycleHookResults('pre_compact', results)
+		const refusal = results.find((result) => result.action === 'skip')
+		if (refusal?.action === 'skip') {
+			// A threshold pass is the context's own housekeeping and a hook may
+			// postpone it. A forced pass runs because the provider rejected the
+			// prompt: a context it will reject is not something a hook may insist
+			// on, so the refusal is reported and the pass runs.
+			if (!options?.force) {
+				pass.attempted = false
+				ctx.log.info('A pre_compact hook cancelled the compaction pass', {
+					[NAMZU.TURN_ID]: ctx.recorder.turnId,
+					'namzu.hook.reason': refusal.reason,
+				})
+				return
+			}
+			ctx.log.warn('A pre_compact hook asked to cancel a compaction the provider forced; it ran', {
+				[NAMZU.TURN_ID]: ctx.recorder.turnId,
+				'namzu.hook.reason': refusal.reason,
+			})
+		}
 	}
 
 	// A reducer, when the turn has one, OWNS reduction — the structured pass
@@ -609,6 +788,7 @@ async function runCompactionCheckInner(
 		ctx.contextReducer ??
 		(config.strategy === 'sliding-window' ? createSlidingWindowReducer() : undefined)
 	if (reducer) {
+		if (!options?.force && (await stopOnRefill(ctx))) return
 		await applyReducer(
 			ctx,
 			reducer,
@@ -635,7 +815,7 @@ async function runCompactionCheckInner(
 		'namzu.runtime.window': budget,
 		'namzu.runtime.window_source': window.source,
 		'namzu.runtime.usage': Math.round(usage * 100),
-		'namzu.runtime.trigger_threshold': config.triggerThreshold,
+		'namzu.runtime.trigger_threshold': trigger,
 		'namzu.runtime.slot_count': manager.slotCount(),
 	})
 
@@ -668,6 +848,7 @@ async function runCompactionCheckInner(
 			messages: ctx.recorder.messages,
 			config,
 			contextWindowTokens: budget,
+			...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
 			estimatedTokens,
 			...(openTasks ? { openTasks } : {}),
 		})
@@ -676,10 +857,7 @@ async function runCompactionCheckInner(
 		}
 		// Under the trigger, the working set was the whole pass: the summary
 		// path is for the trigger, not for the soft target.
-		if (
-			!options?.force &&
-			(estimatedTokens - working.reclaimedTokens) / budget < config.triggerThreshold
-		) {
+		if (!options?.force && (estimatedTokens - working.reclaimedTokens) / budget < trigger) {
 			return
 		}
 	}
@@ -687,6 +865,7 @@ async function runCompactionCheckInner(
 		messages: ctx.recorder.messages,
 		config,
 		contextWindowTokens: budget,
+		...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
 		estimatedTokens,
 		...(options?.force ? { force: true } : {}),
 	})
@@ -712,6 +891,7 @@ async function runCompactionCheckInner(
 		messages,
 		config,
 		contextWindowTokens: budget,
+		...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
 		estimatedTokens,
 		skipToolResultClear: true,
 		...(options?.force ? { force: true } : {}),
@@ -754,6 +934,14 @@ async function runCompactionCheckInner(
 		return
 	}
 
+	if (!options?.force && (await stopOnRefill(ctx))) {
+		// A clear staged for this pass is still a useful edit.
+		if (stagedClear) {
+			await commitToolResultClear(ctx, stagedClear, budget, window.source, pass.reason)
+		}
+		return
+	}
+
 	const { systemMessages, olderMessages, recentMessages, keepStart } = plan
 
 	let compactedContent: string
@@ -765,25 +953,39 @@ async function runCompactionCheckInner(
 		// to a cheap model while the bill is written against the expensive one
 		// is a mistake with no symptom.
 		const compactionModel = resolveTaskModel('compaction', ctx.taskRouter, ctx.turnConfig.model)
-		compactedContent = await buildVerifiedSummaryWithBoundedProvider(
-			manager,
-			olderMessages as Message[],
-			ctx.provider,
-			config,
-			(usage) =>
-				ctx.recorder.accumulateUsage(usage, {
-					providerId: ctx.recorder.servingProviderId,
-					model: compactionModel,
-				}),
-			// The one model call a turn makes that the user never asked for. It
-			// reads a transcript and writes a summary, which is the cheapest
-			// thing a small model does well, and it fires on exactly the long
-			// runs where the primary model is most expensive. `taskRouter` had
-			// been accepted, validated and threaded through four types since it
-			// was added, and nothing ever consulted it.
-			compactionModel,
-			ctx.abortController.signal,
-		)
+		try {
+			compactedContent = await buildVerifiedSummaryWithBoundedProvider(
+				manager,
+				olderMessages as Message[],
+				ctx.provider,
+				config,
+				(usage) =>
+					ctx.recorder.accumulateUsage(usage, {
+						providerId: ctx.recorder.servingProviderId,
+						model: compactionModel,
+					}),
+				// The one model call a turn makes that the user never asked for. It
+				// reads a transcript and writes a summary, which is the cheapest
+				// thing a small model does well, and it fires on exactly the long
+				// runs where the primary model is most expensive. `taskRouter` had
+				// been accepted, validated and threaded through four types since it
+				// was added, and nothing ever consulted it.
+				compactionModel,
+				ctx.abortController.signal,
+			)
+		} catch (error) {
+			// The model step only ADDS to the extracted state, so a failed one (a
+			// timeout, a provider error, its own overflow after the ladder in the
+			// verifier ran out) is not a reason to leave the history as it is. Cancellation
+			// is the caller's, and still stops the pass.
+			if (ctx.abortController.signal.aborted) throw error
+			noteCompactionError(ctx, error)
+			ctx.log.warn('The compaction summary call failed — using the extracted state alone', {
+				[NAMZU.TURN_ID]: ctx.recorder.turnId,
+				'exception.message': error instanceof Error ? error.message : String(error),
+			})
+			compactedContent = serializeState(manager.getState())
+		}
 	} else {
 		compactedContent = serializeState(manager.getState())
 	}
@@ -910,4 +1112,5 @@ async function runCompactionCheckInner(
 		reachedResetThreshold: reachedReset,
 	})
 	await emitContextUsageSnapshot(ctx, newEstimate, budget, window.source)
+	compactionBreaker(ctx)?.recordCompaction(ctx.recorder.currentIteration)
 }

package/src/runtime/query/iteration/phases/context.ts

@@ -199,6 +199,8 @@ export interface IterationContext {
 	readonly taskRouter?: TaskRouterConfig
 
 	readonly compactionConfig?: CompactionConfig
+	/** See `QueryParams.maxOutputContinuations`. */
+	readonly maxOutputContinuations?: number
 
 	/**
 	 * What the driver said this model's context window is, resolved once.
@@ -225,6 +227,11 @@ export interface IterationContext {
 	 * after tool results and before the next turn.
 	 */
 	readonly inboundMessages?: () => readonly import('../../../../types/message/index.js').Message[]
+	/**
+	 * Hidden reminders for each model request; see `ReminderSource`. Absent:
+	 * the turn gets none, as before.
+	 */
+	readonly reminders?: import('../../reminders.js').ReminderSource
 	/** Known topic-queue arrivals appended after the restored checkpoint history. */
 	readonly resumedInput?: readonly import('../../../../types/message/index.js').Message[]
 	/** Observes pending input without draining it; abort releases the waiter. */
@@ -252,6 +259,10 @@ export interface IterationContext {
 
 	readonly pluginManager?: import('../../../../plugin/lifecycle.js').PluginLifecycleManager
 
+	/** The delegating session, when this turn is a child's: `subagent_stop` names it. */
+	readonly parentSessionId?: import('../../../../types/ids/index.js').SessionId
+	readonly parentTurnId?: import('../../../../types/ids/index.js').TurnId
+
 	/**
 	 * Override for {@link PARK_RECORD_DELAY_MS}. Internal; tests set `0` to
 	 * observe a recorded park without waiting out the real threshold.