@namzu/sdk 34.2.0 → 35.0.0

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

@@ -1,17 +1,24 @@
 import { resolveContextWindow } from '../../../../compaction/context-window.js'
 import { findDanglingMessages } from '../../../../compaction/dangling.js'
-import { type CompactionPlan, planCompaction } from '../../../../compaction/plan.js'
+import {
+	type CompactionPlan,
+	DEFAULT_SOFT_TARGET,
+	planCompaction,
+	planSalienceWorkingSet,
+} from '../../../../compaction/plan.js'
 import type { ContextReducer, ContextReduction } from '../../../../compaction/reducer.js'
 import { createSlidingWindowReducer } from '../../../../compaction/reducer.js'
 import { findRetainedIndices } from '../../../../compaction/retention.js'
 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 { 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 type { IterationContext } from './context.js'
 import { isWorkingMemoryMessage } from './working-memory.js'
 
@@ -31,16 +38,11 @@ export { isCompactionMessage } from '../../../../compaction/summary.js'
  * fraction of itself.
  */
 const MIN_RELIEF_FRACTION = 0.02
-const MIN_RELIEF_CHARS = 2_000
+const MIN_RELIEF_TOKENS = 500
 
 /**
- * Model-visible size of a message body, in characters.
- *
- * An image block is measured by its base64 payload because that is what
- * actually occupies the request. It is NOT what the model is billed for —
- * an image costs far fewer tokens than its base64 length divided by four —
- * but under-counting it to zero is the worse error: it let a run full of
- * screenshots read as an empty context.
+ * Serialized content size, only for byte-volume telemetry. This is never
+ * converted to prompt tokens: compressed image bytes are not model text.
  */
 function measureContentChars(content: unknown): number {
 	if (typeof content === 'string') return content.length
@@ -53,23 +55,6 @@ function measureContentChars(content: unknown): number {
 	return total
 }
 
-function estimateMessageTokens(messages: readonly Message[]): number {
-	let chars = 0
-	for (const msg of messages) {
-		// `content` is `string | ToolResultBlock[]`. On an array, `.length` is
-		// the BLOCK COUNT, so a tool result carrying a 400 KB screenshot
-		// contributed 1 — and the estimate that decides when to compact read
-		// near zero for exactly the runs that need compacting most.
-		chars += measureContentChars(msg.content)
-		if (msg.role === 'assistant' && msg.toolCalls) {
-			for (const tc of msg.toolCalls) {
-				chars += tc.function.name.length + tc.function.arguments.length
-			}
-		}
-	}
-	return Math.ceil(chars / CHARS_PER_TOKEN)
-}
-
 /**
  * Tokens the tool catalogue occupies in every request.
  *
@@ -94,7 +79,7 @@ function estimateToolCatalogTokens(ctx: IterationContext): number {
 }
 
 function estimateTokens(ctx: IterationContext): number {
-	return estimateMessageTokens(ctx.runMgr.messages) + estimateToolCatalogTokens(ctx)
+	return estimateMessagesTokens(ctx.runMgr.messages) + estimateToolCatalogTokens(ctx)
 }
 
 type ToolResultClearPlan = Extract<CompactionPlan, { kind: 'cleared' }>
@@ -124,6 +109,7 @@ async function emitContextUsageSnapshot(
 		type: 'token_usage_updated',
 		runId: ctx.runMgr.id,
 		usage: { ...ctx.runMgr.tokenUsage },
+		budget: ctx.runMgr.budget?.summary(),
 		cost: { ...ctx.runMgr.costInfo },
 		contextTokens,
 		contextMeasuredBy: 'estimate',
@@ -148,6 +134,7 @@ async function emitToolResultClear(
 		runId: ctx.runMgr.id,
 		iteration: ctx.runMgr.currentIteration,
 		clearedCount: plan.clearedCount,
+		...(plan.stubbedCount !== undefined ? { stubbedCount: plan.stubbedCount } : {}),
 		charsReclaimed: plan.charsReclaimed,
 		reclaimedTokens: plan.reclaimedTokens,
 		reliefWasEnough: plan.reliefWasEnough,
@@ -207,7 +194,7 @@ export function measureContext(ctx: IterationContext): {
 	if (reported !== undefined && reported > 0) {
 		const measuredThrough = ctx.runMgr.lastPromptMessageCount ?? ctx.runMgr.messages.length
 		const appended = ctx.runMgr.messages.slice(measuredThrough)
-		return { tokens: reported + estimateMessageTokens(appended), source: 'provider' }
+		return { tokens: reported + estimateMessagesTokens(appended), source: 'provider' }
 	}
 	return { tokens: estimateTokens(ctx), source: 'estimate' }
 }
@@ -233,22 +220,25 @@ export function measureContext(ctx: IterationContext): {
 export async function relieveOverflow(ctx: IterationContext): Promise<boolean> {
 	const before = ctx.runMgr.messages.length
 	const beforeChars = totalChars(ctx.runMgr.messages)
+	const beforeTokens = estimateMessagesTokens(ctx.runMgr.messages)
 
 	await runCompactionCheck(ctx, { force: true })
 
 	const shed = beforeChars - totalChars(ctx.runMgr.messages)
+	const tokensShed = beforeTokens - estimateMessagesTokens(ctx.runMgr.messages)
 	// A shed has to be big enough to plausibly change the provider's verdict.
 	// Any positive number used to count, so clearing a single short tool
 	// result reported success, the turn was retried against a prompt that was
 	// still over the window, and the retry burned a call to learn nothing.
 	// The floor is a fraction of what was there rather than a constant: what
 	// counts as meaningful scales with the prompt.
-	const meaningful = Math.max(MIN_RELIEF_CHARS, beforeChars * MIN_RELIEF_FRACTION)
-	if (shed < meaningful) {
+	const meaningful = Math.max(MIN_RELIEF_TOKENS, beforeTokens * MIN_RELIEF_FRACTION)
+	if (tokensShed < meaningful) {
 		ctx.log.warn('Context overflow with too little left to shed — the prompt is irreducible', {
 			[NAMZU.RUN_ID]: ctx.runMgr.id,
 			'namzu.runtime.messages': before,
 			'namzu.runtime.chars_shed': shed,
+			'namzu.runtime.tokens_shed': tokensShed,
 			'namzu.runtime.needed_at_least': Math.ceil(meaningful),
 		})
 		return false
@@ -259,6 +249,7 @@ export async function relieveOverflow(ctx: IterationContext): Promise<boolean> {
 		'namzu.runtime.messages_before': before,
 		'namzu.runtime.messages_after': ctx.runMgr.messages.length,
 		'namzu.runtime.chars_shed': shed,
+		'namzu.runtime.tokens_shed': tokensShed,
 	})
 	return true
 }
@@ -490,9 +481,57 @@ 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.
+ */
+interface CompactionPass {
+	attempted: boolean
+	reason: 'threshold' | 'overflow'
+	tokensBefore: number
+	contextWindowTokens: number
+}
+
 export async function runCompactionCheck(
 	ctx: IterationContext,
 	options?: { force?: boolean },
+): Promise<void> {
+	const pass: CompactionPass = {
+		attempted: false,
+		reason: options?.force ? 'overflow' : 'threshold',
+		tokensBefore: 0,
+		contextWindowTokens: 0,
+	}
+	try {
+		await runCompactionCheckInner(ctx, pass, options)
+	} finally {
+		if (pass.attempted && ctx.pluginManager) {
+			const results = await ctx.pluginManager.executeHooks(
+				'post_compact',
+				{
+					runId: ctx.runMgr.id,
+					iteration: ctx.runMgr.currentIteration,
+					compaction: {
+						reason: pass.reason,
+						tokensBefore: pass.tokensBefore,
+						tokensAfter: estimateTokens(ctx),
+						contextWindowTokens: pass.contextWindowTokens,
+					},
+					signal: ctx.abortController.signal,
+				},
+				ctx.emitEvent,
+			)
+			applyLifecycleHookResults('post_compact', results)
+		}
+	}
+}
+
+async function runCompactionCheckInner(
+	ctx: IterationContext,
+	pass: CompactionPass,
+	options?: { force?: boolean },
 ): Promise<void> {
 	const config = ctx.compactionConfig
 	if (!config) return
@@ -519,7 +558,34 @@ export async function runCompactionCheck(
 
 	// A forced pass skips the threshold: it runs because the provider
 	// rejected the prompt, which is stronger evidence than any estimate.
-	if (!options?.force && usage < config.triggerThreshold) return
+	// 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
+	if (!options?.force && usage < startAt) return
+
+	pass.attempted = true
+	pass.tokensBefore = estimatedTokens
+	pass.contextWindowTokens = budget
+	if (ctx.pluginManager) {
+		const results = await ctx.pluginManager.executeHooks(
+			'pre_compact',
+			{
+				runId: ctx.runMgr.id,
+				iteration: ctx.runMgr.currentIteration,
+				compaction: {
+					reason: pass.reason,
+					tokensBefore: estimatedTokens,
+					contextWindowTokens: budget,
+				},
+				signal: ctx.abortController.signal,
+			},
+			ctx.emitEvent,
+		)
+		applyLifecycleHookResults('pre_compact', results)
+	}
 
 	// A reducer, when the run has one, OWNS reduction — the structured pass
 	// below does not also run. `strategy: 'sliding-window'` resolves to the
@@ -571,6 +637,39 @@ export async function runCompactionCheck(
 	// The decision is `planCompaction`'s; installing it is this file's. The
 	// planner touches no `ctx` at all, which is what lets the boundary
 	// arithmetic be tested without a run.
+	if (salience) {
+		let openTasks: string[] | undefined
+		if (ctx.taskStore) {
+			try {
+				const tasks = await ctx.taskStore.list({ runId: ctx.runMgr.id })
+				openTasks = tasks
+					.filter((t) => t.status !== 'completed')
+					.map((t) => t.description)
+					.filter((d): d is string => typeof d === 'string' && d.length > 0)
+			} catch {
+				// The goal is measured without the plan items; a task store
+				// that cannot answer must not stop the pass.
+			}
+		}
+		const working = planSalienceWorkingSet({
+			messages: ctx.runMgr.messages,
+			config,
+			contextWindowTokens: budget,
+			estimatedTokens,
+			...(openTasks ? { openTasks } : {}),
+		})
+		if (working.reclaimedTokens > 0) {
+			await commitToolResultClear(ctx, working, budget, window.source)
+		}
+		// 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
+		) {
+			return
+		}
+	}
 	const clearPlan = planCompaction({
 		messages: ctx.runMgr.messages,
 		config,

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

@@ -131,6 +131,8 @@ export interface IterationContext {
 	 * drained and no tool result is extended.
 	 */
 	readonly steering?: SteeringChannel
+	/** Exit notices for the run's background jobs, drained into the next tool result. */
+	readonly jobNotices?: SteeringChannel
 	readonly checkpointMgr: CheckpointManager
 	readonly planManager: PlanManager
 

package/src/runtime/query/iteration/phases/tool-review.ts

@@ -8,7 +8,7 @@ import {
 	replaceProjectInstructionSnapshot,
 } from '../../project-instructions.js'
 import { attachRepeatNotice } from '../../repeat-call.js'
-import { attachSteering } from '../../steering.js'
+import { attachNotice, attachSteering, formatJobNote } from '../../steering.js'
 import { type IterationContext, awaitDecisionDurably } from './context.js'
 
 interface VerificationAwareContext extends IterationContext {
@@ -97,18 +97,47 @@ export async function* runToolReview(
 	}
 	let toolCallSummaries = summariesFor(preparedBatch)
 
+	/**
+	 * A call that has failed identically too many times in a row is answered
+	 * with the tracker's refusal instead of being run — the one denial the
+	 * tracker makes, on top of whatever the caller already denied.
+	 */
+	const withRepeatRefusals = (denials?: ToolCallDenials): ToolCallDenials | undefined => {
+		const tracker = ctx.repeatCalls
+		if (!tracker) return denials
+		let merged: Map<string, string> | undefined
+		for (const summary of toolCallSummaries) {
+			if (denials?.has(summary.id)) continue
+			const refusal = tracker.refusal(summary.name, summary.input)
+			if (!refusal) continue
+			merged ??= new Map(denials ?? [])
+			merged.set(summary.id, refusal)
+		}
+		return merged ?? denials
+	}
+
 	/** Executes the batch, answering every call, and appends the results. */
 	const settle = async (denials?: ToolCallDenials): Promise<void> => {
 		const startedAt = Date.now()
-		const batch = await ctx.toolExecutor.executeBatch(response, denials, undefined, preparedBatch)
+		const batch = await ctx.toolExecutor.executeBatch(
+			response,
+			withRepeatRefusals(denials),
+			undefined,
+			preparedBatch,
+		)
 		toolMs += Date.now() - startedAt
 		executed = batch.results
-		// Recorded AFTER execution and never before it: this advises, it does
-		// not deny, so the call has already run and its real result is in the
-		// batch. Wiring it ahead of `executeBatch` would make it a gate.
+		// Recorded AFTER execution, with the real result: the notice advises
+		// on the call that already ran, and the failure count is what the
+		// refusal above reads on the NEXT identical call.
 		const notices = []
 		for (const summary of toolCallSummaries) {
-			const notice = ctx.repeatCalls?.record(summary.name, summary.input)
+			const outcome = batch.results.find((result) => result.toolCallId === summary.id)
+			const notice = ctx.repeatCalls?.record(
+				summary.name,
+				summary.input,
+				outcome ? { failed: outcome.isError === true } : undefined,
+			)
 			if (notice) notices.push(notice)
 		}
 		// Guidance the host queued while this batch was running rides out on
@@ -116,7 +145,10 @@ export async function* runToolReview(
 		// block must be answered by a `tool_result` with the same id, so a
 		// user message wedged between them is rejected by the provider. Same
 		// delivery a denial already uses, without the refusal.
-		for (const msg of attachRepeatNotice(attachSteering(batch.messages, ctx.steering), notices)) {
+		for (const msg of attachRepeatNotice(
+			attachNotice(attachSteering(batch.messages, ctx.steering), ctx.jobNotices, formatJobNote),
+			notices,
+		)) {
 			ctx.runMgr.pushMessage(msg)
 		}
 		// The complete tool-result batch is already in history before host policy

package/src/runtime/query/iteration/phases/working-memory.ts

@@ -1,3 +1,4 @@
+import { renderPins } from '../../../../compaction/serializer.js'
 import { NAMZU } from '../../../../constants/telemetry/index.js'
 import { createSystemMessage } from '../../../../types/message/index.js'
 import type { IterationContext } from './context.js'
@@ -37,22 +38,30 @@ export function isWorkingMemoryMessage(content: string | null | undefined): bool
  */
 export async function refreshWorkingMemory(ctx: IterationContext): Promise<void> {
 	const provider = ctx.workingMemoryProvider
-	if (!provider) return
+	// What the tools pinned joins the slot beside what the host provides: a
+	// pin exists to be in front of the model every iteration, and until this
+	// the working state reached the history only through a compaction
+	// summary. No provider and no pins leaves the history untouched.
+	const pinned = ctx.workingStateManager ? renderPins(ctx.workingStateManager.getState()) : null
+	if (!provider && !pinned) return
 
-	let block: string
-	try {
-		block =
-			(await provider({
-				runId: ctx.runMgr.id,
-				iteration: ctx.runMgr.currentIteration,
-			})) ?? ''
-	} catch (err) {
-		ctx.log.warn('workingMemoryProvider failed; keeping prior slot', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
-			'exception.message': err instanceof Error ? err.message : String(err),
-		})
-		return
+	let block = ''
+	if (provider) {
+		try {
+			block =
+				(await provider({
+					runId: ctx.runMgr.id,
+					iteration: ctx.runMgr.currentIteration,
+				})) ?? ''
+		} catch (err) {
+			ctx.log.warn('workingMemoryProvider failed; keeping prior slot', {
+				[NAMZU.RUN_ID]: ctx.runMgr.id,
+				'exception.message': err instanceof Error ? err.message : String(err),
+			})
+			return
+		}
 	}
+	if (pinned) block = block.trim() ? `${block.trim()}\n\n${pinned}` : pinned
 
 	const msgs = ctx.runMgr.messages
 

package/src/runtime/query/plugin-hooks.ts

@@ -12,18 +12,39 @@ import type { PluginHookEvent, PluginHookResult } from '../../types/plugin/index
 export function applyLifecycleHookResults(
 	event: PluginHookEvent,
 	results: readonly PluginHookResult[],
-): void {
+): string[] {
+	const annotations: string[] = []
 	for (const result of results) {
 		switch (result.action) {
 			case 'continue':
 				continue
+			case 'annotate':
+				if (event !== 'user_prompt_submit') {
+					throw new Error(
+						`Plugin hook ${event} returned 'annotate', which only user_prompt_submit accepts`,
+					)
+				}
+				if (result.text.trim().length > 0) annotations.push(result.text.trim())
+				continue
+			case 'skip':
+				// The one lifecycle event with a verdict: a hook may refuse the
+				// prompt before the model sees it, and the run ends there.
+				if (event === 'user_prompt_submit') {
+					throw new NamzuError({
+						code: 'plugin_error',
+						message: `Prompt blocked by hook: ${result.reason}`,
+						details: { event, blocked: true, reason: result.reason },
+					})
+				}
+				throw new Error(
+					`Plugin hook ${event} returned unsupported action 'skip' for a lifecycle event`,
+				)
 			case 'error':
 				throw new NamzuError({
 					code: 'plugin_error',
 					message: `Plugin hook ${event} reported error: ${result.message}`,
 					details: { event },
 				})
-			case 'skip':
 			case 'modify':
 			case 'retry':
 			case 'replace':
@@ -36,4 +57,5 @@ export function applyLifecycleHookResults(
 			}
 		}
 	}
+	return annotations
 }

package/src/runtime/query/repeat-call.ts

@@ -12,11 +12,18 @@ import { stableStringify } from './tool-grants.js'
  * regardless of whether anything is repeating and needs a human at the
  * other end.
  *
- * It advises; it never denies. A repeat is not necessarily wrong — polling
- * for a build to finish is the same call by design — and a tracker that
- * refused would break that case to fix a different one. What the model
- * lacks is not permission but the observation, which it cannot make about
- * itself: each turn it sees a history, not a count.
+ * It advises, and it refuses exactly one thing. A repeat is not
+ * necessarily wrong — polling for a build to finish is the same call by
+ * design — so a repeat that keeps SUCCEEDING is only ever noticed. A repeat
+ * that keeps FAILING the same way is different: an operator watched a
+ * model ask a desktop it could not reach for a screenshot, read the same
+ * error, and ask again, for as long as the run was allowed to go on. After
+ * `refuseFailedAfter` consecutive identical failures the next identical
+ * call is answered with a refusal instead of being run, and the refusal
+ * says why. A success resets the count, so a poll that fails a few times
+ * before it succeeds is never touched. What the model lacks is not
+ * permission but the observation, which it cannot make about itself: each
+ * turn it sees a history, not a count.
  */
 
 /** Same key `ToolGrantSet` uses, so "the same call" means one thing here. */
@@ -29,11 +36,17 @@ export interface RepeatCallThresholds {
 	readonly notifyAfter: number
 	/** Repeats at which the wording escalates. */
 	readonly escalateAfter: number
+	/**
+	 * Consecutive identical FAILURES after which the next identical call is
+	 * refused rather than run. A success in between resets the count.
+	 */
+	readonly refuseFailedAfter: number
 }
 
 export const DEFAULT_REPEAT_THRESHOLDS: RepeatCallThresholds = {
 	notifyAfter: 3,
 	escalateAfter: 5,
+	refuseFailedAfter: 4,
 }
 
 export interface RepeatCallNotice {
@@ -52,17 +65,27 @@ export class RepeatCallTracker {
 	/** Which keys have already been reported at which level, so one repeat
 	 *  does not produce the same sentence on every subsequent turn. */
 	private readonly announced = new Map<string, 'notice' | 'escalated'>()
+	/** Consecutive failures per key; a success deletes the entry. */
+	private readonly failures = new Map<string, number>()
 
 	constructor(private readonly thresholds: RepeatCallThresholds = DEFAULT_REPEAT_THRESHOLDS) {}
 
 	/**
 	 * Records one call and returns a notice when this is the repeat that
-	 * crosses a threshold, `undefined` otherwise.
+	 * crosses a threshold, `undefined` otherwise. `outcome.failed` is what
+	 * the refusal counts; a call recorded without an outcome counts as a
+	 * repeat but never towards a refusal.
 	 */
-	record(toolName: string, input: unknown): RepeatCallNotice | undefined {
+	record(
+		toolName: string,
+		input: unknown,
+		outcome?: { readonly failed: boolean },
+	): RepeatCallNotice | undefined {
 		const key = keyFor(toolName, input)
 		const count = (this.counts.get(key) ?? 0) + 1
 		this.counts.set(key, count)
+		if (outcome?.failed === true) this.failures.set(key, (this.failures.get(key) ?? 0) + 1)
+		else if (outcome?.failed === false) this.failures.delete(key)
 
 		const already = this.announced.get(key)
 		if (count >= this.thresholds.escalateAfter && already !== 'escalated') {
@@ -90,6 +113,18 @@ export class RepeatCallTracker {
 	countOf(toolName: string, input: unknown): number {
 		return this.counts.get(keyFor(toolName, input)) ?? 0
 	}
+
+	/**
+	 * The refusal for a call that has failed identically too many times in
+	 * a row, or `undefined` when the call may run. Asked BEFORE execution;
+	 * the refused call is still recorded afterwards, as a failure, so the
+	 * refusal holds until the model changes something.
+	 */
+	refusal(toolName: string, input: unknown): string | undefined {
+		const failed = this.failures.get(keyFor(toolName, input)) ?? 0
+		if (failed < this.thresholds.refuseFailedAfter) return undefined
+		return `Refused: \`${toolName}\` with these exact arguments has failed ${failed} times in a row in this run, with the same result each time. It will not be run again with these arguments. Change the arguments, use a different tool, or tell the user what is blocking you and stop.`
+	}
 }
 
 /**

package/src/runtime/query/result.ts

@@ -2,6 +2,7 @@ import { type Span, SpanStatusCode } from '@opentelemetry/api'
 import type { PlanManager } from '../../manager/plan/lifecycle.js'
 import type { RunPersistence } from '../../manager/run/persistence.js'
 import { isCallerAbortError, isProviderRequestError } from '../../provider/errors.js'
+import { TokenBudgetAdmissionError } from '../../provider/token-budget.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
 import { GENAI, NAMZU } from '../../telemetry/attributes.js'
 import { explainError } from '../../types/errors/catalog.js'
@@ -85,6 +86,7 @@ export class ResultAssembler {
 
 		await emitEvent({
 			type: 'run_completed',
+			budget: runMgr.budget?.summary(),
 			runId: runMgr.id,
 			result: runMgr.getRun().result ?? '',
 			// Read AFTER `markCompleted`, which is where a run that was stopped
@@ -133,6 +135,11 @@ export class ResultAssembler {
 			yield* this.completeRun(rootSpan)
 			return
 		}
+		if (err instanceof TokenBudgetAdmissionError) {
+			runMgr.setStopReason('token_budget')
+			yield* this.completeRun(rootSpan)
+			return
+		}
 		const errorMessage = toErrorMessage(err)
 		// The classifier at the provider boundary already walked the cause
 		// chain over status, errno and `Retry-After`, so a fully-populated
@@ -176,6 +183,7 @@ export class ResultAssembler {
 
 			await emitEvent({
 				type: 'run_paused',
+				budget: runMgr.budget?.summary(),
 				runId: runMgr.id,
 				checkpointId: resumeFrom,
 				reason: errorMessage,
@@ -219,6 +227,7 @@ export class ResultAssembler {
 
 		await emitEvent({
 			type: 'run_failed',
+			budget: runMgr.budget?.summary(),
 			runId: runMgr.id,
 			error: errorMessage,
 			failure,