blun-king-cli 9.1.550 → 9.1.562

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:804ef7d1988621941a7f328013311dcf55daa850695958e9d322a7eb3f92e699
+// BLUN_BUILD_INPUT_SHA256:058cccc03f986fac95f89d198bb56bfa928b0c5117340651158d2f731509129c
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -2798,8 +2798,6 @@ var init_blun = __esmMin((() => {
 			}
 			const kwargs = { ...this._generationKwargs };
 			for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
-			if (kwargs["max_completion_tokens"] === void 0 && kwargs["max_tokens"] !== void 0) kwargs["max_completion_tokens"] = kwargs["max_tokens"];
-			delete kwargs["max_tokens"];
 			const { extra_body: extraBody, ...requestKwargs } = kwargs;
 			const extraBodyRecord = typeof extraBody === "object" && extraBody !== null ? { ...extraBody } : {};
 			const thinking = sanitizeThinkingConfig(extraBodyRecord.thinking);
@@ -2910,7 +2908,7 @@ var init_blun = __esmMin((() => {
 		withMaxCompletionTokens(maxCompletionTokens, options) {
 			let cap = maxCompletionTokens;
 			if (options?.usedContextTokens !== void 0 && options?.maxContextTokens !== void 0 && options.maxContextTokens > 0) cap = Math.min(cap, options.maxContextTokens - options.usedContextTokens);
-			return this._withGenerationKwargs({ max_completion_tokens: Math.max(1, cap) });
+			return this._withGenerationKwargs({ max_tokens: Math.max(1, cap) });
 		}
 		withExtraBody(extraBody) {
 			const oldExtra = this._generationKwargs.extra_body ?? {};
@@ -15931,6 +15929,8 @@ function loadRuntimeConfigSafe(filePath, env = process.env) {
 	} catch (error) {
 		envWarnings.push(`Ignoring BLUN_MODEL_* environment overrides: ${describeUnknownError(error)}`);
 	}
+	const { applyDefaultModelOutputBudget } = createRequire(import.meta.url)("./bin/default-model-output-budget-policy.cjs");
+	config = applyDefaultModelOutputBudget(config);
 	return {
 		config,
 		fileWarnings,
@@ -30347,7 +30347,6 @@ function resolveCompletionBudget(args) {
 	const fromLegacy = parseEnvBudget(env["BLUN_MODEL_MAX_TOKENS"]);
 	if (fromLegacy !== "absent") return fromLegacy === "disabled" ? void 0 : { hardCap: fromLegacy };
 	if (args.maxOutputSize !== void 0 && args.maxOutputSize > 0) return { hardCap: args.maxOutputSize };
-	if (args.reservedContextSize !== void 0 && args.reservedContextSize > 0) return { fallback: args.reservedContextSize };
 	return { fallback: DEFAULT_UNKNOWN_CONTEXT_FALLBACK };
 }
 function parseEnvBudget(raw) {
@@ -30400,13 +30399,12 @@ function applyCompletionBudgetWithDetails(args) {
 var MIN_FLOOR, DEFAULT_UNKNOWN_CONTEXT_FALLBACK, MIN_THINKING_COMPLETION_TOKENS, COMPLETION_CONTEXT_SAFETY_MARGIN;
 var init_completion_budget = __esmMin((() => {
 	MIN_FLOOR = 1;
-	DEFAULT_UNKNOWN_CONTEXT_FALLBACK = 32e3;
+	DEFAULT_UNKNOWN_CONTEXT_FALLBACK = 65536;
 	MIN_THINKING_COMPLETION_TOKENS = 1024;
 	COMPLETION_CONTEXT_SAFETY_MARGIN = 1e4;
 }));
 //#endregion
 //#region ../../packages/agent-core/src/loop/retry.ts
-var { nextThinkingEffortForExhaustedEmpty } = createRequire(import.meta.url)("./bin/empty-response-retry-policy.cjs");
 async function chatWithRetry(input) {
 	const maxAttempts = input.maxAttempts ?? 3;
 	if (input.llm.isRetryableError === void 0 || maxAttempts <= 1) {
@@ -30420,10 +30418,9 @@ async function chatWithRetry(input) {
 	}
 	const delays = retryBackoffDelays(maxAttempts);
 	let completionBudgetRetry;
-	let thinkingEffortRetry;
 	let emptyRetryKind;
 	for (let attempt = 1;; attempt += 1) try {
-		return await input.llm.chat(paramsForAttempt(input, attempt, maxAttempts, completionBudgetRetry, thinkingEffortRetry));
+		return await input.llm.chat(paramsForAttempt(input, attempt, maxAttempts, completionBudgetRetry));
 	} catch (error) {
 		if (error instanceof APIEmptyResponseError && (emptyRetryKind !== void 0 || error.emptyResponseKind === "length" || error.emptyResponseKind === "stop")) {
 			logEmptyResponse(input, error, attempt);
@@ -30433,24 +30430,24 @@ async function chatWithRetry(input) {
 				throw terminal;
 			}
 			completionBudgetRetry = completionBudgetRetryForEmpty(error);
-			thinkingEffortRetry = nextThinkingEffortForExhaustedEmpty({
-				emptyResponseKind: error.emptyResponseKind,
-				maxCompletionTokens: error.maxCompletionTokens,
-				completionTokens: error.completionTokens,
-				thinkingEffort: input.llm.thinkingEffort
-			});
 			emptyRetryKind = error.emptyResponseKind;
 			input.params.signal.throwIfAborted();
-			input.dispatchEvent({
-				type: "step.retrying",
-				turnId: input.turnId,
-				step: input.currentStep,
-				stepUuid: input.stepUuid,
-				failedAttempt: attempt,
-				nextAttempt: attempt + 1,
-				maxAttempts,
-				delayMs: 0,
-				...retryErrorFields(error)
+			await persistRetrySchedule({
+				dispatchRetrying: input.dispatchEvent,
+				flush: input.checkpointBeforeRetryWait,
+				signal: input.params.signal,
+				event: {
+					type: "step.retrying",
+					turnId: input.turnId,
+					step: input.currentStep,
+					stepUuid: input.stepUuid,
+					failedAttempt: attempt,
+					nextAttempt: attempt + 1,
+					maxAttempts,
+					delayMs: 0,
+					...completionBudgetIntervention(error, completionBudgetRetry),
+					...retryErrorFields(error)
+				}
 			});
 			continue;
 		}
@@ -30460,17 +30457,22 @@ async function chatWithRetry(input) {
 		}
 		const delayMs = retryDelayForError(error, delays[attempt - 1] ?? 0);
 		input.params.signal.throwIfAborted();
-		input.dispatchEvent({
-			type: "step.retrying",
-			turnId: input.turnId,
-			step: input.currentStep,
-			stepUuid: input.stepUuid,
-			failedAttempt: attempt,
-			nextAttempt: attempt + 1,
-			maxAttempts,
-			delayMs,
-			outputMayHaveStarted: input.llm.didErrorEmitPartialOutput?.(error) === true,
-			...retryErrorFields(error)
+		await persistRetrySchedule({
+			dispatchRetrying: input.dispatchEvent,
+			flush: input.checkpointBeforeRetryWait,
+			signal: input.params.signal,
+			event: {
+				type: "step.retrying",
+				turnId: input.turnId,
+				step: input.currentStep,
+				stepUuid: input.stepUuid,
+				failedAttempt: attempt,
+				nextAttempt: attempt + 1,
+				maxAttempts,
+				delayMs,
+				outputMayHaveStarted: input.llm.didErrorEmitPartialOutput?.(error) === true,
+				...retryErrorFields(error)
+			}
 		});
 		await sleepForRetry(delayMs, input.params.signal);
 	}
@@ -30482,6 +30484,14 @@ function completionBudgetRetryForEmpty(error) {
 		multiplier: 2
 	};
 }
+function completionBudgetIntervention(error, retryBudget) {
+	const before = Number(error.maxCompletionTokens);
+	if (retryBudget === void 0 || !Number.isFinite(before) || before <= 0) return {};
+	return {
+		completionBudgetBefore: before,
+		completionBudgetAfter: Math.max(retryBudget.minimumCompletionTokens, Math.ceil(before * retryBudget.multiplier))
+	};
+}
 function retryDelayForError(error, fallbackDelayMs) {
 	if (!(error instanceof APIProviderRateLimitError) || error.retryAfterMs === null) return fallbackDelayMs;
 	return Math.max(fallbackDelayMs, error.retryAfterMs);
@@ -30495,12 +30505,11 @@ function logRequestFailure(input, error, attempt, maxAttempts) {
 		...retryErrorFields(error)
 	});
 }
-function paramsForAttempt(input, attempt, maxAttempts, completionBudgetRetry, thinkingEffortRetry) {
+function paramsForAttempt(input, attempt, maxAttempts, completionBudgetRetry) {
 	const turnStep = `${input.turnId}.${String(input.currentStep)}`;
 	return {
 		...input.params,
 		completionBudgetRetry,
-		thinkingEffortRetry,
 		requestLogFields: attempt === 1 ? { turnStep } : {
 			turnStep,
 			attempt: `${String(attempt)}/${String(maxAttempts)}`
@@ -30508,19 +30517,12 @@ function paramsForAttempt(input, attempt, maxAttempts, completionBudgetRetry, th
 	};
 }
 function logEmptyResponse(input, error, attempt) {
-	const retryThinkingEffort = nextThinkingEffortForExhaustedEmpty({
-		emptyResponseKind: error.emptyResponseKind,
-		maxCompletionTokens: error.maxCompletionTokens,
-		completionTokens: error.completionTokens,
-		thinkingEffort: input.llm.thinkingEffort
-	});
 	input.log?.warn(`[leer] fall=${error.emptyResponseKind}`, {
 		turnStep: `${input.turnId}.${String(input.currentStep)}`,
 		attempt,
 		budget: error.maxCompletionTokens,
 		completion: error.completionTokens,
-		reasoningLength: error.reasoningLength,
-		...retryThinkingEffort === void 0 ? {} : { retryThinkingEffort }
+		reasoningLength: error.reasoningLength
 	});
 }
 function retryBackoffDelays(maxAttempts) {
@@ -30548,7 +30550,7 @@ function maybeStatusCode(error) {
 	const statusCode = error.statusCode;
 	return typeof statusCode === "number" ? statusCode : void 0;
 }
-var import_retry$1, RETRY_MIN_TIMEOUT_MS, RETRY_MAX_TIMEOUT_MS, RETRY_FACTOR;
+var import_retry$1, RETRY_MIN_TIMEOUT_MS, RETRY_MAX_TIMEOUT_MS, RETRY_FACTOR, persistRetrySchedule;
 var init_retry = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -30556,6 +30558,7 @@ var init_retry = __esmMin((() => {
 	init_abort();
 	init_completion_budget();
 	init_errors$4();
+	({ persistRetrySchedule } = createRequire(import.meta.url)("./bin/retry-checkpoint-policy.cjs"));
 	RETRY_MIN_TIMEOUT_MS = 300;
 	RETRY_MAX_TIMEOUT_MS = 5e3;
 	RETRY_FACTOR = 2;
@@ -74933,6 +74936,25 @@ var init_kosong_llm = __esmMin((() => {
 		get thinkingEffort() {
 			return this.provider.thinkingEffort;
 		}
+		describeRequest(messages, tools, retry) {
+			const outgoingRequestTokens = estimateSystemPromptTokens(this.systemPrompt) + estimateTokensForTools(tools) + estimateTokensForMessages(messages);
+			const reportedContextTokens = this.reportedContextTokens?.() ?? 0;
+			const details = applyCompletionBudgetWithDetails({
+				provider: this.provider,
+				budget: this.completionBudgetConfig,
+				capability: this.capability,
+				usedContextTokens: Math.max(outgoingRequestTokens, reportedContextTokens),
+				retry: retry ?? (thinkingEnabled(this.provider.thinkingEffort) ? {
+					minimumCompletionTokens: 1024,
+					multiplier: 1
+				} : void 0)
+			});
+			return {
+				thinkingEffort: this.provider.thinkingEffort,
+				completionBudget: details.maxCompletionTokens,
+				details
+			};
+		}
 		notifyMediaDropped(dropped) {
 			if (this.onMediaDropped === void 0) return;
 			const fresh = dropped.filter((part) => {
@@ -74975,25 +74997,12 @@ var init_kosong_llm = __esmMin((() => {
 			let result;
 			let completionBudget;
 			try {
-				const requestProvider = params.thinkingEffortRetry === void 0 ? this.provider : this.provider.withThinking(params.thinkingEffortRetry);
 				const enrichedMessages = this.visionReader === void 0 ? params.messages : await enrichMessagesWithVision(params.messages, this.visionReader, params.signal, this.onVisionUsage);
 				const tools = [...params.tools];
 				const outgoingMessages = downgradeUnsupportedMedia(enrichedMessages, this.capability, (dropped) => {
 					this.notifyMediaDropped(dropped);
 				});
-				const outgoingRequestTokens = estimateSystemPromptTokens(this.systemPrompt) + estimateTokensForTools(tools) + estimateTokensForMessages(outgoingMessages);
-				const reportedContextTokens = this.reportedContextTokens?.() ?? 0;
-				const usedContextTokens = Math.max(outgoingRequestTokens, reportedContextTokens);
-				completionBudget = applyCompletionBudgetWithDetails({
-					provider: requestProvider,
-					budget: this.completionBudgetConfig,
-					capability: this.capability,
-					usedContextTokens,
-					retry: params.completionBudgetRetry ?? (thinkingEnabled(requestProvider.thinkingEffort) ? {
-						minimumCompletionTokens: 1024,
-						multiplier: 1
-					} : void 0)
-				});
+				completionBudget = this.describeRequest(outgoingMessages, tools, params.completionBudgetRetry).details;
 				result = await this.generate(completionBudget.provider, this.systemPrompt, tools, outgoingMessages, callbacks, options);
 			} catch (error) {
 				if (error instanceof APIEmptyResponseError) throw error.withMetadata({ maxCompletionTokens: completionBudget === void 0 ? null : completionBudget.maxCompletionTokens ?? null });
@@ -75516,12 +75525,13 @@ function extractCompactionSummary(response) {
 	if (summary.trim().length === 0) throw new APIEmptyResponseError("The compaction response did not contain a non-empty summary.");
 	return summary;
 }
-var archiveCompactionHistory, buildCompactionArchiveNotice, capCompactionCompletionTokens, capCompactionStageTarget, proactiveCompactionEligibility, waitForAbortableCompletion, COMPACTION_THINKING_EFFORT, COMPACTION_SYSTEM_PROMPT, COMPACTION_SUMMARY_RESERVE_RATIO, MAX_HIERARCHICAL_COMPACTION_PASSES, HIERARCHICAL_COMPACTION_PREFIX, CompactionTruncatedError, CompactionStallError, COMPACTION_STALL_MEASUREMENT_MULTIPLIER, REBUILT_AFTER_COMPACTION_INJECTION_VARIANTS, FullCompaction, MAX_COMPACTION_OVERFLOW_SHRINK_ATTEMPTS, COMPACTION_OVERFLOW_SHRINK_RATIOS;
+var archiveCompactionHistory, buildCompactionArchiveNotice, capCompactionCompletionTokens, capCompactionStageTarget, proactiveCompactionEligibility, assertBalancedToolPairs, createCompactionTransaction, endCompactionTransaction, summarizeCompactionTransaction, waitForAbortableCompletion, COMPACTION_THINKING_EFFORT, COMPACTION_SYSTEM_PROMPT, COMPACTION_SUMMARY_RESERVE_RATIO, MAX_HIERARCHICAL_COMPACTION_PASSES, HIERARCHICAL_COMPACTION_PREFIX, CompactionTruncatedError, CompactionStallError, COMPACTION_STALL_MEASUREMENT_MULTIPLIER, REBUILT_AFTER_COMPACTION_INJECTION_VARIANTS, FullCompaction, MAX_COMPACTION_OVERFLOW_SHRINK_ATTEMPTS, COMPACTION_OVERFLOW_SHRINK_RATIOS;
 var init_full = __esmMin((() => {
 	({ archiveCompactionHistory, buildCompactionArchiveNotice } = createRequire(import.meta.url)("./bin/compaction-history-archive.cjs"));
 	({ waitForAbortableCompletion } = createRequire(import.meta.url)("./bin/abort-listener-policy.cjs"));
 	({ capCompactionCompletionTokens, capCompactionStageTarget } = createRequire(import.meta.url)("./bin/compaction-stage-policy.cjs"));
 	({ proactiveCompactionEligibility } = createRequire(import.meta.url)("./bin/proactive-compaction-policy.cjs"));
+	({ assertBalancedToolPairs, createCompactionTransaction, endCompactionTransaction, summarizeCompactionTransaction } = createRequire(import.meta.url)("./bin/compaction-transaction-policy.cjs"));
 	init_errors$8();
 	init_src$4();
 	init_errors$4();
@@ -75672,6 +75682,15 @@ var init_full = __esmMin((() => {
 			}
 			if (this.agent.context.history.length === 0) throw new BlunError(ErrorCodes.COMPACTION_UNABLE, "No messages to compact in current history.");
 			if (data.source === "manual" && this.agent.turn.hasActiveTurn) throw new BlunError(ErrorCodes.COMPACTION_UNABLE, "Cannot compact while a turn is active. Wait for it to finish, then retry.");
+			const history = this.agent.context.history;
+			assertBalancedToolPairs(history, "history selected for full compaction");
+			const { transaction, record: transactionStart } = createCompactionTransaction({
+				source: data.source,
+				turnId: this.agent.turn.hasActiveTurn ? this.agent.turn.currentId : null,
+				tokensBefore: estimateTokensForMessages(history),
+				messageCountBefore: history.length
+			});
+			this.agent.records.logRecord(transactionStart);
 			this.agent.records.logRecord({
 				type: "full_compaction.begin",
 				...data
@@ -75684,20 +75703,32 @@ var init_full = __esmMin((() => {
 			const abortController = new AbortController();
 			this.compacting = {
 				abortController,
-				promise: this.compactionWorker(abortController.signal, data),
+				promise: this.compactionWorker(abortController.signal, data, transaction),
+				transaction,
 				blockedByTurn: false
 			};
 		}
-		cancel() {
+		closeTransaction(status, error) {
+			const transaction = this.compacting?.transaction;
+			if (transaction === void 0) return;
+			const record = endCompactionTransaction(transaction, {
+				status,
+				...error === void 0 ? {} : { error: error instanceof Error ? `${error.name}: ${error.message}` : String(error) }
+			});
+			if (record !== void 0) this.agent.records.logRecord(record);
+		}
+		cancel(error) {
 			this.agent.replayBuilder.patchLast("compaction", { result: "cancelled" });
 			if (!this.compacting) return;
 			this.agent.records.logRecord({ type: "full_compaction.cancel" });
+			this.closeTransaction(error === void 0 ? "cancelled" : "failed", error);
 			this.compacting.abortController.abort();
 			this.compacting = null;
 			this.agent.emitEvent({ type: "compaction.cancelled" });
 		}
 		markCompleted() {
 			this.agent.records.logRecord({ type: "full_compaction.complete" });
+			this.closeTransaction("success");
 			this.compacting = null;
 		}
 		get tokenCountWithPending() {
@@ -75806,9 +75837,9 @@ var init_full = __esmMin((() => {
 				await waitForAbortableCompletion(signal, active.promise, onAbort);
 			}
 		}
-		async compactionWorker(signal, data) {
+		async compactionWorker(signal, data, transaction) {
 			try {
-				const output = await this.compactionRound(signal, data);
+				const output = await this.compactionRound(signal, data, transaction);
 				if (!output) return;
 				const { result, stageCount } = output;
 				try {
@@ -75833,9 +75864,12 @@ var init_full = __esmMin((() => {
 				});
 				this.triggerPostCompactHook(data, result);
 			} catch (error) {
-				if (isAbortError$4(error)) return;
+				if (isAbortError$4(error)) {
+					if (this.compacting?.transaction === transaction) this.cancel();
+					return;
+				}
 				const blockedByTurn = this.compacting?.blockedByTurn === true;
-				this.cancel();
+				this.cancel(error);
 				this.agent.log.error("compaction failed", { error });
 				if (blockedByTurn) throw error;
 				this.agent.emitEvent({
@@ -75855,7 +75889,7 @@ var init_full = __esmMin((() => {
 			const todoMarkdown = renderTodoList(todos, "## TODO List");
 			return `${summary.trim()}\n\n${todoMarkdown}`;
 		}
-		async compactionRound(signal, data) {
+		async compactionRound(signal, data, transaction) {
 			const startedAt = Date.now();
 			const originalHistory = [...this.agent.context.history];
 			const tokensBefore = estimateTokensForMessages(originalHistory);
@@ -76131,7 +76165,9 @@ var init_full = __esmMin((() => {
 					contextSummary,
 					compactedCount: originalHistory.length,
 					tokensBefore,
-					droppedCount: droppedCount === 0 ? void 0 : droppedCount
+					droppedCount: droppedCount === 0 ? void 0 : droppedCount,
+					transaction,
+					historyBefore: originalHistory
 				});
 				this.agent.telemetry.track("compaction_finished", {
 					source: data.source,
@@ -76242,10 +76278,18 @@ var init_full = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/micro.ts
-var selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, freshToolResultIds, projectHistoricalUnaddressedTelegramMessages, dedupeRepeatedUserMessages, projectRepeatedAssistantResponses, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, projectLoopEventForRecord, projectUsageModelForRecord, projectUsageForRecord, resolveCompletedStepUuid, resolveStepEventUuid, restoreUsageFromRecord, restoreUsageModelFromRecord, isWireOnlyProgrammaticEvent, DEFAULT_CONFIG, MicroCompaction;
+function repeatedToolResultReference(marker, newestToolCallId) {
+	if (newestToolCallId === void 0) return marker;
+	return [
+		marker,
+		`same_as_tool_call_id: ${newestToolCallId}`,
+		"reason: identical successful result for the same tool call arguments"
+	].join("\n");
+}
+var selectMicroCompactionCutoff, redundantHistoricalToolResultReferences, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, freshToolResultIds, projectHistoricalUnaddressedTelegramMessages, dedupeRepeatedUserMessages, projectRepeatedAssistantResponses, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, projectLoopEventForRecord, projectUsageModelForRecord, projectUsageForRecord, resolveCompletedStepUuid, resolveStepEventUuid, restoreUsageFromRecord, restoreUsageModelFromRecord, isWireOnlyProgrammaticEvent, DEFAULT_CONFIG, MicroCompaction;
 var init_micro = __esmMin((() => {
 	({ isWireOnlyProgrammaticEvent } = createRequire(import.meta.url)("./bin/programmatic-context-isolation.cjs"));
-	({ selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS } = createRequire(import.meta.url)("./bin/micro-compaction-policy.cjs"));
+	({ selectMicroCompactionCutoff, redundantHistoricalToolResultReferences, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS } = createRequire(import.meta.url)("./bin/micro-compaction-policy.cjs"));
 	({ isPersistedToolResultReference, freshToolResultIds } = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs"));
 	({ projectHistoricalUnaddressedTelegramMessages } = createRequire(import.meta.url)("./bin/telegram-context-projection-policy.cjs"));
 	({ dedupeRepeatedUserMessages } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
@@ -76260,7 +76304,7 @@ var init_micro = __esmMin((() => {
 		compactToolArguments: MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED,
 		minToolArgumentTokens: MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS,
 		cacheMissedThresholdMs: 3600 * 1e3,
-		truncatedMarker: "[Old tool result content cleared]",
+		truncatedMarker: "[Repeated tool result omitted]",
 		truncatedArgumentsMarker: "[Old tool call arguments cleared]",
 		minContextUsageRatio: .5
 	};
@@ -76308,10 +76352,18 @@ var init_micro = __esmMin((() => {
 			const effect = this.measureEffect(history, selection.cutoff);
 			const previousEffect = this.measureEffect(history, previousCutoff);
 			if (effect.truncatedToolResultCount <= previousEffect.truncatedToolResultCount && effect.truncatedToolArgumentCount <= previousEffect.truncatedToolArgumentCount) return;
-			this.apply(selection.cutoff);
 			const rawContextTokens = estimateTokensForMessages(history);
 			const tokensBefore = rawContextTokens - previousEffect.truncatedToolResultTokensBefore + previousEffect.truncatedToolResultTokensAfter - previousEffect.truncatedToolArgumentTokensBefore + previousEffect.truncatedToolArgumentTokensAfter;
 			const tokensAfter = rawContextTokens - effect.truncatedToolResultTokensBefore + effect.truncatedToolResultTokensAfter - effect.truncatedToolArgumentTokensBefore + effect.truncatedToolArgumentTokensAfter;
+			this.apply(selection.cutoff);
+			this.agent.records.logRecord({
+				type: "policy.intervention",
+				policy: "repeated_tool_result_projection",
+				location: "MicroCompaction.detect",
+				size_before: tokensBefore,
+				size_after: tokensAfter,
+				unit: "tokens"
+			});
 			this.agent.telemetry.track("micro_compaction_finished", {
 				trigger: selection.trigger,
 				keep_recent_messages: config.keepRecentMessages,
@@ -76343,15 +76395,16 @@ var init_micro = __esmMin((() => {
 			const historicalArgumentCutoff = Math.max(this.cutoff, messages.length - config.keepRecentMessages);
 			const completedToolCallIds = new Set(messages.filter((message) => message?.role === "tool" && message.toolCallId !== void 0).map((message) => message.toolCallId));
 			const protectedToolResultIds = freshToolResultIds(messages);
+			const reducibleToolResultIds = redundantHistoricalToolResultReferences(messages, this.cutoff);
 			const serializedArgumentsMarker = JSON.stringify({ _blun_compacted: config.truncatedArgumentsMarker });
 			const result = [];
 			let i = 0;
 			for (const msg of messages) {
-				if (i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && !protectedToolResultIds.has(msg.toolCallId) && !isPersistedToolResultReference(msg.content) && estimateTokensForContentParts(msg.content) >= config.minContentTokens) result.push({
+				if (i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && reducibleToolResultIds.has(msg.toolCallId) && !protectedToolResultIds.has(msg.toolCallId) && !isPersistedToolResultReference(msg.content) && estimateTokensForContentParts(msg.content) >= config.minContentTokens) result.push({
 					...msg,
 					content: [{
 						type: "text",
-						text: config.truncatedMarker
+						text: repeatedToolResultReference(config.truncatedMarker, reducibleToolResultIds.get(msg.toolCallId))
 					}]
 				});
 				else if (config.compactToolArguments && i < historicalArgumentCutoff && msg.role === "assistant" && Array.isArray(msg.toolCalls)) {
@@ -76380,7 +76433,6 @@ var init_micro = __esmMin((() => {
 			return result;
 		}
 		measureEffect(messages, cutoff) {
-			let markerTokenCount;
 			let argumentsMarkerTokenCount;
 			let truncatedToolResultCount = 0;
 			let truncatedToolResultTokensBefore = 0;
@@ -76390,19 +76442,20 @@ var init_micro = __esmMin((() => {
 			let truncatedToolArgumentTokensAfter = 0;
 			const completedToolCallIds = new Set(messages.filter((message) => message?.role === "tool" && message.toolCallId !== void 0).map((message) => message.toolCallId));
 			const protectedToolResultIds = freshToolResultIds(messages);
+			const reducibleToolResultIds = redundantHistoricalToolResultReferences(messages, cutoff);
 			const serializedArgumentsMarker = JSON.stringify({ _blun_compacted: this.config.truncatedArgumentsMarker });
 			for (let i = 0; i < messages.length && i < cutoff; i++) {
 				const message = messages[i];
-				if (message?.role === "tool" && message.toolCallId !== void 0 && !protectedToolResultIds.has(message.toolCallId) && !isPersistedToolResultReference(message.content)) {
+				if (message?.role === "tool" && message.toolCallId !== void 0 && reducibleToolResultIds.has(message.toolCallId) && !protectedToolResultIds.has(message.toolCallId) && !isPersistedToolResultReference(message.content)) {
 					const contentTokens = estimateTokensForContentParts(message.content);
 					if (contentTokens >= this.config.minContentTokens) {
-						markerTokenCount ??= estimateTokensForContentParts([{
-							type: "text",
-							text: this.config.truncatedMarker
-						}]);
 						truncatedToolResultCount += 1;
 						truncatedToolResultTokensBefore += contentTokens;
-						truncatedToolResultTokensAfter += markerTokenCount;
+						const replacement = repeatedToolResultReference(this.config.truncatedMarker, reducibleToolResultIds.get(message.toolCallId));
+						truncatedToolResultTokensAfter += estimateTokensForContentParts([{
+							type: "text",
+							text: replacement
+						}]);
 					}
 				}
 				if (!this.config.compactToolArguments || message?.role !== "assistant" || !Array.isArray(message.toolCalls)) continue;
@@ -79395,6 +79448,24 @@ var init_context$2 = __esmMin((() => {
 				keptHeadUserMessageCount,
 				droppedCount: input.droppedCount
 			};
+			const summaryMessage = {
+				role: "user",
+				content: [{
+					type: "text",
+					text: contextSummary
+				}],
+				toolCalls: [],
+				origin: { kind: "compaction_summary" }
+			};
+			const isLegacyRestore = this.agent.records.restoring !== null && input.keptUserMessageCount === void 0 && input.compactedCount < this._history.length;
+			const nextHistory = isLegacyRestore ? [summaryMessage, ...this._history.slice(input.compactedCount)] : [...keptMessages, summaryMessage];
+			if (input.transaction !== void 0) this.agent.records.logRecord(summarizeCompactionTransaction(input.transaction, {
+				summary: contextSummary,
+				historyBefore: input.historyBefore ?? this._history,
+				historyAfter: nextHistory,
+				tokensAfter: result.tokensAfter,
+				messageCountAfter: nextHistory.length
+			}));
 			this.agent.records.logRecord({
 				type: "policy.intervention",
 				policy: "full_context_compaction",
@@ -79417,17 +79488,7 @@ var init_context$2 = __esmMin((() => {
 				keptHeadUserMessageCount: result.keptHeadUserMessageCount,
 				droppedCount: result.droppedCount
 			} });
-			const summaryMessage = {
-				role: "user",
-				content: [{
-					type: "text",
-					text: contextSummary
-				}],
-				toolCalls: [],
-				origin: { kind: "compaction_summary" }
-			};
-			const isLegacyRestore = this.agent.records.restoring !== null && input.keptUserMessageCount === void 0 && input.compactedCount < this._history.length;
-				this._history = isLegacyRestore ? [summaryMessage, ...this._history.slice(input.compactedCount)] : [...keptMessages, summaryMessage];
+				this._history = nextHistory;
 				this.markPendingTokenEstimateDirty();
 			this.openSteps.clear();
 			this.pendingToolResultIds.clear();
@@ -244545,6 +244606,7 @@ function createNestedToolInvoker(step, parentToolCall) {
 			...step,
 			signal: nestedSignal,
 			toolCalls: [nestedToolCall],
+			checkpointBeforeToolExecution: void 0,
 			dispatchEvent: (event) => step.dispatchEvent(markProgrammaticNestedEvent(event))
 		};
 		const preflight = preflightToolCall(nestedStep, nestedToolCall);
@@ -244679,6 +244741,16 @@ async function prepareToolCall(step, call, approvalEditCount = 0) {
 	}
 	const executionMetadata = authorization?.executionMetadata ?? decision.metadata;
 	await dispatchToolCall(step, call, effectiveArgs, displayFields);
+	if (step.checkpointBeforeToolExecution !== void 0) {
+		const checkpoint = await checkpointBeforeExternalSideEffect({
+			flush: step.checkpointBeforeToolExecution,
+			signal: step.signal
+		});
+		if (!checkpoint.allowed) return {
+			task: makeResolvedToolCallTask(makeErrorToolResult(call, effectiveArgs, `${checkpoint.code}: ${checkpoint.error}`)),
+			stopBatchAfterThis: true
+		};
+	}
 	return {
 		task: {
 			accesses: execution.accesses ?? ToolAccesses.all(),
@@ -244985,9 +245057,10 @@ async function dispatchToolCall(step, call, args, displayFields) {
 		display: displayFields?.display
 	});
 }
-var markProgrammaticNestedEvent, GRACE_TIMEOUT_MS, TOOL_OUTPUT_EMPTY, TOOL_OUTPUT_NON_TEXT, validators;
+var markProgrammaticNestedEvent, checkpointBeforeExternalSideEffect, GRACE_TIMEOUT_MS, TOOL_OUTPUT_EMPTY, TOOL_OUTPUT_NON_TEXT, validators;
 var init_tool_call = __esmMin((() => {
 	({ markProgrammaticNestedEvent } = createRequire(import.meta.url)("./bin/programmatic-context-isolation.cjs"));
+	({ checkpointBeforeExternalSideEffect } = createRequire(import.meta.url)("./bin/session-checkpoint-policy.cjs"));
 	init_args_validator();
 	init_path_access();
 	init_abort();
@@ -245011,7 +245084,7 @@ var init_tool_call = __esmMin((() => {
 * does not lose model usage that was already spent.
 */
 async function executeLoopStep(deps) {
-	const { turnId, signal, buildMessages, buildMessagesStrict, dispatchEvent, llm, tools, hooks, log, currentStep, maxRetryAttempts, recordUsage, onStepStarted } = deps;
+	const { turnId, signal, buildMessages, buildMessagesStrict, dispatchEvent, llm, tools, hooks, log, currentStep, maxRetryAttempts, recordUsage, onStepStarted, checkpointBeforeToolExecution, checkpointBeforeRetryWait } = deps;
 	const beforeStep = hooks?.beforeStep === void 0 ? void 0 : await hooks.beforeStep({
 		turnId,
 		stepNumber: currentStep,
@@ -245027,12 +245100,15 @@ async function executeLoopStep(deps) {
 	const messages = await stepBuildMessages();
 	signal.throwIfAborted();
 	const stepUuid = randomUUID();
+	const requestMetadata = stepLLM.describeRequest?.(messages, stepTools ?? []);
 	const stepEvents = createStepEventGate({
 		dispatchEvent,
 		turnId,
 		currentStep,
 		stepUuid,
-		onStepStarted
+		onStepStarted,
+		requestMetadata,
+		maxAttempts: maxRetryAttempts
 	});
 	const prepareRequestBoundary = stepLLM.prepareRequestBoundary?.bind(stepLLM);
 	const step = {
@@ -245044,7 +245120,8 @@ async function executeLoopStep(deps) {
 		signal,
 		turnId,
 		currentStep,
-		stepUuid
+		stepUuid,
+		checkpointBeforeToolExecution
 	};
 	let chatParams = {
 		messages,
@@ -245057,9 +245134,8 @@ async function executeLoopStep(deps) {
 	signal.throwIfAborted();
 	const retryInput = {
 		llm: stepLLM,
-		dispatchEvent: (event) => {
-			stepEvents.dispatchRetrying(event);
-		},
+		dispatchEvent: (event) => stepEvents.dispatchRetrying(event),
+		checkpointBeforeRetryWait,
 		turnId,
 		currentStep,
 		stepUuid,
@@ -245219,29 +245295,33 @@ async function chatWithLiveResponseRepetitionRecovery(deps) {
 				occurrences: repetition.count,
 				wordCount: repetition.wordCount
 			});
-			await stepEvents.dispatchRetrying({
-				type: "step.retrying",
-				turnId: retryInput.turnId,
-				step: retryInput.currentStep,
-				stepUuid: retryInput.stepUuid,
-				failedAttempt: 1,
-				nextAttempt: 2,
-				maxAttempts: 2,
-				delayMs: 0,
-				outputMayHaveStarted: true,
-				errorName: "LiveResponseRepetitionError",
-				errorMessage: "Repeated assistant text detected during streaming"
+			await persistRetrySchedule({
+				dispatchRetrying: (event) => stepEvents.dispatchRetrying(event),
+				flush: checkpointBeforeRetryWait,
+				signal,
+				event: {
+					type: "step.retrying",
+					turnId: retryInput.turnId,
+					step: retryInput.currentStep,
+					stepUuid: retryInput.stepUuid,
+					failedAttempt: 1,
+					nextAttempt: 2,
+					maxAttempts: 2,
+					delayMs: 0,
+					outputMayHaveStarted: true,
+					errorName: "LiveResponseRepetitionError",
+					errorMessage: "Repeated assistant text detected during streaming"
+				}
 			});
 		}
 	}
 	throw new Error("Live response repetition recovery exhausted");
 }
 function createStepEventGate(deps) {
-	const { dispatchEvent, turnId, currentStep, stepUuid, onStepStarted } = deps;
+	const { dispatchEvent, turnId, currentStep, stepUuid, onStepStarted, requestMetadata, maxAttempts } = deps;
 	let startPromise;
 	let eventQueue = Promise.resolve();
 	let hasOutput = false;
-	const pendingBeforeStart = [];
 	let liveRepetitionGuard;
 	let liveRepetitionController;
 	let liveRepetitionResult = null;
@@ -245251,10 +245331,13 @@ function createStepEventGate(deps) {
 				type: "step.begin",
 				uuid: stepUuid,
 				turnId,
-				step: currentStep
+				step: currentStep,
+				thinkingEffort: requestMetadata?.thinkingEffort,
+				completionBudget: requestMetadata?.completionBudget,
+				attempt: 1,
+				maxAttempts
 			});
 			onStepStarted?.();
-			for (const dispatch of pendingBeforeStart.splice(0)) await dispatch();
 		})();
 		return startPromise;
 	};
@@ -245289,14 +245372,9 @@ function createStepEventGate(deps) {
 			return AbortSignal.any([signal, liveRepetitionController.signal]);
 		},
 		dispatchRetrying: async (event) => {
-			if (startPromise === void 0) {
-				pendingBeforeStart.push(() => {
-					dispatchEvent(event);
-				});
-				return;
-			}
-			const queued = eventQueue.then(() => {
-				dispatchEvent(event);
+			const queued = eventQueue.then(async () => {
+				await start();
+				await dispatchEvent(event);
 			});
 			eventQueue = queued;
 			await queued;
@@ -245360,7 +245438,7 @@ var init_turn_step = __esmMin((() => {
 //#endregion
 //#region ../../packages/agent-core/src/loop/run-turn.ts
 async function runTurn(input) {
-	const { turnId, signal, llm, buildMessages, buildMessagesStrict, dispatchEvent, tools, hooks, log, maxSteps, maxRetryAttempts, recordStepUsage: hostRecordStepUsage } = input;
+	const { turnId, signal, llm, buildMessages, buildMessagesStrict, dispatchEvent, tools, hooks, log, maxSteps, maxRetryAttempts, checkpointBeforeToolExecution, checkpointBeforeRetryWait, recordStepUsage: hostRecordStepUsage } = input;
 	let usage = emptyUsage();
 	let steps = 0;
 	let stopReason = "end_turn";
@@ -245390,6 +245468,8 @@ async function runTurn(input) {
 				log,
 				currentStep: stepNumber,
 				maxRetryAttempts,
+				checkpointBeforeToolExecution,
+				checkpointBeforeRetryWait,
 				recordUsage: recordStepUsage,
 				onStepStarted: setActiveStep.bind(void 0, stepNumber)
 			});
@@ -246762,7 +246842,11 @@ var init_events$1 = __esmMin((() => {
 		type: literal("turn.step.started"),
 		turnId: number$1(),
 		step: number$1(),
-		stepId: string().optional()
+		stepId: string().optional(),
+		thinkingEffort: string().optional(),
+		completionBudget: number$1().int().positive().optional(),
+		attempt: number$1().int().positive().optional(),
+		maxAttempts: number$1().int().positive().optional()
 	});
 	turnStepCompletedEventSchema = object({
 		type: literal("turn.step.completed"),
@@ -246792,7 +246876,9 @@ var init_events$1 = __esmMin((() => {
 		outputMayHaveStarted: boolean$1().optional(),
 		errorName: string(),
 		errorMessage: string(),
-		statusCode: number$1().optional()
+		statusCode: number$1().optional(),
+		completionBudgetBefore: number$1().int().positive().optional(),
+		completionBudgetAfter: number$1().int().positive().optional()
 	});
 	turnStepInterruptedEventSchema = object({
 		type: literal("turn.step.interrupted"),
@@ -254607,7 +254693,15 @@ function replaceOnceLiteral(content, oldString, newString) {
 	if (index === -1) return content;
 	return content.slice(0, index) + newString + content.slice(index + oldString.length);
 }
-var EditInputSchema, EditTool, findDegenerateGeneratedStatementRun;
+async function observedFileStat(kaos, path) {
+	try {
+		return await kaos.stat(path);
+	} catch (error) {
+		if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return null;
+		throw error;
+	}
+}
+var EditInputSchema, EditTool, findDegenerateGeneratedStatementRun, writeToolTextAtomic;
 var init_edit = __esmMin((() => {
 	init_zod$1();
 	init_tool_access();
@@ -254619,6 +254713,7 @@ var init_edit = __esmMin((() => {
 	init_edit$1();
 	init_lsp_diagnostics();
 	({ findDegenerateGeneratedStatementRun } = createRequire(import.meta.url)("./bin/generated-source-health.cjs"));
+	({ writeToolTextAtomic } = createRequire(import.meta.url)("./bin/tool-file-persistence.cjs"));
 	EditInputSchema = object({
 		path: string().describe("Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute."),
 		old_string: string().min(1).describe("Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\r escapes where Read shows \\r."),
@@ -254632,14 +254727,16 @@ var init_edit = __esmMin((() => {
 		workspace;
 		history;
 		lsp;
+		fileObservation;
 		name = "Edit";
 		description = edit_default;
 		parameters = toInputJsonSchema(EditInputSchema);
-		constructor(kaos, workspace, history, lsp) {
+		constructor(kaos, workspace, history, lsp, fileObservation) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.history = history;
 			this.lsp = lsp;
+			this.fileObservation = fileObservation;
 		}
 		resolveExecution(args) {
 			const path = resolvePathAccessPath(args.path, {
@@ -254677,6 +254774,12 @@ var init_edit = __esmMin((() => {
 				output: `Refused to edit ${args.path}: generated source contains a runaway repeated statement ${String(degenerateStatementRun.count)} times from line ${String(degenerateStatementRun.line)} (starts with ${JSON.stringify(degenerateStatementRun.preview)}). Regenerate that section in a smaller focused chunk. No file was written.`
 			};
 			try {
+				const currentStat = await observedFileStat(this.kaos, safePath);
+				const authorization = this.fileObservation.authorizeEdit(safePath, currentStat);
+				if (!authorization.allowed) return {
+					isError: true,
+					output: `[${authorization.code}] ${authorization.error}`
+				};
 				const raw = await this.kaos.readText(safePath);
 				const modelView = toModelTextView(raw);
 				const content = modelView.text;
@@ -254699,7 +254802,7 @@ var init_edit = __esmMin((() => {
 						output: `old_string is not unique in ${args.path} (found ${String(count)} occurrences). To replace every occurrence, set replace_all=true. To replace only one occurrence, include more surrounding context in old_string.`
 					};
 					const newContent = replaceOnceLiteral(content, args.old_string, args.new_string);
-					return this.writeReplacement(args, safePath, raw, newContent, modelView.lineEndingStyle, 1);
+					return this.writeReplacement(args, safePath, raw, newContent, modelView.lineEndingStyle, 1, authorization.version);
 				}
 				const parts = content.split(args.old_string);
 				const replacementCount = parts.length - 1;
@@ -254709,7 +254812,7 @@ var init_edit = __esmMin((() => {
 `
 				};
 				const newContent = parts.join(args.new_string);
-				return this.writeReplacement(args, safePath, raw, newContent, modelView.lineEndingStyle, replacementCount);
+				return this.writeReplacement(args, safePath, raw, newContent, modelView.lineEndingStyle, replacementCount, authorization.version);
 			} catch (error) {
 				if (error?.code === "EISDIR") return {
 					isError: true,
@@ -254721,7 +254824,7 @@ var init_edit = __esmMin((() => {
 				};
 			}
 		}
-		async writeReplacement(args, safePath, currentContent, nextContent, lineEndingStyle, replacementCount) {
+		async writeReplacement(args, safePath, currentContent, nextContent, lineEndingStyle, replacementCount, observedVersion) {
 			const materialized = materializeModelText(nextContent, lineEndingStyle);
 			const lineLimit = evaluateSourceFileLineLimit(safePath, materialized, {
 				currentContent,
@@ -254732,7 +254835,14 @@ var init_edit = __esmMin((() => {
 				isError: true,
 				output: lineLimit.error
 			};
-			await this.kaos.writeText(safePath, materialized);
+			const latestStat = await observedFileStat(this.kaos, safePath);
+			const freshness = this.fileObservation.verifyUnchanged(safePath, observedVersion, latestStat);
+			if (!freshness.allowed) return {
+				isError: true,
+				output: `[${freshness.code}] ${freshness.error}`
+			};
+			await writeToolTextAtomic(safePath, materialized);
+			this.fileObservation.recordPresent(safePath, await this.kaos.stat(safePath));
 			const occurrence = replacementCount === 1 ? "occurrence" : "occurrences";
 			const notice = lineLimit.notice === void 0 ? "" : ` ${lineLimit.notice}`;
 			return appendLspDiagnostics({ output: `Replaced ${String(replacementCount)} ${occurrence} in ${args.path}.` + notice }, safePath, this.lsp);
@@ -260327,13 +260437,15 @@ var init_read = __esmMin((() => {
 		kaos;
 		workspace;
 		contextWindowState;
+		fileObservation;
 		name = "Read";
 		description = READ_DESCRIPTION;
 		parameters = toInputJsonSchema(ReadInputSchema);
-		constructor(kaos, workspace, contextWindowState = () => ({})) {
+		constructor(kaos, workspace, contextWindowState = () => ({}), fileObservation) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.contextWindowState = contextWindowState;
+			this.fileObservation = fileObservation;
 		}
 		modelVisibleBytes() {
 			return readModelVisibleBytes(this.contextWindowState());
@@ -260370,10 +260482,13 @@ var init_read = __esmMin((() => {
 				try {
 					stat = await this.kaos.stat(safePath);
 				} catch (error) {
-					if (isFileNotFoundError(error)) return {
-						isError: true,
-						output: `"${args.path}" does not exist.`
-					};
+					if (isFileNotFoundError(error)) {
+						this.fileObservation.recordAbsent(safePath);
+						return {
+							isError: true,
+							output: `"${args.path}" does not exist.`
+						};
+					}
 					throw error;
 				}
 				if (!isRegularFileMode(stat.stMode)) return {
@@ -260394,8 +260509,17 @@ var init_read = __esmMin((() => {
 				const requestedLines = args.n_lines ?? maxLines;
 				const effectiveLimit = Math.min(requestedLines, maxLines);
 				const maxBytes = this.modelVisibleBytes();
-				if (lineOffset < 0) return await this.readTail(safePath, args.path, lineOffset, effectiveLimit, requestedLines, maxBytes, maxLines);
-				return await this.readForward(safePath, args.path, lineOffset, effectiveLimit, requestedLines, maxBytes, maxLines);
+				const result = lineOffset < 0
+					? await this.readTail(safePath, args.path, lineOffset, effectiveLimit, requestedLines, maxBytes, maxLines)
+					: await this.readForward(safePath, args.path, lineOffset, effectiveLimit, requestedLines, maxBytes, maxLines);
+				if (result.isError === true) return result;
+				const afterStat = await observedFileStat(this.kaos, safePath);
+				const stability = this.fileObservation.verifyStableRead(safePath, stat, afterStat);
+				if (!stability.allowed) return {
+					isError: true,
+					output: `[${stability.code}] ${stability.error}`
+				};
+				return result;
 			} catch (error) {
 				if (isTextDecodeError(error)) return {
 					isError: true,
@@ -260662,10 +260786,10 @@ var init_read = __esmMin((() => {
 		name = "ReadBatch";
 		description = READ_BATCH_DESCRIPTION;
 		parameters = toInputJsonSchema(ReadBatchInputSchema);
-		constructor(kaos, workspace, contextWindowState) {
+		constructor(kaos, workspace, contextWindowState, fileObservation) {
 			this.kaos = kaos;
 			this.workspace = workspace;
-			this.reader = new ReadTool(kaos, workspace, contextWindowState);
+			this.reader = new ReadTool(kaos, workspace, contextWindowState, fileObservation);
 		}
 		resolveExecution(args) {
 			const items = args.requests.map((request) => ({
@@ -261090,7 +261214,7 @@ function countCompletedLines(content) {
 	for (const character of content) if (character === "\n") count += 1;
 	return count;
 }
-var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract, resolvePlainWriteContract, splitNativeWriteBytes, writeNativeLargeContentOnDisk;
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract, resolvePlainWriteContract, splitNativeWriteBytes, writeNativeLargeContentOnDisk, writeToolTextAtomic;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -261104,6 +261228,7 @@ var init_write = __esmMin((() => {
 	init_lsp_diagnostics();
 	({ resolveWriteContinuationContract, resolvePlainWriteContract, splitNativeWriteBytes } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
 	({ writeNativeLargeContentOnDisk } = createRequire(import.meta.url)("./bin/native-large-file-io.cjs"));
+	({ writeToolTextAtomic } = createRequire(import.meta.url)("./bin/tool-file-persistence.cjs"));
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
 	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
@@ -261133,17 +261258,19 @@ bytesWritten: number$1().int().nonnegative() });
 		workspace;
 		history;
 		lsp;
+		fileObservation;
 		maxContinuationChunkBytes;
 		name = "Write";
 		description = write_default;
 		parameters = toInputJsonSchema(WriteInputSchema);
 		pendingContinuations = /* @__PURE__ */ new Map();
 		continuationRequiredPaths = /* @__PURE__ */ new Set();
-		constructor(kaos, workspace, history, lsp, maxContinuationChunkBytes = resolveWriteContinuationChunkBytes()) {
+		constructor(kaos, workspace, history, lsp, fileObservation, maxContinuationChunkBytes = resolveWriteContinuationChunkBytes()) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.history = history;
 			this.lsp = lsp;
+			this.fileObservation = fileObservation;
 			this.maxContinuationChunkBytes = maxContinuationChunkBytes;
 		}
 		resolveExecution(args) {
@@ -261312,6 +261439,12 @@ bytesWritten: number$1().int().nonnegative() });
 				isError: true,
 				output: `Refused to write ${args.path}: generated source contains a runaway repeated statement ${String(degenerateStatementRun.count)} times from line ${String(degenerateStatementRun.line)} (starts with ${JSON.stringify(degenerateStatementRun.preview)}). Regenerate that section in a smaller focused chunk. No file was written.`
 			};
+			const currentStat = await observedFileStat(this.kaos, safePath);
+			const authorization = this.fileObservation.authorizeWrite(safePath, currentStat);
+			if (!authorization.allowed) return {
+				isError: true,
+				output: `[${authorization.code}] ${authorization.error}`
+			};
 			let currentContent;
 			if (isSourceFilePath(safePath)) try {
 				currentContent = await this.kaos.readText(safePath);
@@ -261339,9 +261472,16 @@ bytesWritten: number$1().int().nonnegative() });
 				continuationRequired: this.continuationRequiredPaths.has(safePath)
 			});
 			if (!allowLargeContent && !plainWrite.allowed) {
+				const latestStat = await observedFileStat(this.kaos, safePath);
+				const freshness = this.fileObservation.verifyUnchanged(safePath, authorization.version, latestStat);
+				if (!freshness.allowed) return {
+					isError: true,
+					output: `[${freshness.code}] ${freshness.error}`
+				};
 				const chunks = splitNativeWriteBytes(args.content, this.maxContinuationChunkBytes);
 				const nativeResult = await this.writeNativeLargeContent(safePath, chunks, mode);
 				if (nativeResult.isError === true) return nativeResult;
+				this.fileObservation.recordPresent(safePath, await this.kaos.stat(safePath));
 				this.continuationRequiredPaths.delete(safePath);
 				const notice = lineLimit.notice === void 0 ? "" : ` ${lineLimit.notice}`;
 				return appendLspDiagnostics({
@@ -261354,8 +261494,15 @@ bytesWritten: number$1().int().nonnegative() });
 				output: parentError
 			};
 			try {
+				const latestStat = await observedFileStat(this.kaos, safePath);
+				const freshness = this.fileObservation.verifyUnchanged(safePath, authorization.version, latestStat);
+				if (!freshness.allowed) return {
+					isError: true,
+					output: `[${freshness.code}] ${freshness.error}`
+				};
 				if (mode === "append") await this.kaos.writeText(safePath, args.content, { mode: "a" });
-				else await this.kaos.writeText(safePath, args.content);
+				else await writeToolTextAtomic(safePath, args.content);
+				this.fileObservation.recordPresent(safePath, await this.kaos.stat(safePath));
 				const bytesWritten = Buffer.byteLength(args.content, "utf8");
 				const notice = lineLimit.notice === void 0 ? "" : ` ${lineLimit.notice}`;
 				return appendLspDiagnostics({ output: `${mode === "append" ? "Appended" : "Wrote"} ${String(bytesWritten)} bytes to ${args.path}.${notice}` }, safePath, this.lsp);
@@ -261904,7 +262051,8 @@ var init_tool_dedup = __esmMin((() => {
 //#region ../../packages/agent-core/src/agent/turn/tool-result-budget.ts
 async function budgetToolResultForModel(options) {
 	const text = persistableToolResultText(options.result.output);
-	if (text === void 0 || shouldKeepFreshToolResult(options.toolName) || !shouldOffloadToolResult(text.length)) return options.result;
+	const contextUsageRatio = Number.isFinite(options.maxContextTokens) && options.maxContextTokens > 0 ? Number(options.contextTokens) / options.maxContextTokens : 1;
+	if (text === void 0 || shouldKeepFreshToolResult(options.toolName) || !shouldOffloadToolResult(text.length, { contextUsageRatio })) return options.result;
 	const readSourcePath = reusableReadSourcePath(options);
 	if (readSourcePath !== void 0) return referenceReadSourceForModel(options, text, readSourcePath);
 	return persistToolResultForModel(options, text);
@@ -262688,7 +262836,11 @@ function mapLoopEvent(event, turnId) {
 			type: "turn.step.started",
 			turnId,
 			step: event.step,
-			stepId: event.uuid
+			stepId: event.uuid,
+			thinkingEffort: event.thinkingEffort,
+			completionBudget: event.completionBudget,
+			attempt: event.attempt,
+			maxAttempts: event.maxAttempts
 		};
 		case "step.end": return {
 			type: "turn.step.completed",
@@ -262718,7 +262870,9 @@ function mapLoopEvent(event, turnId) {
 			outputMayHaveStarted: event.outputMayHaveStarted,
 			errorName: event.errorName,
 			errorMessage: event.errorMessage,
-			statusCode: event.statusCode
+			statusCode: event.statusCode,
+			completionBudgetBefore: event.completionBudgetBefore,
+			completionBudgetAfter: event.completionBudgetAfter
 		};
 		case "content.part": return;
 		case "tool.call": return {
@@ -263006,6 +263160,7 @@ var init_turn = __esmMin((() => {
 		toolScopeByTurn = /* @__PURE__ */ new Map();
 		interruptedTelemetryTurnIds = /* @__PURE__ */ new Set();
 		stepFailureByTurn = /* @__PURE__ */ new Map();
+		stepRequestStateByTurn = /* @__PURE__ */ new Map();
 		currentStep = 0;
 		cognitiveLifecycle;
 		cognitiveLifecycleUnavailable = false;
@@ -263698,6 +263853,7 @@ var init_turn = __esmMin((() => {
 			this.cognitiveExternalReportsByTurn.delete(turnId);
 			this.cognitiveLocalClaimsByTurn.delete(turnId);
 			this.stepFailureByTurn.delete(turnId);
+			this.stepRequestStateByTurn.delete(turnId);
 			await this.agent.records.flush();
 			await this.agent.records.writeResumeCheckpoint();
 			return {
@@ -263841,6 +263997,8 @@ var init_turn = __esmMin((() => {
 						log: this.agent.log,
 						maxSteps: loopControl?.maxStepsPerTurn,
 						maxRetryAttempts: loopControl?.maxRetriesPerStep,
+						checkpointBeforeToolExecution: () => this.agent.records.flush(),
+						checkpointBeforeRetryWait: () => this.agent.records.flush(),
 						recordStepUsage: async (usage) => {
 							try {
 								stopForGoalBudget = (await this.agent.goal.recordTokenUsage(grandTotal(usage)))?.budget.overBudget === true;
@@ -264038,14 +264196,25 @@ var init_turn = __esmMin((() => {
 										toolOutput: isError === true ? void 0 : toolOutputText(output).slice(0, 2e3)
 									}
 								});
-								return budgetToolResultForModel({
+								const budgetedResult = await budgetToolResultForModel({
 									homedir: this.agent.homedir,
 									toolName: ctx.toolCall.name,
 									toolCallId: ctx.toolCall.id,
 									toolArgs: ctx.args,
 									result: finalResult,
+									contextTokens: this.agent.context.tokenCountWithPending,
+									maxContextTokens: this.agent.config.modelCapabilities.max_context_tokens,
 									telemetry: this.agent.telemetry
 								});
+								if (budgetedResult !== finalResult) this.agent.records.logRecord({
+									type: "policy.intervention",
+									policy: "tool_result_spill",
+									location: "budgetToolResultForModel",
+									size_before: toolOutputText(finalResult.output).length,
+									size_after: toolOutputText(budgetedResult.output).length,
+									unit: "chars"
+								});
+								return budgetedResult;
 							}
 						}
 					})).stopReason;
@@ -264094,6 +264263,26 @@ var init_turn = __esmMin((() => {
 				emitLiveEvent: (event) => {
 					this.noteFirstRequestEvent(event);
 					this.trackLoopTelemetry(event, turnId);
+					if (event.type === "thinking.delta" && event.delta.trim().length === 0) {
+						const requestState = this.stepRequestStateByTurn.get(turnId);
+						this.agent.records.logRecord({
+							type: "thinking.heartbeat",
+							turn_id: turnId,
+							step: this.currentStepByTurn.get(turnId) ?? this.currentStep,
+							attempt: requestState?.attempt ?? 1,
+							max_attempts: requestState?.maxAttempts,
+							completion_budget: requestState?.completionBudget,
+							thinking_effort: requestState?.thinkingEffort
+						});
+					}
+					if (event.type === "step.retrying" && event.completionBudgetBefore !== void 0 && event.completionBudgetAfter !== void 0) this.agent.records.logRecord({
+						type: "policy.intervention",
+						policy: "empty_response_completion_budget_retry",
+						location: "chatWithRetry",
+						size_before: event.completionBudgetBefore,
+						size_after: event.completionBudgetAfter,
+						unit: "tokens"
+					});
 					const mapped = mapLoopEvent(event, turnId);
 					if (mapped !== void 0) return this.agent.emitEvent(mapped);
 				}
@@ -264117,9 +264306,18 @@ var init_turn = __esmMin((() => {
 		}
 		trackLoopTelemetry(event, turnId) {
 			if (event.type === "step.begin") {
-				this.beginTrackedStep(turnId, event.step);
+				this.beginTrackedStep(turnId, event.step, event);
 				return;
 			}
+			if (event.type === "step.retrying") {
+				const previous = this.stepRequestStateByTurn.get(turnId) ?? {};
+				this.stepRequestStateByTurn.set(turnId, {
+					...previous,
+					attempt: event.nextAttempt,
+					maxAttempts: event.maxAttempts,
+					completionBudget: event.completionBudgetAfter ?? previous.completionBudget
+				});
+			}
 			if (event.type === "turn.interrupted") {
 				if (event.reason === "error" && event.activeStep !== void 0) this.stepFailureByTurn.set(turnId, event);
 				this.trackTurnInterrupted(turnId, interruptedStep(event));
@@ -264127,9 +264325,15 @@ var init_turn = __esmMin((() => {
 			}
 			this.trackToolLifecycle(event, turnId);
 		}
-		beginTrackedStep(turnId, step) {
+		beginTrackedStep(turnId, step, event) {
 			this.currentStepByTurn.set(turnId, step);
 			this.currentStep = step;
+			this.stepRequestStateByTurn.set(turnId, {
+				thinkingEffort: event?.thinkingEffort,
+				completionBudget: event?.completionBudget,
+				attempt: event?.attempt ?? 1,
+				maxAttempts: event?.maxAttempts
+			});
 			if (!this.stepToolCallKeys.has(step)) this.stepToolCallKeys.set(step, /* @__PURE__ */ new Set());
 		}
 		trackToolLifecycle(event, turnId) {
@@ -265838,7 +266042,7 @@ var init_builtin = __esmMin((() => {
 var init_types$3 = __esmMin((() => {}));
 //#endregion
 //#region ../../packages/agent-core/src/agent/tool/index.ts
-var import_picomatch, profileToolExclusionPolicy, applyProfileToolExclusions, shouldRecordUserToolUnregister, SHELL_FOREGROUND_TIMEOUT_S, ToolManager;
+var import_picomatch, profileToolExclusionPolicy, applyProfileToolExclusions, shouldRecordUserToolUnregister, createFileObservationPolicy, SHELL_FOREGROUND_TIMEOUT_S, ToolManager;
 var init_tool$1 = __esmMin((() => {
 	init_dist$4();
 	import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
@@ -265854,6 +266058,7 @@ var init_tool$1 = __esmMin((() => {
 	profileToolExclusionPolicy = createRequire(import.meta.url)("./bin/profile-tool-exclusion-policy.cjs");
 	applyProfileToolExclusions = profileToolExclusionPolicy.applyProfileToolExclusions;
 	({ shouldRecordUserToolUnregister } = createRequire(import.meta.url)("./bin/user-tool-record-policy.cjs"));
+	({ createFileObservationPolicy } = createRequire(import.meta.url)("./bin/file-observation-policy.cjs"));
 	SHELL_FOREGROUND_TIMEOUT_S = 120;
 	ToolManager = class {
 		agent;
@@ -266258,11 +266463,12 @@ var init_tool$1 = __esmMin((() => {
 				contextTokens: this.agent.context.tokenCountWithPending,
 				maxContextTokens: this.agent.fullCompaction.getEffectiveMaxContextTokens()
 			});
+			const fileObservation = createFileObservationPolicy({ pathClass: kaos.pathClass() });
 			this.builtinTools = new Map([
-				new ReadTool(kaos, workspace, readBudget),
-				new ReadBatchTool(kaos, workspace, readBudget),
-				new WriteTool(kaos, workspace, () => this.agent.context.history, toolServices?.lsp),
-				new EditTool(kaos, workspace, () => this.agent.context.history, toolServices?.lsp),
+				new ReadTool(kaos, workspace, readBudget, fileObservation),
+				new ReadBatchTool(kaos, workspace, readBudget, fileObservation),
+				new WriteTool(kaos, workspace, () => this.agent.context.history, toolServices?.lsp, fileObservation),
+				new EditTool(kaos, workspace, () => this.agent.context.history, toolServices?.lsp, fileObservation),
 				new GrepTool(kaos, workspace, this.agent.telemetry),
 				new GlobTool(kaos, workspace, this.agent.telemetry),
 				new BashTool(kaos, cwd, background, { allowBackground }),
@@ -266692,7 +266898,7 @@ var init_llm_request_logger = __esmMin((() => {
 function normalizeRuntimeSystemPromptAppend(value) {
 	return value?.trim().slice(0, 16e3) ?? "";
 }
-var PINNED_MODEL_ALIASES, createEffectiveSystemPromptResolver, resolveProviderIdleTimeoutMs, capCompletionBudgetForAdaptiveEffort, capTurnCompletionTokens, selectThinkingEffortForBufferedSteer, selectThinkingEffortForWorkStep, selectThinkingEffortForTurn, Agent$1;
+var PINNED_MODEL_ALIASES, createEffectiveSystemPromptResolver, resolveProviderIdleTimeoutMs, capCompletionBudgetForAdaptiveEffort, selectThinkingEffortForBufferedSteer, selectThinkingEffortForWorkStep, selectThinkingEffortForTurn, Agent$1;
 var init_agent = __esmMin((() => {
 	init_dist$6();
 	init_config$4();
@@ -266731,7 +266937,7 @@ var init_agent = __esmMin((() => {
 	init_error_memory();
 	({ createEffectiveSystemPromptResolver } = createRequire(import.meta.url)("./bin/effective-system-prompt-cache-policy.cjs"));
 	({ resolveProviderIdleTimeoutMs } = createRequire(import.meta.url)("./bin/provider-idle-timeout-policy.cjs"));
-	({ capCompletionBudgetForAdaptiveEffort, capTurnCompletionTokens, selectThinkingEffortForBufferedSteer, selectThinkingEffortForWorkStep, selectThinkingEffortForTurn } = createRequire(import.meta.url)("./bin/turn-thinking-policy.cjs"));
+	({ capCompletionBudgetForAdaptiveEffort, selectThinkingEffortForBufferedSteer, selectThinkingEffortForWorkStep, selectThinkingEffortForTurn } = createRequire(import.meta.url)("./bin/turn-thinking-policy.cjs"));
 	PINNED_MODEL_ALIASES = new Set(["blun/king"]);
 	Agent$1 = class {
 		type;
@@ -266926,7 +267132,7 @@ var init_agent = __esmMin((() => {
 			const provider = thinkingEffort === void 0 ? runtimeModel.provider : runtimeModel.provider.withThinking(thinkingEffort);
 			const loopControl = this.blunConfig?.loopControl;
 			const completionBudgetConfig = resolveCompletionBudget({
-				maxOutputSize: capTurnCompletionTokens(runtimeModel.maxOutputSize),
+				maxOutputSize: runtimeModel.maxOutputSize,
 				reservedContextSize: loopControl?.reservedContextSize
 			});
 			return new KosongLLM({
@@ -343755,7 +343961,7 @@ const DEFAULT_NOTIFICATIONS_CONFIG = {
 	enabled: true,
 	condition: "unfocused"
 };
-const DEFAULT_UPGRADE_PREFERENCES = { autoInstall: true };
+const DEFAULT_UPGRADE_PREFERENCES = { autoInstall: false };
 /**
 * F2 Tippen-mit-Vorschlag: Code-Sprachen standardmäßig an, md/plain aus.
 * Unbekannte Sprachen fallen auf "an" zurück (Opt-out über tui.toml).
@@ -409266,6 +409472,9 @@ var TUI = class TUI extends Container {
 	setClearOnShrink(enabled) {
 		this.clearOnShrink = enabled;
 	}
+	getRenderHeight() {
+		return this.terminal.rows;
+	}
 	setFocus(component) {
 		this.setFocusInternal({
 			component,
@@ -409874,7 +410083,7 @@ var TUI = class TUI extends Container {
 	doRender() {
 		if (this.stopped) return;
 		const width = this.terminal.columns;
-		const height = this.terminal.rows;
+		const height = this.getRenderHeight();
 		const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
 		const heightChanged = this.previousHeight !== 0 && this.previousHeight !== height;
 		const previousBufferLength = this.previousHeight > 0 ? this.previousViewportTop + this.previousHeight : height;
@@ -493584,12 +493793,28 @@ registerUiCatalogFragment({
 	en: {
 		"thinking.label": "{name} thinking",
 		"thinking.aborted": "aborted",
+		"thinking.step": "step {step}",
+		"thinking.effort": "effort {effort}",
+		"thinking.attempt": "attempt {attempt}/{maxAttempts}",
+		"thinking.budget": "budget {budget}",
+		"thinking.heartbeat": "hidden-thought heartbeat {seconds}s ago",
+		"thinking.worked": "Worked {elapsed}",
+		"thinking.finished": "done {time}",
+		"thinking.emptyRetry": "Empty model response; {hint} · budget {before} → {after}",
 		"thinking.tokens.one": "{count} Token",
 		"thinking.tokens.other": "{count} Tokens"
 	},
 	de: {
 		"thinking.label": "{name} denkt",
 		"thinking.aborted": "abgebrochen",
+		"thinking.step": "Schritt {step}",
+		"thinking.effort": "Effort {effort}",
+		"thinking.attempt": "Versuch {attempt}/{maxAttempts}",
+		"thinking.budget": "Budget {budget}",
+		"thinking.heartbeat": "Verdecktes Denken läuft · letzter Takt vor {seconds}s",
+		"thinking.worked": "Gearbeitet {elapsed}",
+		"thinking.finished": "fertig {time}",
+		"thinking.emptyRetry": "Leere Modellantwort; {hint} · Budget {before} → {after}",
 		"thinking.tokens.one": "{count} Token",
 		"thinking.tokens.other": "{count} Tokens"
 	},
@@ -493643,6 +493868,14 @@ var ThinkingComponent = class {
 	thinkElapsedMs = 0;
 	thinkAborted = false;
 	estimatedOutputTokens = 0;
+	step;
+	thinkingEffort;
+	attempt = 1;
+	maxAttempts = 1;
+	completionBudget;
+	lastHeartbeatAtMs;
+	activeToolName;
+	finishedAtMs;
 	textComponent;
 	renderCache;
 	constructor(text, showMarker = true, mode = "finalized", ui, metrics) {
@@ -493657,6 +493890,7 @@ var ThinkingComponent = class {
 			this.thinkStartMs = metrics?.startedAtMs ?? Date.now();
 			this.thinkAborted = false;
 			this.estimatedOutputTokens = metrics?.estimatedOutputTokens ?? 0;
+			this.applyLiveMetrics(metrics ?? {});
 		}
 	}
 	markRenderDirty() {
@@ -493675,10 +493909,22 @@ var ThinkingComponent = class {
 	}
 	setLiveMetrics(metrics) {
 		if (this.mode === "live" && !this.thinkAborted && metrics.startedAtMs !== void 0) this.thinkStartMs = metrics.startedAtMs;
-		if (metrics.estimatedOutputTokens === this.estimatedOutputTokens) return;
+		const before = JSON.stringify([this.estimatedOutputTokens, this.step, this.thinkingEffort, this.attempt, this.maxAttempts, this.completionBudget, this.lastHeartbeatAtMs, this.activeToolName]);
 		this.estimatedOutputTokens = metrics.estimatedOutputTokens;
+		this.applyLiveMetrics(metrics);
+		const after = JSON.stringify([this.estimatedOutputTokens, this.step, this.thinkingEffort, this.attempt, this.maxAttempts, this.completionBudget, this.lastHeartbeatAtMs, this.activeToolName]);
+		if (before === after) return;
 		this.markRenderDirty();
 	}
+	applyLiveMetrics(metrics) {
+		this.step = metrics.step;
+		this.thinkingEffort = metrics.thinkingEffort;
+		this.attempt = metrics.attempt ?? 1;
+		this.maxAttempts = metrics.maxAttempts ?? 1;
+		this.completionBudget = metrics.completionBudget;
+		this.lastHeartbeatAtMs = metrics.lastHeartbeatAtMs;
+		this.activeToolName = metrics.activeToolName;
+	}
 	styled(text) {
 		return currentTheme.italicFg("textDim", text);
 	}
@@ -493690,6 +493936,7 @@ var ThinkingComponent = class {
 			this.thinkElapsedMs = Date.now() - this.thinkStartMs;
 			this.thinkStartMs = null;
 		}
+		this.finishedAtMs = Date.now();
 	}
 	dispose() {
 		this.stopSpinner();
@@ -493713,12 +493960,24 @@ var ThinkingComponent = class {
 			const abortMark = this.thinkAborted ? ` (${uiText("thinking.aborted")})` : "";
 			const tokenKey = roundedTokenCount === 1 ? "thinking.tokens.one" : "thinking.tokens.other";
 			const thinkingLabel = uiText("thinking.label", { name: this.persona });
-			const fullLabel = `${thinkingLabel}… (${elapsed} · ↓ ~${uiText(tokenKey, { count: tokenCount })} · ${startedAt})${abortMark}`;
-			const compactLabel = `${thinkingLabel}… (${elapsed} · ↓${tokenCount} · ${startedAt})${abortMark}`;
+			const details = [];
+			if (this.step !== void 0) details.push(uiText("thinking.step", { step: this.step }));
+			if (this.thinkingEffort !== void 0) details.push(uiText("thinking.effort", { effort: this.thinkingEffort }));
+			if (this.attempt > 1 || this.maxAttempts > 1) details.push(uiText("thinking.attempt", { attempt: this.attempt, maxAttempts: this.maxAttempts }));
+			if (this.completionBudget !== void 0) details.push(uiText("thinking.budget", { budget: this.completionBudget.toLocaleString(locale) }));
+			if (this.lastHeartbeatAtMs !== void 0) details.push(uiText("thinking.heartbeat", { seconds: Math.max(0, Math.floor((Date.now() - this.lastHeartbeatAtMs) / 1e3)) }));
+			if (this.activeToolName !== void 0) details.push(this.activeToolName);
+			const detailText = details.length === 0 ? "" : ` · ${details.join(" · ")}`;
+			const fullLabel = `${thinkingLabel}… (${elapsed} · ↓ ~${uiText(tokenKey, { count: tokenCount })}${detailText} · ${startedAt})${abortMark}`;
+			const compactLabel = `${thinkingLabel}… (${elapsed} · ↓${tokenCount}${this.step === void 0 ? "" : ` · #${this.step}`} · ${startedAt})${abortMark}`;
 			const metricsOnly = `(${elapsed} · ${startedAt})${abortMark}`;
 			const availableWidth = Math.max(1, width - visibleWidth(spinner));
 			const label = visibleWidth(fullLabel) <= availableWidth ? fullLabel : visibleWidth(compactLabel) <= availableWidth ? compactLabel : metricsOnly;
 			rendered = ["", spinner + currentTheme.fg("textDim", truncateToWidth(label, availableWidth))];
+		} else if (this.thinkElapsedMs > 0) {
+			const finishedAt = new Date(this.finishedAtMs ?? Date.now()).toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
+			const finalLabel = `${uiText("thinking.worked", { elapsed: formatLiveElapsed(this.formatElapsedSeconds()) })} · ${uiText("thinking.finished", { time: finishedAt })}`;
+			rendered = ["", currentTheme.fg("textDim", truncateToWidth(finalLabel, Math.max(1, width)))];
 		} else rendered = [""];
 		if (isRenderCacheEnabled()) this.renderCache = {
 			width,
@@ -508308,6 +508567,9 @@ var BottomPinnedTUI = class extends TUI {
 	* page-up/down jumps without re-reading the live (possibly stale) value.
 	*/
 	getTerminalRows() {
+		return this.getRenderHeight();
+	}
+	getRenderHeight() {
 		this.ensureResizeLatch();
 		return this.latchedTerminalRows > 0 ? this.latchedTerminalRows : currentTerminalRows(this.terminal.rows);
 	}
@@ -510438,7 +510700,7 @@ var SessionEventHandler = class {
 		this.host.commitQueuedSteerAtStepStart(event.turnId);
 		this.host.commitChannelPromptAtStepStart(event.turnId);
 		this.host.streamingUI.flushNow();
-		this.host.streamingUI.setStep(event.step);
+		this.host.streamingUI.beginStep(event);
 		this.host.streamingUI.resetToolUi();
 		this.host.streamingUI.finalizeLiveTextBuffers("waiting");
 		this.host.patchLivePane({
@@ -510512,7 +510774,8 @@ var SessionEventHandler = class {
 	handleStepRetrying(event) {
 		this.turnWatchdog.recordProgress();
 		const hint = formatModelRetryProgress(event);
-		if (event.outputMayHaveStarted === true) {
+		const completionBudgetRetry = event.completionBudgetBefore !== void 0 && event.completionBudgetAfter !== void 0;
+		if (event.outputMayHaveStarted === true || completionBudgetRetry) {
 			const { streamingUI } = this.host;
 			streamingUI.flushNow();
 			streamingUI.discardUnfinishedToolUi();
@@ -510522,9 +510785,14 @@ var SessionEventHandler = class {
 				kind: "status",
 				turnId: String(event.turnId),
 				renderMode: "plain",
-				content: uiText("sessionEvent.interrupted.reason", { reason: hint })
+				content: completionBudgetRetry ? uiText("thinking.emptyRetry", {
+					hint,
+					before: event.completionBudgetBefore.toLocaleString(getCurrentUiLocale()),
+					after: event.completionBudgetAfter.toLocaleString(getCurrentUiLocale())
+				}) : uiText("sessionEvent.interrupted.reason", { reason: hint })
 			});
 		}
+		this.host.streamingUI.noteStepRetry(event);
 		this.modelRetryHint = hint;
 		this.host.state.footer.setTransientHint(hint);
 		this.host.state.ui.requestRender();
@@ -510540,6 +510808,7 @@ var SessionEventHandler = class {
 	handleThinkingDelta(event) {
 		const { state, streamingUI } = this.host;
 		if (event.delta.length === 0 && !streamingUI.hasThinkingDraft()) return;
+		if (event.delta.trim().length === 0) streamingUI.noteThinkingHeartbeat();
 		if (event.delta.length > 0) this.turnWatchdog.recordProgress();
 		if (event.delta.length > 0) this.clearModelRetryHint();
 		streamingUI.appendThinkingDelta(event.delta);
@@ -513582,6 +513851,9 @@ var StreamingUIController = class {
 	_remoteTurnActivity = { active: false };
 	_remoteProcessStartedAt = new Date(Date.now() - process.uptime() * 1e3).toISOString();
 	_liveTurnStartedAtMs = void 0;
+	_liveStepStartedAtMs = void 0;
+	_liveThinkingHeartbeatAtMs = void 0;
+	_liveStepRequest = {};
 	_liveOutputTokens = new LiveOutputTokenCounter();
 	_countedToolCallIds = /* @__PURE__ */ new Set();
 	_assistantDraft = "";
@@ -513612,6 +513884,32 @@ var StreamingUIController = class {
 		this._currentStep = step;
 		this.publishTelegramConsoleStatus();
 	}
+	beginStep(event) {
+		this.setStep(event.step);
+		this._liveStepStartedAtMs = Date.now();
+		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveOutputTokens.reset();
+		this._countedToolCallIds.clear();
+		this._liveStepRequest = {
+			thinkingEffort: event.thinkingEffort,
+			completionBudget: event.completionBudget,
+			attempt: event.attempt ?? 1,
+			maxAttempts: event.maxAttempts ?? 1
+		};
+	}
+	noteStepRetry(event) {
+		this._liveStepStartedAtMs = Date.now();
+		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveStepRequest = {
+			...this._liveStepRequest,
+			attempt: event.nextAttempt,
+			maxAttempts: event.maxAttempts,
+			completionBudget: event.completionBudgetAfter ?? this._liveStepRequest.completionBudget
+		};
+	}
+	noteThinkingHeartbeat() {
+		this._liveThinkingHeartbeatAtMs = Date.now();
+	}
 	setRemoteTurnActivity(activity) {
 		const previous = this._remoteTurnActivity;
 		this._remoteTurnActivity = activity?.active === true ? activity : { active: false };
@@ -513640,14 +513938,25 @@ var StreamingUIController = class {
 	}
 	beginLiveTurn() {
 		this._liveTurnStartedAtMs = Date.now();
+		this._liveStepStartedAtMs = void 0;
+		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveStepRequest = {};
 		this._liveOutputTokens.reset();
 		this._countedToolCallIds.clear();
 		this.lastFlushAt = void 0;
 	}
 	getLiveActivityMetrics() {
+		const activeToolName = [...this._activeToolCalls.values()].at(-1)?.name ?? [...this._streamingToolCallArguments.values()].at(-1)?.name;
 		return {
-			startedAtMs: this._liveTurnStartedAtMs,
-			estimatedOutputTokens: this._liveOutputTokens.estimatedOutputTokens()
+			startedAtMs: this._liveStepStartedAtMs ?? this._liveTurnStartedAtMs,
+			estimatedOutputTokens: this._liveOutputTokens.estimatedOutputTokens(),
+			step: this._currentStep,
+			thinkingEffort: this._liveStepRequest.thinkingEffort,
+			completionBudget: this._liveStepRequest.completionBudget,
+			attempt: this._liveStepRequest.attempt ?? 1,
+			maxAttempts: this._liveStepRequest.maxAttempts ?? 1,
+			lastHeartbeatAtMs: this._liveThinkingHeartbeatAtMs,
+			activeToolName
 		};
 	}
 	recordLiveOutput(fragment) {
@@ -513688,6 +513997,9 @@ var StreamingUIController = class {
 	}
 	resetLiveActivity() {
 		this._liveTurnStartedAtMs = void 0;
+		this._liveStepStartedAtMs = void 0;
+		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveStepRequest = {};
 		this._liveOutputTokens.reset();
 		this._countedToolCallIds.clear();
 	}