blun-king-cli 9.1.564 → 9.1.566

package/blun.mjs

@@ -17,6 +17,7 @@ import sessionScrollbackArchive from "./bin/session-scrollback-archive.cjs";
 import sessionReplayWindowPolicy from "./bin/session-replay-window-policy.cjs";
 import globPatternPolicy from "./bin/glob-pattern-policy.cjs";
 import userHomePathPolicy from "./bin/user-home-path-policy.cjs";
+import nativeRuntimeCachePolicy from "./bin/native-runtime-cache.cjs";
 import editableToolApprovalPolicy from "./bin/editable-tool-approval-policy.cjs";
 import editableToolApprovalRuntime from "./bin/editable-tool-approval-runtime.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
@@ -59,6 +60,7 @@ const { SessionScrollbackArchive, sessionScrollbackArchiveDirectory } = sessionS
 const { replayWindowStartIndex, resolveReplayActiveTurnCount } = sessionReplayWindowPolicy;
 const { globPatternError } = globPatternPolicy;
 const { unsupportedUserHomePathError } = userHomePathPolicy;
+const { resolveNativeRuntimePath } = nativeRuntimeCachePolicy;
 const {
 	buildApprovalEditedEvent,
 	canonicalEditedToolInputJson,
@@ -2705,9 +2707,14 @@ var init_blun = __esmMin((() => {
 					if (!choice) continue;
 					if (choice.finish_reason !== null && choice.finish_reason !== void 0) this._captureFinishReason(choice.finish_reason);
 					const delta = choice.delta ?? {};
+					const hiddenThinkingTokens = typeof delta.blun_denk_tokens === "number" && Number.isFinite(delta.blun_denk_tokens) && delta.blun_denk_tokens >= 0 ? Math.floor(delta.blun_denk_tokens) : void 0;
+					if (hiddenThinkingTokens !== void 0) yield {
+						type: "think_tokens",
+						thinkTokens: hiddenThinkingTokens
+					};
 					const reasoning = observeBlunReasoning(delta);
 					this._reasoningFieldState = mergeReasoningFieldState(this._reasoningFieldState, reasoning.state);
-					if (reasoning.value !== void 0) yield {
+					if (reasoning.value !== void 0 && (hiddenThinkingTokens === void 0 || reasoning.value.trim().length > 0)) yield {
 						type: "think",
 						think: reasoning.value
 					};
@@ -74783,6 +74790,11 @@ function buildKosongCallbacks(params, markStreamOutput) {
 			params.onThinkDelta(part.think);
 			return;
 		}
+		if (part.type === "think_tokens") {
+			if (params.onThinkTokens === void 0) return;
+			params.onThinkTokens(part.thinkTokens);
+			return;
+		}
 		if (part.type === "function") {
 			const identity = {
 				toolCallId: part.id,
@@ -245084,7 +245096,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, checkpointBeforeToolExecution, checkpointBeforeRetryWait } = deps;
+	const { turnId, signal, buildMessages, buildMessagesStrict, dispatchEvent, llm, tools, hooks, log, currentStep, maxRetryAttempts, recordUsage, onStepStarted, checkpointBeforeToolExecution, checkpointBeforeRetryWait, beginInterruptibleRequest, endInterruptibleRequest } = deps;
 	const beforeStep = hooks?.beforeStep === void 0 ? void 0 : await hooks.beforeStep({
 		turnId,
 		stepNumber: currentStep,
@@ -245132,6 +245144,9 @@ async function executeLoopStep(deps) {
 	if (prepareRequestBoundary === void 0) await stepEvents.start();
 	else chatParams = await prepareRequestBoundary(chatParams, stepBuildMessages);
 	signal.throwIfAborted();
+	const requestSignal = beginInterruptibleRequest?.() ?? signal;
+	const wasInterruptedByActiveSteer = (error) => isActiveSteerInterrupt(error) || isActiveSteerInterrupt(requestSignal.reason);
+	chatParams = { ...chatParams, signal: requestSignal };
 	const retryInput = {
 		llm: stepLLM,
 		dispatchEvent: (event) => stepEvents.dispatchRetrying(event),
@@ -245148,11 +245163,20 @@ async function executeLoopStep(deps) {
 			retryInput,
 			params: chatParams,
 			stepEvents,
-			signal,
+			signal: requestSignal,
 			log
 		});
 	} catch (error) {
 		await stepEvents.drain();
+		if (wasInterruptedByActiveSteer(error) && !signal.aborted) {
+			await dispatchEvent({
+				type: "turn.interrupted",
+				reason: "steered",
+				attemptedSteps: currentStep,
+				activeStep: currentStep
+			});
+			return { usage: emptyUsage(), stopReason: "steer_restart" };
+		}
 		if (stepBuildMessagesStrict === void 0 || !isRecoverableRequestStructureError(error) || prepareRequestBoundary !== void 0 && stepEvents.hasOutput) throw error;
 		signal.throwIfAborted();
 		log?.warn("provider rejected request structure; resending with strict projection", {
@@ -245172,10 +245196,19 @@ async function executeLoopStep(deps) {
 				retryInput,
 				params: strictParams,
 				stepEvents,
-				signal,
+				signal: requestSignal,
 				log
 			});
 		} catch (strictError) {
+			if (wasInterruptedByActiveSteer(strictError) && !signal.aborted) {
+				await dispatchEvent({
+					type: "turn.interrupted",
+					reason: "steered",
+					attemptedSteps: currentStep,
+					activeStep: currentStep
+				});
+				return { usage: emptyUsage(), stopReason: "steer_restart" };
+			}
 			log?.error("strict resend still rejected by provider; request remains wire-invalid", {
 				turnStep: `${turnId}.${String(currentStep)}`,
 				model: stepLLM.modelName,
@@ -245185,6 +245218,8 @@ async function executeLoopStep(deps) {
 			throw strictError;
 		}
 		log?.info("recovered after strict resend", { turnStep: `${turnId}.${String(currentStep)}` });
+	} finally {
+		endInterruptibleRequest?.();
 	}
 	await stepEvents.start();
 	await stepEvents.drain();
@@ -245275,20 +245310,53 @@ function stepEndProviderDiagnostics(response, stopReason) {
 	};
 }
 var { createLiveResponseRepetitionGuard } = createRequire(import.meta.url)("./bin/live-response-repetition-guard.cjs");
+var { createThinkingOnlyGuard, forceAnswerParams } = createRequire(import.meta.url)("./bin/thinking-only-guard.cjs");
+var { ACTIVE_STEER_PRIORITY_REMINDER, createActiveSteerInterrupt, isActiveSteerInterrupt } = createRequire(import.meta.url)("./bin/active-steer-priority-policy.cjs");
 async function chatWithLiveResponseRepetitionRecovery(deps) {
 	const { retryInput, params, stepEvents, signal, log } = deps;
+	let currentParams = params;
 	for (let attempt = 1; attempt <= 2; attempt++) {
 		try {
-			return await chatWithRetry({
+			const response = await chatWithRetry({
 				...retryInput,
 				params: {
-					...params,
+					...currentParams,
 					signal: stepEvents.beginLiveResponseAttempt(signal)
 				}
 			});
+			stepEvents.finishLiveResponseAttempt();
+			return response;
 		} catch (error) {
 			await stepEvents.drain();
 			const repetition = stepEvents.liveRepetitionResult;
+			const thinkingTimeout = stepEvents.thinkingOnlyTimeoutResult;
+			stepEvents.finishLiveResponseAttempt();
+			if (thinkingTimeout !== null && !signal.aborted && attempt < 2) {
+				log?.warn("thinking-only phase exceeded limit; forcing answer", {
+					elapsedMs: thinkingTimeout.elapsedMs,
+					turnStep: `${retryInput.turnId}.${String(retryInput.currentStep)}`
+				});
+				await persistRetrySchedule({
+					dispatchRetrying: (event) => stepEvents.dispatchRetrying(event),
+					flush: retryInput.checkpointBeforeRetryWait,
+					signal,
+					event: {
+						type: "step.retrying",
+						turnId: retryInput.turnId,
+						step: retryInput.currentStep,
+						stepUuid: retryInput.stepUuid,
+						failedAttempt: attempt,
+						nextAttempt: attempt + 1,
+						maxAttempts: 2,
+						delayMs: 0,
+						outputMayHaveStarted: true,
+						errorName: "ThinkingOnlyTimeoutError",
+						errorMessage: "Hidden thinking exceeded the bounded thinking-only phase"
+					}
+				});
+				currentParams = forceAnswerParams(currentParams);
+				continue;
+			}
 			if (repetition === null || signal.aborted || attempt >= 2) throw error;
 			log?.warn("live response repetition detected; retrying step once", {
 				charCount: repetition.charCount,
@@ -245325,6 +245393,9 @@ function createStepEventGate(deps) {
 	let liveRepetitionGuard;
 	let liveRepetitionController;
 	let liveRepetitionResult = null;
+	let thinkingOnlyController;
+	let thinkingOnlyGuard;
+	let thinkingOnlyTimeoutResult = null;
 	const start = () => {
 		startPromise ??= (async () => {
 			await dispatchEvent({
@@ -245365,12 +245436,25 @@ function createStepEventGate(deps) {
 		get liveRepetitionResult() {
 			return liveRepetitionResult;
 		},
+		get thinkingOnlyTimeoutResult() {
+			return thinkingOnlyTimeoutResult;
+		},
 		beginLiveResponseAttempt: (signal) => {
 			liveRepetitionGuard = createLiveResponseRepetitionGuard();
 			liveRepetitionController = new AbortController();
 			liveRepetitionResult = null;
-			return AbortSignal.any([signal, liveRepetitionController.signal]);
+			thinkingOnlyController = new AbortController();
+			thinkingOnlyTimeoutResult = null;
+			thinkingOnlyGuard = createThinkingOnlyGuard({
+				onTimeout: (result) => {
+					thinkingOnlyTimeoutResult = result;
+					thinkingOnlyController?.abort(/* @__PURE__ */ new Error("Hidden thinking exceeded the bounded thinking-only phase"));
+				}
+			});
+			thinkingOnlyGuard.beginAttempt();
+			return AbortSignal.any([signal, liveRepetitionController.signal, thinkingOnlyController.signal]);
 		},
+		finishLiveResponseAttempt: () => thinkingOnlyGuard?.stop(),
 		dispatchRetrying: async (event) => {
 			const queued = eventQueue.then(async () => {
 				await start();
@@ -245383,6 +245467,7 @@ function createStepEventGate(deps) {
 		drain: async () => eventQueue,
 		callbacks: {
 			onTextDelta: (delta) => {
+				if (delta.length > 0) thinkingOnlyGuard?.noteSubstantiveOutput();
 				if (inspectLiveRepetition(delta)) return;
 				enqueue(() => {
 					dispatchEvent({
@@ -245392,6 +245477,7 @@ function createStepEventGate(deps) {
 				});
 			},
 			onThinkDelta: (delta) => {
+				thinkingOnlyGuard?.noteThinking();
 				if (inspectLiveRepetition(delta)) return;
 				enqueue(() => {
 					dispatchEvent({
@@ -245400,7 +245486,17 @@ function createStepEventGate(deps) {
 					});
 				});
 			},
+			onThinkTokens: (cumulativeTokens) => {
+				thinkingOnlyGuard?.noteThinking();
+				enqueue(() => {
+					dispatchEvent({
+						type: "thinking.progress",
+						cumulativeTokens
+					});
+				});
+			},
 			onToolCallDelta: (delta) => {
+				thinkingOnlyGuard?.noteSubstantiveOutput();
 				enqueue(() => {
 					dispatchEvent({
 						type: "tool.call.delta",
@@ -245410,14 +245506,17 @@ function createStepEventGate(deps) {
 					});
 				});
 			},
-			onTextPart: (part) => enqueue(() => dispatchEvent({
-				type: "content.part",
-				uuid: randomUUID(),
-				turnId,
-				step: currentStep,
-				stepUuid,
-				part
-			})),
+			onTextPart: (part) => {
+				thinkingOnlyGuard?.noteSubstantiveOutput();
+				return enqueue(() => dispatchEvent({
+					type: "content.part",
+					uuid: randomUUID(),
+					turnId,
+					step: currentStep,
+					stepUuid,
+					part
+				}));
+			},
 			onThinkPart: (part) => enqueue(() => dispatchEvent({
 				type: "content.part",
 				uuid: randomUUID(),
@@ -245474,6 +245573,10 @@ async function runTurn(input) {
 				onStepStarted: setActiveStep.bind(void 0, stepNumber)
 			});
 			activeStep = void 0;
+			if (stepResult.stopReason === "steer_restart") {
+				steps -= 1;
+				continue;
+			}
 			if (stepResult.stopReason === "tool_use") continue;
 			const terminalStopReason = stepResult.stopReason;
 			stopReason = terminalStopReason;
@@ -246368,7 +246471,7 @@ var init_modelCatalog$2 = __esmMin((() => {
 function isVolatileEventType(type) {
 	return volatileEventTypeSet.has(type);
 }
-var MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE, tokenUsageSchema, finishReasonSchema, usageStatusSchema, permissionModeSchema, skillSourceSchema, userPromptOriginSchema, skillActivationOriginSchema, pluginCommandOriginSchema, injectionOriginSchema, shellCommandOriginSchema, compactionSummaryOriginSchema, cronToolScopeSchema, systemTriggerOriginSchema, agentCoreBackgroundTaskStatusSchema, backgroundTaskOriginSchema, cronJobOriginSchema, cronMissedOriginSchema, hookResultOriginSchema, retryOriginSchema, promptOriginSchema, goalStatusSchema, goalActorSchema, goalBudgetReportSchema, goalSnapshotSchema, goalChangeStatsSchema, goalChangeKindSchema, goalChangeSchema, blunErrorCodeSchema, blunErrorPayloadSchema, backgroundTaskInfoBaseSchema, processBackgroundTaskInfoSchema, agentBackgroundTaskInfoSchema, questionBackgroundTaskInfoSchema, backgroundTaskInfoSchema, compactionResultSchema, toolUpdateSchema, turnEndReasonSchema, agentStatusUpdatedEventSchema, sessionMetaUpdatedEventSchema, sessionCreatedEventSchema, workspaceCreatedEventSchema, workspaceUpdatedEventSchema, workspaceDeletedEventSchema, sessionStatusChangedEventSchema, modelCatalogChangedEventSchema, goalUpdatedEventSchema, skillActivatedEventSchema, pluginCommandActivatedEventSchema, errorEventSchema, warningEventSchema, turnStartedEventSchema, turnEndedEventSchema, turnStepStartedEventSchema, turnStepCompletedEventSchema, turnStepRetryingEventSchema, turnStepInterruptedEventSchema, assistantDeltaEventSchema, hookResultEventSchema, thinkingDeltaEventSchema, toolCallDeltaEventSchema, toolCallStartedEventSchema, toolProgressEventSchema, shellOutputEventSchema, shellStartedEventSchema, toolResultEventSchema, subagentSpawnedEventSchema, subagentStartedEventSchema, subagentSuspendedEventSchema, subagentCompletedEventSchema, subagentFailedEventSchema, compactionStartedEventSchema, compactionBlockedEventSchema, compactionCancelledEventSchema, compactionProgressEventSchema, compactionCompletedEventSchema, backgroundTaskStartedEventSchema, backgroundTaskTerminatedEventSchema, cronFiredEventSchema, cronRunCreatedEventSchema, cronRunStartedEventSchema, cronRunTerminalEventSchema, attentionIntentSchema, attentionAuthorizedEventSchema, promptSubmittedEventSchema, toolListUpdatedReasonSchema, toolListUpdatedEventSchema, mcpServerStatusPayloadSchema, mcpServerStatusEventSchema, mediaDroppedEventSchema, agentEventSchema, eventSchema, VOLATILE_EVENT_TYPES, volatileEventTypeSet;
+var MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE, tokenUsageSchema, finishReasonSchema, usageStatusSchema, permissionModeSchema, skillSourceSchema, userPromptOriginSchema, skillActivationOriginSchema, pluginCommandOriginSchema, injectionOriginSchema, shellCommandOriginSchema, compactionSummaryOriginSchema, cronToolScopeSchema, systemTriggerOriginSchema, agentCoreBackgroundTaskStatusSchema, backgroundTaskOriginSchema, cronJobOriginSchema, cronMissedOriginSchema, hookResultOriginSchema, retryOriginSchema, promptOriginSchema, goalStatusSchema, goalActorSchema, goalBudgetReportSchema, goalSnapshotSchema, goalChangeStatsSchema, goalChangeKindSchema, goalChangeSchema, blunErrorCodeSchema, blunErrorPayloadSchema, backgroundTaskInfoBaseSchema, processBackgroundTaskInfoSchema, agentBackgroundTaskInfoSchema, questionBackgroundTaskInfoSchema, backgroundTaskInfoSchema, compactionResultSchema, toolUpdateSchema, turnEndReasonSchema, agentStatusUpdatedEventSchema, sessionMetaUpdatedEventSchema, sessionCreatedEventSchema, workspaceCreatedEventSchema, workspaceUpdatedEventSchema, workspaceDeletedEventSchema, sessionStatusChangedEventSchema, modelCatalogChangedEventSchema, goalUpdatedEventSchema, skillActivatedEventSchema, pluginCommandActivatedEventSchema, errorEventSchema, warningEventSchema, turnStartedEventSchema, turnEndedEventSchema, turnStepStartedEventSchema, turnStepCompletedEventSchema, turnStepRetryingEventSchema, turnStepInterruptedEventSchema, assistantDeltaEventSchema, hookResultEventSchema, thinkingDeltaEventSchema, thinkingProgressEventSchema, toolCallDeltaEventSchema, toolCallStartedEventSchema, toolProgressEventSchema, shellOutputEventSchema, shellStartedEventSchema, toolResultEventSchema, subagentSpawnedEventSchema, subagentStartedEventSchema, subagentSuspendedEventSchema, subagentCompletedEventSchema, subagentFailedEventSchema, compactionStartedEventSchema, compactionBlockedEventSchema, compactionCancelledEventSchema, compactionProgressEventSchema, compactionCompletedEventSchema, backgroundTaskStartedEventSchema, backgroundTaskTerminatedEventSchema, cronFiredEventSchema, cronRunCreatedEventSchema, cronRunStartedEventSchema, cronRunTerminalEventSchema, attentionIntentSchema, attentionAuthorizedEventSchema, promptSubmittedEventSchema, toolListUpdatedReasonSchema, toolListUpdatedEventSchema, mcpServerStatusPayloadSchema, mcpServerStatusEventSchema, mediaDroppedEventSchema, agentEventSchema, eventSchema, VOLATILE_EVENT_TYPES, volatileEventTypeSet;
 var init_events$1 = __esmMin((() => {
 	init_zod$1();
 	init_display();
@@ -246905,6 +247008,11 @@ var init_events$1 = __esmMin((() => {
 		turnId: number$1(),
 		delta: string()
 	});
+	thinkingProgressEventSchema = object({
+		type: literal("thinking.progress"),
+		turnId: number$1(),
+		cumulativeTokens: number$1().int().nonnegative()
+	});
 	toolCallDeltaEventSchema = object({
 		type: literal("tool.call.delta"),
 		turnId: number$1(),
@@ -247130,6 +247238,7 @@ var init_events$1 = __esmMin((() => {
 		assistantDeltaEventSchema,
 		hookResultEventSchema,
 		thinkingDeltaEventSchema,
+		thinkingProgressEventSchema,
 		toolCallDeltaEventSchema,
 		toolCallStartedEventSchema,
 		toolProgressEventSchema,
@@ -247165,6 +247274,7 @@ var init_events$1 = __esmMin((() => {
 	VOLATILE_EVENT_TYPES = [
 		"assistant.delta",
 		"thinking.delta",
+		"thinking.progress",
 		"tool.call.delta",
 		"tool.progress",
 		"compaction.progress",
@@ -261915,13 +262025,11 @@ function appendReminder(result, reminderText) {
 		output: newOutput
 	};
 }
-function forceStopResult(result, reminderText) {
-	return {
-		...appendReminder(result, reminderText),
-		stopTurn: true
-	};
-}
-var REMINDER_TEXT_1, REMINDER_TEXT_3, REPEAT_REMINDER_1_START, REPEAT_REMINDER_2_START, REPEAT_REMINDER_3_START, REPEAT_FORCE_STOP_STREAK, DEDUP_PLACEHOLDER_RESULT, ToolCallDeduplicator;
+var loopPolicy = createRequire(import.meta.url)("./bin/tool-call-loop-policy.cjs");
+var FORCE_ANSWER_RESULT_STREAK = loopPolicy.FORCE_ANSWER_RESULT_STREAK;
+var createToolCallLoopKey = loopPolicy.createToolCallLoopKey;
+var hashToolResult = loopPolicy.hashToolResult;
+var REMINDER_TEXT_1, REMINDER_TEXT_3, REPEAT_REMINDER_1_START, REPEAT_REMINDER_2_START, REPEAT_REMINDER_3_START, DEDUP_PLACEHOLDER_RESULT, ToolCallDeduplicator;
 var init_tool_dedup = __esmMin((() => {
 	init_canonical_args();
 	REMINDER_TEXT_1 = "\n\n<system-reminder>\nYou are repeating the exact same tool call with identical parameters. Please carefully analyze the previous result. If the task is not yet complete, try a different method or parameters instead of repeating the same call.\n</system-reminder>";
@@ -261929,7 +262037,6 @@ var init_tool_dedup = __esmMin((() => {
 	REPEAT_REMINDER_1_START = 3;
 	REPEAT_REMINDER_2_START = 5;
 	REPEAT_REMINDER_3_START = 8;
-	REPEAT_FORCE_STOP_STREAK = 12;
 	DEDUP_PLACEHOLDER_RESULT = { output: "" };
 	ToolCallDeduplicator = class {
 		stepDeferreds = /* @__PURE__ */ new Map();
@@ -261945,8 +262052,14 @@ var init_tool_dedup = __esmMin((() => {
 		* during finalize.
 		*/
 		callKeyByCallId = /* @__PURE__ */ new Map();
+		/** The tolerant key is used only for cross-step loop detection. */
+		callLoopKeyByCallId = /* @__PURE__ */ new Map();
 		consecutiveKey = null;
 		consecutiveCount = 0;
+		lastResultLoopKey = null;
+		lastResultHash = null;
+		resultStreakCount = 0;
+		forceAnswerOnly = false;
 		telemetry;
 		constructor(options) {
 			this.telemetry = options?.telemetry;
@@ -261961,6 +262074,7 @@ var init_tool_dedup = __esmMin((() => {
 			this.originalCallIndex.clear();
 			this.syntheticCallIds.clear();
 			this.callKeyByCallId.clear();
+			this.callLoopKeyByCallId.clear();
 		}
 		endStep() {
 			for (const key of this.stepCalls) if (key === this.consecutiveKey) this.consecutiveCount += 1;
@@ -261969,6 +262083,9 @@ var init_tool_dedup = __esmMin((() => {
 				this.consecutiveCount = 1;
 			}
 		}
+		shouldForceAnswerOnly() {
+			return this.forceAnswerOnly;
+		}
 		/**
 		* Called from `prepareToolExecution`. If this `(toolName, args)` was already
 		* seen in the current step, returns a placeholder result so the loop can
@@ -261981,9 +262098,11 @@ var init_tool_dedup = __esmMin((() => {
 		*/
 		checkSameStep(toolCallId, toolName, args) {
 			const key = makeKey(toolName, args);
+			const loopKey = createToolCallLoopKey(toolName, args);
 			const index = this.stepCalls.length;
-			this.stepCalls.push(key);
+			this.stepCalls.push(loopKey);
 			this.callKeyByCallId.set(toolCallId, key);
+			this.callLoopKeyByCallId.set(toolCallId, loopKey);
 			if (this.stepDeferreds.get(key) !== void 0) {
 				this.syntheticCallIds.add(toolCallId);
 				return DEDUP_PLACEHOLDER_RESULT;
@@ -262004,6 +262123,8 @@ var init_tool_dedup = __esmMin((() => {
 			const key = this.callKeyByCallId.get(toolCallId);
 			if (key === void 0) return result;
 			this.callKeyByCallId.delete(toolCallId);
+			const loopKey = this.callLoopKeyByCallId.get(toolCallId);
+			this.callLoopKeyByCallId.delete(toolCallId);
 			if (this.syntheticCallIds.delete(toolCallId)) {
 				const deferred = this.stepDeferreds.get(key);
 				if (deferred === void 0) return result;
@@ -262024,9 +262145,15 @@ var init_tool_dedup = __esmMin((() => {
 			}
 			let finalResult = result;
 			let action = "none";
-			if (streak >= REPEAT_FORCE_STOP_STREAK) {
-				finalResult = forceStopResult(result, REMINDER_TEXT_3);
-				action = "stop";
+			const resultHash = hashToolResult(result);
+			const resultRepeatCount = this.lastResultLoopKey === loopKey && this.lastResultHash === resultHash ? this.resultStreakCount + 1 : 1;
+			this.lastResultLoopKey = loopKey;
+			this.lastResultHash = resultHash;
+			this.resultStreakCount = resultRepeatCount;
+			if (resultRepeatCount >= FORCE_ANSWER_RESULT_STREAK) {
+				finalResult = appendReminder(result, REMINDER_TEXT_3);
+				this.forceAnswerOnly = true;
+				action = "force_answer";
 			} else if (streak >= REPEAT_REMINDER_3_START) {
 				finalResult = appendReminder(result, REMINDER_TEXT_3);
 				action = "r3";
@@ -262037,9 +262164,10 @@ var init_tool_dedup = __esmMin((() => {
 				finalResult = appendReminder(result, REMINDER_TEXT_1);
 				action = "r1";
 			}
-			if (streak >= 2) this.telemetry?.track("tool_call_repeat", {
+			if (streak >= 2 || resultRepeatCount >= 2) this.telemetry?.track("tool_call_repeat", {
 				tool_name: toolName,
 				repeat_count: streak,
+				result_repeat_count: resultRepeatCount,
 				action
 			});
 			this.stepDeferreds.get(key)?.resolve(finalResult);
@@ -262911,6 +263039,11 @@ function mapLoopEvent(event, turnId) {
 			turnId,
 			delta: event.delta
 		};
+		case "thinking.progress": return {
+			type: "thinking.progress",
+			turnId,
+			cumulativeTokens: event.cumulativeTokens
+		};
 		case "tool.call.delta": return {
 			type: "tool.call.delta",
 			turnId,
@@ -263066,7 +263199,7 @@ function durablePromptOrigin(origin) {
 	void externalReportSources;
 	return durableOrigin;
 }
-var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, assessTodoListBounds, assessTodoMaintenanceUpdate, enforceSingleTodoWritePerStep, todoRefreshWorkCallLimit, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, applyMnemoAgentToToolArgs, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, assessTodoListBounds, assessTodoMaintenanceUpdate, enforceSingleTodoWritePerStep, todoRefreshWorkCallLimit, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -263080,6 +263213,7 @@ var init_turn = __esmMin((() => {
 	init_hooks();
 	init_canonical_args();
 	init_tool_dedup();
+	({ applyMnemoAgentToToolArgs } = createRequire(import.meta.url)("./bin/mnemo-tool-agent-policy.cjs"));
 	init_tool_result_budget();
 	init_user_message_offload();
 	init_assistant_message_offload();
@@ -263420,6 +263554,7 @@ var init_turn = __esmMin((() => {
 				origin: durablePromptOrigin(origin)
 			});
 			this.bufferSteer(input, origin, this.currentId);
+			active.interruptActiveStep?.();
 			return {
 				turnId: this.currentId,
 				duplicate: false
@@ -263453,7 +263588,8 @@ var init_turn = __esmMin((() => {
 				controller,
 				promise,
 				firstRequest,
-				acceptingSteers: false
+				acceptingSteers: false,
+				interruptActiveStep: void 0
 			};
 			firstRequest.catch(() => void 0);
 			promise.then(firstRequest.reject, firstRequest.reject);
@@ -263584,6 +263720,11 @@ var init_turn = __esmMin((() => {
 			if (active === null || active === "resuming" || this.currentId !== turnId) return;
 			active.acceptingSteers = accepting;
 		}
+		setActiveStepInterrupter(turnId, interrupter) {
+			const active = this.activeTurn;
+			if (active === null || active === "resuming" || this.currentId !== turnId) return;
+			active.interruptActiveStep = interrupter;
+		}
 		discardUnconsumedActiveSteers(turnId) {
 			const before = this.steerBuffer.length;
 			this.steerBuffer = this.steerBuffer.filter((steer) => steer.targetTurnId !== turnId);
@@ -263937,7 +264078,7 @@ var init_turn = __esmMin((() => {
 			const turnText = blunExtractText(input);
 			const turnNeedsTools = blunTurnNeedsTools(input, origin);
 			const turnHasAttachment = blunTurnHasAttachment(input);
-			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind);
+			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind, this.agent.config.thinkingEffort);
 			const fastConversation = turnThinkingEffort === "off" || turnThinkingEffort === "low";
 			const pendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
 			const requiredToolNames = mediaToolNamesForTurnText(turnText);
@@ -263947,6 +264088,7 @@ var init_turn = __esmMin((() => {
 			let currentStepHadTool = false;
 			let currentStepHadFailure = false;
 			let currentLoopStep = 0;
+			let activeStepInterruptController;
 			while (true) {
 				signal.throwIfAborted();
 				const model = this.agent.config.model;
@@ -263999,6 +264141,15 @@ var init_turn = __esmMin((() => {
 						maxRetryAttempts: loopControl?.maxRetriesPerStep,
 						checkpointBeforeToolExecution: () => this.agent.records.flush(),
 						checkpointBeforeRetryWait: () => this.agent.records.flush(),
+						beginInterruptibleRequest: () => {
+							activeStepInterruptController = new AbortController();
+							this.setActiveStepInterrupter(turnId, () => activeStepInterruptController?.abort(createActiveSteerInterrupt()));
+							return AbortSignal.any([signal, activeStepInterruptController.signal]);
+						},
+						endInterruptibleRequest: () => {
+							this.setActiveStepInterrupter(turnId, void 0);
+							activeStepInterruptController = void 0;
+						},
 						recordStepUsage: async (usage) => {
 							try {
 								stopForGoalBudget = (await this.agent.goal.recordTokenUsage(grandTotal(usage)))?.budget.overBudget === true;
@@ -264017,6 +264168,10 @@ var init_turn = __esmMin((() => {
 								await this.agent.injection.inject();
 								stepSignal.throwIfAborted();
 								deduper.beginStep();
+								if (deduper.shouldForceAnswerOnly()) {
+									this.agent.log.warn("tool loop stopped; forcing text answer", { stepNumber });
+									return { tools: [] };
+								}
 								const workStepThinkingEffort = selectThinkingEffortForWorkStep(stepNumber, previousStepToolOutcome);
 								currentStepHadTool = false;
 								currentStepHadFailure = false;
@@ -264054,13 +264209,26 @@ var init_turn = __esmMin((() => {
 								}
 							if (pendingSteers.some((steer) => directMessageAllowsWorkContinuation(blunExtractText(steer.input)))) directSteerContinuationPending = true;
 							const steerEfforts = pendingSteers.map((steer) => blunTurnHasAttachment(steer.input) ? void 0 : selectThinkingEffortForBufferedSteer(blunExtractText(blunThinkingIntentInput(steer.input)), steer.origin.kind));
-								if (steerEfforts.some((effort) => effort === void 0)) return;
 								const steerInput = pendingSteers.flatMap((steer) => [...steer.input]);
-								const steerThinkingEffort = "low";
-								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
 								const steerText = blunExtractText(steerInput);
 								const steerRequiredToolNames = mediaToolNamesForTurnText(steerText);
 								for (const name of rankedToolNamesForTurnText(eligibleTools, steerText)) steerRequiredToolNames.add(name);
+								if (steerEfforts.some((effort) => effort === void 0)) {
+									const prioritizedSelection = blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, steerRequiredToolNames);
+									this.agent.context.appendSystemReminder(ACTIVE_STEER_PRIORITY_REMINDER, {
+										kind: "injection",
+										variant: "active_steer_priority"
+									});
+									this.agent.log.info("steer request tools", {
+										requestPurpose: "active_steer_priority",
+										pendingSteerCount: pendingSteers.length,
+										selectedToolCount: prioritizedSelection.tools.length,
+										deferredToolCount: prioritizedSelection.deferredToolCount
+									});
+									return { tools: prioritizedSelection.tools };
+								}
+								const steerThinkingEffort = "low";
+								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
 								const steerNeedsActionTools = steerRequiredToolNames.size > 0;
 								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, blunPendingMediaSystemPrompt(steerNeedsActionTools ? this.agent.effectiveSystemPrompt : this.agent.fastConversationSystemPrompt, steerPendingMediaJobIds));
 								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput, steerPendingMediaJobIds, steerRequiredToolNames)];
@@ -264155,8 +264323,10 @@ var init_turn = __esmMin((() => {
 								if (goalTodoPolicy !== void 0) return goalTodoPolicy;
 								const ideaPolicy = enforceIdeaToolPolicy(this.agent, ctx);
 								if (ideaPolicy !== void 0) return ideaPolicy;
-								const cached = deduper.checkSameStep(ctx.toolCall.id, ctx.toolCall.name, ctx.args);
-								if (cached !== null) return { syntheticResult: cached };
+								const effectiveArgs = applyMnemoAgentToToolArgs(ctx.toolCall.name, ctx.args);
+								const cached = deduper.checkSameStep(ctx.toolCall.id, ctx.toolCall.name, effectiveArgs);
+								if (cached !== null) return { updatedArgs: effectiveArgs, syntheticResult: cached };
+								if (effectiveArgs !== ctx.args) return { updatedArgs: effectiveArgs };
 							},
 							authorizeToolExecution: async (ctx) => {
 								try {
@@ -264263,7 +264433,7 @@ var init_turn = __esmMin((() => {
 				emitLiveEvent: (event) => {
 					this.noteFirstRequestEvent(event);
 					this.trackLoopTelemetry(event, turnId);
-					if (event.type === "thinking.delta" && event.delta.trim().length === 0) {
+					if (event.type === "thinking.progress" || event.type === "thinking.delta" && event.delta.trim().length === 0) {
 						const requestState = this.stepRequestStateByTurn.get(turnId);
 						this.agent.records.logRecord({
 							type: "thinking.heartbeat",
@@ -264272,7 +264442,8 @@ var init_turn = __esmMin((() => {
 							attempt: requestState?.attempt ?? 1,
 							max_attempts: requestState?.maxAttempts,
 							completion_budget: requestState?.completionBudget,
-							thinking_effort: requestState?.thinkingEffort
+							thinking_effort: requestState?.thinkingEffort,
+							hidden_thinking_tokens: event.type === "thinking.progress" ? event.cumulativeTokens : void 0
 						});
 					}
 					if (event.type === "step.retrying" && event.completionBudgetBefore !== void 0 && event.completionBudgetAfter !== void 0) this.agent.records.logRecord({
@@ -264295,6 +264466,7 @@ var init_turn = __esmMin((() => {
 				case "tool.call":
 				case "text.delta":
 				case "thinking.delta":
+				case "thinking.progress":
 				case "tool.call.delta": {
 					const active = this.activeTurn;
 					if (active === null || active === "resuming") return;
@@ -342961,6 +343133,241 @@ function definedCatalogEntries(copy) {
 	return Object.entries(copy).filter((entry) => entry[1] !== void 0);
 }
 //#endregion
+//#region src/tui/i18n/gated-565-catalog-additions.ts
+registerUiCatalogFragment({
+	"es": {
+		"media.activity.chain": "Cadena de producción",
+		"media.activity.collapse": "ctrl+o: contraer",
+		"media.activity.jobs": "{count} trabajos multimedia activos",
+		"media.activity.showJobs": "ctrl+o: mostrar trabajos",
+		"media.detail.audio": "{seconds}s de audio",
+		"media.detail.duration": "Duración {duration}",
+		"media.detail.open": "Abrir",
+		"media.detail.playSample": "Reproducir muestra",
+		"media.detail.preview": "Vista previa",
+		"media.detail.queue": "Posición {position}",
+		"media.detail.remaining": "quedan aprox. {duration}",
+		"media.detail.resolution": "{width}x{height}",
+		"media.detail.segment": "Segmento {current} de {total}",
+		"media.detail.waveform": "Forma de onda",
+		"media.kind.dubbing": "Doblaje",
+		"media.kind.image": "Imagen",
+		"media.kind.image-analysis": "Análisis de imagen",
+		"media.kind.lipsync": "Sincronización labial",
+		"media.kind.media": "Multimedia",
+		"media.kind.video": "Vídeo",
+		"media.kind.video-analysis": "Análisis de vídeo",
+		"media.kind.voice": "Voz",
+		"media.phase.accepted": "En cola",
+		"media.phase.analyzing": "Analizando",
+		"media.phase.audio-analysis": "Análisis de audio",
+		"media.phase.checking": "Comprobando estado",
+		"media.phase.exporting": "Exportando",
+		"media.phase.face-detection": "Detección de rostros",
+		"media.phase.face-tracking": "Seguimiento de rostros",
+		"media.phase.generating": "Generando",
+		"media.phase.in-progress": "Procesando",
+		"media.phase.lip-sync-running": "Sincronización labial en curso",
+		"media.phase.pending": "En cola",
+		"media.phase.processing": "Procesando",
+		"media.phase.queued": "En cola",
+		"media.phase.rendering": "Renderizando",
+		"media.phase.running": "Procesando",
+		"media.phase.saving": "Guardando",
+		"media.phase.submitting": "Enviando solicitud",
+		"media.phase.uploading": "Enviando solicitud",
+		"media.phase.upscaling": "Aumentando la resolución",
+		"thinking.activity.coordinates": "{name} coordinando",
+		"thinking.activity.plans": "{name} planificando",
+		"thinking.activity.reads": "{name} leyendo",
+		"thinking.activity.runs": "{name} ejecutando",
+		"thinking.activity.writes": "{name} escribiendo",
+		"thinking.attempt": "intento {attempt}/{maxAttempts}",
+		"thinking.budget": "presupuesto {budget}",
+		"thinking.effort": "esfuerzo {effort}",
+		"thinking.emptyRetry": "Respuesta vacía del modelo; {hint} · presupuesto {before} → {after}",
+		"thinking.finished": "listo {time}",
+		"thinking.heartbeat": "señal del pensamiento oculto hace {seconds}s",
+		"thinking.hiddenTokens": "pensando {count}",
+		"thinking.step": "paso {step}",
+		"thinking.worked": "Trabajó {elapsed}"
+	},
+	"fr": {
+		"media.activity.chain": "Chaîne de production",
+		"media.activity.collapse": "ctrl+o : replier",
+		"media.activity.jobs": "{count} tâches média actives",
+		"media.activity.showJobs": "ctrl+o : afficher les tâches",
+		"media.detail.audio": "{seconds} s d'audio",
+		"media.detail.duration": "Durée {duration}",
+		"media.detail.open": "Ouvrir",
+		"media.detail.playSample": "Écouter l'extrait",
+		"media.detail.preview": "Aperçu",
+		"media.detail.queue": "Rang {position}",
+		"media.detail.remaining": "encore environ {duration}",
+		"media.detail.resolution": "{width}x{height}",
+		"media.detail.segment": "Segment {current} sur {total}",
+		"media.detail.waveform": "Forme d'onde",
+		"media.kind.dubbing": "Doublage",
+		"media.kind.image": "Image",
+		"media.kind.image-analysis": "Analyse d'image",
+		"media.kind.lipsync": "Synchronisation labiale",
+		"media.kind.media": "Médias",
+		"media.kind.video": "Vidéo",
+		"media.kind.video-analysis": "Analyse vidéo",
+		"media.kind.voice": "Voix",
+		"media.phase.accepted": "En file d'attente",
+		"media.phase.analyzing": "Analyse en cours",
+		"media.phase.audio-analysis": "Analyse audio",
+		"media.phase.checking": "Vérification de l'état",
+		"media.phase.exporting": "Export en cours",
+		"media.phase.face-detection": "Détection des visages",
+		"media.phase.face-tracking": "Suivi des visages",
+		"media.phase.generating": "Génération en cours",
+		"media.phase.in-progress": "Traitement en cours",
+		"media.phase.lip-sync-running": "Synchronisation labiale en cours",
+		"media.phase.pending": "En file d'attente",
+		"media.phase.processing": "Traitement en cours",
+		"media.phase.queued": "En file d'attente",
+		"media.phase.rendering": "Rendu en cours",
+		"media.phase.running": "Traitement en cours",
+		"media.phase.saving": "Enregistrement en cours",
+		"media.phase.submitting": "Envoi de la requête",
+		"media.phase.uploading": "Envoi de la requête",
+		"media.phase.upscaling": "Agrandissement en cours",
+		"thinking.activity.coordinates": "{name} coordonne",
+		"thinking.activity.plans": "{name} planifie",
+		"thinking.activity.reads": "{name} lit",
+		"thinking.activity.runs": "{name} exécute",
+		"thinking.activity.writes": "{name} écrit",
+		"thinking.attempt": "tentative {attempt}/{maxAttempts}",
+		"thinking.budget": "budget {budget}",
+		"thinking.effort": "niveau d'effort {effort}",
+		"thinking.emptyRetry": "Réponse vide du modèle ; {hint} · budget {before} → {after}",
+		"thinking.finished": "terminé {time}",
+		"thinking.heartbeat": "signe de vie de la réflexion il y a {seconds} s",
+		"thinking.hiddenTokens": "réflexion {count}",
+		"thinking.step": "étape {step}",
+		"thinking.worked": "A travaillé {elapsed}"
+	},
+	"sv": {
+		"media.activity.chain": "Produktionskedja",
+		"media.activity.collapse": "ctrl+o: fäll ihop",
+		"media.activity.jobs": "{count} aktiva mediejobb",
+		"media.activity.showJobs": "ctrl+o: visa jobb",
+		"media.detail.audio": "{seconds}s ljud",
+		"media.detail.duration": "Längd {duration}",
+		"media.detail.open": "Öppna",
+		"media.detail.playSample": "Spela upp exempel",
+		"media.detail.preview": "Förhandsvisning",
+		"media.detail.queue": "Plats {position}",
+		"media.detail.remaining": "cirka {duration} kvar",
+		"media.detail.resolution": "{width}x{height}",
+		"media.detail.segment": "Segment {current} av {total}",
+		"media.detail.waveform": "Vågform",
+		"media.kind.dubbing": "Dubbning",
+		"media.kind.image": "Bild",
+		"media.kind.image-analysis": "Bildanalys",
+		"media.kind.lipsync": "Läppsynk",
+		"media.kind.media": "Media",
+		"media.kind.video": "Video",
+		"media.kind.video-analysis": "Videoanalys",
+		"media.kind.voice": "Röst",
+		"media.phase.accepted": "I kö",
+		"media.phase.analyzing": "Analyserar",
+		"media.phase.audio-analysis": "Ljudanalys",
+		"media.phase.checking": "Kontrollerar status",
+		"media.phase.exporting": "Exporterar",
+		"media.phase.face-detection": "Ansiktsdetektering",
+		"media.phase.face-tracking": "Ansiktsspårning",
+		"media.phase.generating": "Genererar",
+		"media.phase.in-progress": "Bearbetar",
+		"media.phase.lip-sync-running": "Läppsynk pågår",
+		"media.phase.pending": "I kö",
+		"media.phase.processing": "Bearbetar",
+		"media.phase.queued": "I kö",
+		"media.phase.rendering": "Renderar",
+		"media.phase.running": "Bearbetar",
+		"media.phase.saving": "Sparar",
+		"media.phase.submitting": "Skickar begäran",
+		"media.phase.uploading": "Skickar begäran",
+		"media.phase.upscaling": "Skalar upp",
+		"thinking.activity.coordinates": "{name} samordnar",
+		"thinking.activity.plans": "{name} planerar",
+		"thinking.activity.reads": "{name} läser",
+		"thinking.activity.runs": "{name} kör",
+		"thinking.activity.writes": "{name} skriver",
+		"thinking.attempt": "försök {attempt}/{maxAttempts}",
+		"thinking.budget": "budget {budget}",
+		"thinking.effort": "insats {effort}",
+		"thinking.emptyRetry": "Tomt svar från modellen; {hint} · budget {before} → {after}",
+		"thinking.finished": "klar {time}",
+		"thinking.heartbeat": "livstecken från dold tanke för {seconds}s sedan",
+		"thinking.hiddenTokens": "tänker {count}",
+		"thinking.step": "steg {step}",
+		"thinking.worked": "Arbetade {elapsed}"
+	},
+	"cs": {
+		"approval.choice.editArguments": "Upravit argumenty (JSON)",
+		"approval.hint.editArguments": "Zadejte kompletní náhradní objekt JSON · ↵ odeslat.",
+		"approval.transcript.edited": "Argumenty upraveny",
+		"media.activity.chain": "Produkční řetězec",
+		"media.activity.collapse": "ctrl+o: sbalit",
+		"media.activity.jobs": "Aktivní mediální úlohy: {count}",
+		"media.activity.showJobs": "ctrl+o: zobrazit úlohy",
+		"media.detail.audio": "{seconds}s zvuku",
+		"media.detail.duration": "Délka {duration}",
+		"media.detail.open": "Otevřít",
+		"media.detail.playSample": "Přehrát ukázku",
+		"media.detail.preview": "Náhled",
+		"media.detail.queue": "Pozice {position}",
+		"media.detail.remaining": "zbývá přibližně {duration}",
+		"media.detail.resolution": "{width}x{height}",
+		"media.detail.segment": "Segment {current} z {total}",
+		"media.detail.waveform": "Vlnový průběh",
+		"media.kind.dubbing": "Dabing",
+		"media.kind.image": "Obrázek",
+		"media.kind.image-analysis": "Analýza obrázku",
+		"media.kind.lipsync": "Synchronizace rtů",
+		"media.kind.media": "Média",
+		"media.kind.video": "Video",
+		"media.kind.video-analysis": "Analýza videa",
+		"media.kind.voice": "Hlas",
+		"media.phase.accepted": "Ve frontě",
+		"media.phase.analyzing": "Analyzuje se",
+		"media.phase.audio-analysis": "Analýza zvuku",
+		"media.phase.checking": "Kontrola stavu",
+		"media.phase.exporting": "Exportuje se",
+		"media.phase.face-detection": "Detekce obličejů",
+		"media.phase.face-tracking": "Sledování obličejů",
+		"media.phase.generating": "Generuje se",
+		"media.phase.in-progress": "Zpracovává se",
+		"media.phase.lip-sync-running": "Probíhá synchronizace rtů",
+		"media.phase.pending": "Ve frontě",
+		"media.phase.processing": "Zpracovává se",
+		"media.phase.queued": "Ve frontě",
+		"media.phase.rendering": "Renderuje se",
+		"media.phase.running": "Zpracovává se",
+		"media.phase.saving": "Ukládá se",
+		"media.phase.submitting": "Odesílá se požadavek",
+		"media.phase.uploading": "Odesílá se požadavek",
+		"media.phase.upscaling": "Zvyšuje se rozlišení",
+		"thinking.activity.coordinates": "{name} koordinuje",
+		"thinking.activity.plans": "{name} plánuje",
+		"thinking.activity.reads": "{name} čte",
+		"thinking.activity.runs": "{name} spouští",
+		"thinking.activity.writes": "{name} píše",
+		"thinking.attempt": "pokus {attempt}/{maxAttempts}",
+		"thinking.budget": "rozpočet {budget}",
+		"thinking.effort": "úsilí {effort}",
+		"thinking.emptyRetry": "Prázdná odpověď modelu; {hint} · rozpočet {before} → {after}",
+		"thinking.finished": "hotovo {time}",
+		"thinking.heartbeat": "signál skrytého uvažování před {seconds}s",
+		"thinking.hiddenTokens": "uvažuje {count}",
+		"thinking.step": "krok {step}",
+		"thinking.worked": "Pracováno {elapsed}"
+	}
+});
+//#endregion
 //#region src/tui/commands/auth.copy.ts
 registerUiCatalogFragment({
 	en: {
@@ -493799,12 +494206,18 @@ var PluginCommandComponent = class extends Container {
 registerUiCatalogFragment({
 	en: {
 		"thinking.label": "{name} thinking",
+		"thinking.activity.reads": "{name} reading",
+		"thinking.activity.writes": "{name} writing",
+		"thinking.activity.runs": "{name} running",
+		"thinking.activity.coordinates": "{name} coordinating",
+		"thinking.activity.plans": "{name} planning",
 		"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.hiddenTokens": "thinking {count}",
 		"thinking.worked": "Worked {elapsed}",
 		"thinking.finished": "done {time}",
 		"thinking.emptyRetry": "Empty model response; {hint} · budget {before} → {after}",
@@ -493813,12 +494226,18 @@ registerUiCatalogFragment({
 	},
 	de: {
 		"thinking.label": "{name} denkt",
+		"thinking.activity.reads": "{name} liest",
+		"thinking.activity.writes": "{name} schreibt",
+		"thinking.activity.runs": "{name} führt aus",
+		"thinking.activity.coordinates": "{name} koordiniert",
+		"thinking.activity.plans": "{name} plant",
 		"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.hiddenTokens": "denkt {count}",
 		"thinking.worked": "Gearbeitet {elapsed}",
 		"thinking.finished": "fertig {time}",
 		"thinking.emptyRetry": "Leere Modellantwort; {hint} · Budget {before} → {after}",
@@ -493862,6 +494281,7 @@ function formatLiveStartedAt(startedAtMs) {
 	const minute = String(startedAt.getMinutes()).padStart(2, "0");
 	return `${day}.${month}. · ${hour}:${minute}`;
 }
+var { ThinkingActivityRotator, inferThinkingActivityGroup } = createRequire(import.meta.url)("./bin/thinking-activity-status-policy.cjs");
 var ThinkingComponent = class {
 	text;
 	showMarker;
@@ -493875,13 +494295,17 @@ var ThinkingComponent = class {
 	thinkElapsedMs = 0;
 	thinkAborted = false;
 	estimatedOutputTokens = 0;
+	totalTokenCount = 0;
 	step;
 	thinkingEffort;
 	attempt = 1;
 	maxAttempts = 1;
 	completionBudget;
 	lastHeartbeatAtMs;
+	hiddenThinkingTokens = 0;
 	activeToolName;
+	activityGroup = "Thinking";
+	activityRotator = new ThinkingActivityRotator();
 	finishedAtMs;
 	textComponent;
 	renderCache;
@@ -493916,21 +494340,24 @@ var ThinkingComponent = class {
 	}
 	setLiveMetrics(metrics) {
 		if (this.mode === "live" && !this.thinkAborted && metrics.startedAtMs !== void 0) this.thinkStartMs = metrics.startedAtMs;
-		const before = JSON.stringify([this.estimatedOutputTokens, this.step, this.thinkingEffort, this.attempt, this.maxAttempts, this.completionBudget, this.lastHeartbeatAtMs, this.activeToolName]);
+		const before = JSON.stringify([this.estimatedOutputTokens, this.totalTokenCount, this.hiddenThinkingTokens, this.step, this.thinkingEffort, this.attempt, this.maxAttempts, this.completionBudget, this.lastHeartbeatAtMs, this.activeToolName, this.activityGroup]);
 		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]);
+		const after = JSON.stringify([this.estimatedOutputTokens, this.totalTokenCount, this.hiddenThinkingTokens, this.step, this.thinkingEffort, this.attempt, this.maxAttempts, this.completionBudget, this.lastHeartbeatAtMs, this.activeToolName, this.activityGroup]);
 		if (before === after) return;
 		this.markRenderDirty();
 	}
 	applyLiveMetrics(metrics) {
+		this.totalTokenCount = metrics.totalTokenCount ?? 0;
 		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.hiddenThinkingTokens = metrics.hiddenThinkingTokens ?? 0;
 		this.activeToolName = metrics.activeToolName;
+		this.activityGroup = metrics.activityGroup ?? "Thinking";
 	}
 	styled(text) {
 		return currentTheme.italicFg("textDim", text);
@@ -493964,26 +494391,29 @@ var ThinkingComponent = class {
 			const startedAt = formatLiveStartedAt(this.thinkStartMs ?? Date.now());
 			const roundedTokenCount = Math.max(0, Math.round(this.estimatedOutputTokens));
 			const tokenCount = formatLiveTokenCount(roundedTokenCount);
-			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 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)) }));
+			const abortMark = this.thinkAborted ? " (aborted)" : "";
+			const thinkingLabel = this.activityRotator.resolve(this.activityGroup, Date.now());
+			const details = [`↓ ~${tokenCount} ${roundedTokenCount === 1 ? "token" : "tokens"}`];
+			if (this.hiddenThinkingTokens > 0) details.push(`thinking ${formatLiveTokenCount(this.hiddenThinkingTokens)}`);
+			if (this.totalTokenCount > 0) details.push(`total ${formatLiveTokenCount(this.totalTokenCount)}`);
+			if (this.thinkingEffort !== void 0) details.push(`thinking with ${this.thinkingEffort} effort`);
+			if (this.step !== void 0) details.push(`step ${this.step}`);
+			if (this.attempt > 1 || this.maxAttempts > 1) details.push(`attempt ${this.attempt}/${this.maxAttempts}`);
+			if (this.completionBudget !== void 0) details.push(`budget ${this.completionBudget.toLocaleString(locale)}`);
+			if (this.lastHeartbeatAtMs !== void 0) details.push(`last hidden-thought tick ${Math.max(0, Math.floor((Date.now() - this.lastHeartbeatAtMs) / 1e3))}s ago`);
 			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 fullLabel = `${thinkingLabel}… (${elapsed} · ${details.join(" · ")} · ${startedAt})${abortMark}`;
+			const compactHiddenTokens = this.hiddenThinkingTokens > 0 ? ` · thinking ${formatLiveTokenCount(this.hiddenThinkingTokens)}` : "";
+			const compactTotalTokens = this.totalTokenCount > 0 ? ` · total ${formatLiveTokenCount(this.totalTokenCount)}` : "";
+			const compactEffort = this.thinkingEffort === void 0 ? "" : ` · ${this.thinkingEffort} effort`;
+			const compactLabel = `${thinkingLabel}… (${elapsed} · ↓ ${tokenCount} tokens${compactHiddenTokens}${compactTotalTokens}${compactEffort}${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 })}`;
+			const finalLabel = `Worked for ${formatLiveElapsed(this.formatElapsedSeconds())} · done ${finishedAt}`;
 			rendered = ["", currentTheme.fg("textDim", truncateToWidth(finalLabel, Math.max(1, width)))];
 		} else rendered = [""];
 		if (isRenderCacheEnabled()) this.renderCache = {
@@ -510557,6 +510987,9 @@ var SessionEventHandler = class {
 			case "thinking.delta":
 				this.handleThinkingDelta(event);
 				break;
+			case "thinking.progress":
+				this.handleThinkingProgress(event);
+				break;
 			case "tool.call.started":
 				this.handleToolCall(event);
 				break;
@@ -510724,7 +511157,10 @@ var SessionEventHandler = class {
 		this.clearModelRetryHint();
 		this.lastStepFinishReason = event.finishReason;
 		this.host.streamingUI.flushNow();
-		if (event.usage !== void 0) this.currentTurnTokenCount = (this.currentTurnTokenCount ?? 0) + totalTokenUsage(event.usage);
+		if (event.usage !== void 0) {
+			this.currentTurnTokenCount = (this.currentTurnTokenCount ?? 0) + totalTokenUsage(event.usage);
+			this.host.streamingUI.noteTurnTokenUsage(this.currentTurnTokenCount);
+		}
 		this.maybeShowDebugTiming(event);
 		if (event.providerFinishReason === "filtered") {
 			this.host.showNotice(uiText("sessionEvent.filter.title"), uiText("sessionEvent.filter.detail", { reason: event.rawFinishReason ?? "content_filter" }));
@@ -510814,8 +511250,17 @@ 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.trim().length === 0) {
+			streamingUI.noteThinkingHeartbeat();
+			this.turnWatchdog.recordProgress();
+			this.clearModelRetryHint();
+			this.host.patchLivePane({ mode: "idle" });
+			if (state.appState.streamingPhase !== "thinking") this.host.setAppState({
+				streamingPhase: "thinking",
+				streamingStartTime: Date.now()
+			});
+			return;
+		}
 		if (event.delta.length > 0) this.turnWatchdog.recordProgress();
 		if (event.delta.length > 0) this.clearModelRetryHint();
 		streamingUI.appendThinkingDelta(event.delta);
@@ -510826,9 +511271,20 @@ var SessionEventHandler = class {
 		});
 		streamingUI.scheduleFlush();
 	}
+	handleThinkingProgress(event) {
+		const { state, streamingUI } = this.host;
+		this.turnWatchdog.recordProgress();
+		this.clearModelRetryHint();
+		streamingUI.noteThinkingProgress(event.cumulativeTokens);
+		this.host.patchLivePane({ mode: "idle" });
+		if (state.appState.streamingPhase !== "thinking") this.host.setAppState({
+			streamingPhase: "thinking",
+			streamingStartTime: Date.now()
+		});
+	}
 	handleAssistantDelta(event) {
 		const { state, streamingUI } = this.host;
-		if (streamingUI.hasThinkingDraft()) streamingUI.flushThinkingToTranscript("idle");
+		if (streamingUI.hasThinkingDraft() || streamingUI.hasActiveThinkingComponent()) streamingUI.flushThinkingToTranscript("idle");
 		if (event.delta.trim().length > 0) {
 			this.turnWatchdog.recordProgress();
 			this.clearModelRetryHint();
@@ -510850,7 +511306,7 @@ var SessionEventHandler = class {
 	handleHookResult(event) {
 		if (!shouldDisplayHookResult(event)) return;
 		this.host.streamingUI.flushNow();
-		if (this.host.streamingUI.hasThinkingDraft()) this.host.streamingUI.flushThinkingToTranscript("idle");
+		if (this.host.streamingUI.hasThinkingDraft() || this.host.streamingUI.hasActiveThinkingComponent()) this.host.streamingUI.flushThinkingToTranscript("idle");
 		this.host.streamingUI.finalizeAssistantStream();
 		if (event.content.trim().length > 0) {
 			this.currentTurnHasAssistantText = true;
@@ -513860,6 +514316,8 @@ var StreamingUIController = class {
 	_liveTurnStartedAtMs = void 0;
 	_liveStepStartedAtMs = void 0;
 	_liveThinkingHeartbeatAtMs = void 0;
+	_liveHiddenThinkingTokens = 0;
+	_liveTurnTokenCount = 0;
 	_liveStepRequest = {};
 	_liveOutputTokens = new LiveOutputTokenCounter();
 	_countedToolCallIds = /* @__PURE__ */ new Set();
@@ -513895,6 +514353,7 @@ var StreamingUIController = class {
 		this.setStep(event.step);
 		this._liveStepStartedAtMs = Date.now();
 		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveHiddenThinkingTokens = 0;
 		this._liveOutputTokens.reset();
 		this._countedToolCallIds.clear();
 		this._liveStepRequest = {
@@ -513907,6 +514366,7 @@ var StreamingUIController = class {
 	noteStepRetry(event) {
 		this._liveStepStartedAtMs = Date.now();
 		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveHiddenThinkingTokens = 0;
 		this._liveStepRequest = {
 			...this._liveStepRequest,
 			attempt: event.nextAttempt,
@@ -513916,6 +514376,18 @@ var StreamingUIController = class {
 	}
 	noteThinkingHeartbeat() {
 		this._liveThinkingHeartbeatAtMs = Date.now();
+		this.onThinkingUpdate(this._thinkingDraft, true);
+	}
+	noteThinkingProgress(cumulativeTokens) {
+		if (!Number.isFinite(cumulativeTokens) || cumulativeTokens < 0) return;
+		this._liveThinkingHeartbeatAtMs = Date.now();
+		this._liveHiddenThinkingTokens = Math.max(this._liveHiddenThinkingTokens, Math.floor(cumulativeTokens));
+		this.onThinkingUpdate(this._thinkingDraft, true);
+	}
+	noteTurnTokenUsage(cumulativeTokens) {
+		if (!Number.isFinite(cumulativeTokens) || cumulativeTokens < 0) return;
+		this._liveTurnTokenCount = Math.max(this._liveTurnTokenCount, Math.floor(cumulativeTokens));
+		this.onThinkingUpdate(this._thinkingDraft, true);
 	}
 	setRemoteTurnActivity(activity) {
 		const previous = this._remoteTurnActivity;
@@ -513947,23 +514419,29 @@ var StreamingUIController = class {
 		this._liveTurnStartedAtMs = Date.now();
 		this._liveStepStartedAtMs = void 0;
 		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveHiddenThinkingTokens = 0;
+		this._liveTurnTokenCount = 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;
+		const activeTool = [...this._activeToolCalls.values()].at(-1) ?? [...this._streamingToolCallArguments.values()].at(-1);
+		const activeToolName = activeTool?.name;
 		return {
 			startedAtMs: this._liveStepStartedAtMs ?? this._liveTurnStartedAtMs,
 			estimatedOutputTokens: this._liveOutputTokens.estimatedOutputTokens(),
+			totalTokenCount: this._liveTurnTokenCount,
 			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
+			hiddenThinkingTokens: this._liveHiddenThinkingTokens,
+			activeToolName,
+			activityGroup: inferThinkingActivityGroup(activeTool, { retrying: (this._liveStepRequest.attempt ?? 1) > 1 })
 		};
 	}
 	recordLiveOutput(fragment) {
@@ -514006,6 +514484,7 @@ var StreamingUIController = class {
 		this._liveTurnStartedAtMs = void 0;
 		this._liveStepStartedAtMs = void 0;
 		this._liveThinkingHeartbeatAtMs = void 0;
+		this._liveHiddenThinkingTokens = 0;
 		this._liveStepRequest = {};
 		this._liveOutputTokens.reset();
 		this._countedToolCallIds.clear();
@@ -514463,8 +514942,8 @@ var StreamingUIController = class {
 		}
 		this._streamingBlock = null;
 	}
-	onThinkingUpdate(fullText) {
-		if (fullText.length === 0 && this._activeThinkingComponent === void 0) return;
+	onThinkingUpdate(fullText, forceLiveStatus = false) {
+		if (fullText.length === 0 && this._activeThinkingComponent === void 0 && !forceLiveStatus) return;
 		const { state } = this.host;
 		if (this._activeThinkingComponent === void 0) {
 			this._pendingAgentGroup = null;
@@ -514476,12 +514955,14 @@ var StreamingUIController = class {
 			this._activeThinkingComponent.setText(fullText);
 			this._activeThinkingComponent.setLiveMetrics(this.getLiveActivityMetrics());
 		}
+		this.host.updateActivityPane();
 		state.ui.requestRender();
 	}
 	onThinkingEnd() {
 		if (this._activeThinkingComponent === void 0) return;
 		this._activeThinkingComponent.finalize();
 		this._activeThinkingComponent = void 0;
+		this.host.updateActivityPane();
 		this.host.state.ui.requestRender();
 		this.host.mergeCurrentTurnSteps();
 	}
@@ -519229,6 +519710,7 @@ var BlunTUI = class {
 	async start() {
 		this.registerSignalHandlers();
 		this.startupWorkspaceSelectionPending = !(this.options.startup.sessionFlag !== void 0 || this.options.startup.continueLast);
+		this.startTelegramChannel();
 		try {
 			const shouldReplayHistory = await this.initMainTui();
 			this.startEventLoop();
@@ -522091,6 +522573,7 @@ var BlunTUI = class {
 		this.state.ui.requestRender();
 	}
 	resolveActivityPaneMode() {
+		if (this.streamingUI.hasActiveThinkingComponent()) return "hidden";
 		if (this.state.activeDialog === "session-picker") return "hidden";
 		if (this.state.livePane.pendingApproval !== null) return "hidden";
 		if (this.state.appState.isCompacting) return "hidden";
@@ -522760,6 +523243,7 @@ async function runShell(opts, version) {
 		});
 		try {
 			log.error("uncaughtException, restoring terminal and exiting", { error: String(error) });
+			getRootInternal().flushSync();
 		} catch {}
 		emergencyExit(1);
 	};
@@ -522771,6 +523255,7 @@ async function runShell(opts, version) {
 		});
 		try {
 			log.error("unhandledRejection, restoring terminal and exiting", { reason: String(reason) });
+			getRootInternal().flushSync();
 		} catch {}
 		emergencyExit(1);
 	};
@@ -523044,6 +523529,7 @@ function installNativeModuleHook() {
 	installed = true;
 	const moduleBuiltin = nodeRequire("node:module");
 	const originalLoad = moduleBuiltin._load;
+	const originalResolveFilename = moduleBuiltin._resolveFilename;
 	if (originalLoad === void 0) return;
 	moduleBuiltin._load = function loadWithNativeAssets(request, parent, isMain) {
 		if (request === "node-pty") {
@@ -523060,6 +523546,13 @@ function installNativeModuleHook() {
 				}
 			}
 		}
+		if (typeof request === "string" && request.toLowerCase().endsWith(".node") && typeof originalResolveFilename === "function") {
+			try {
+				const resolvedRequest = originalResolveFilename.call(moduleBuiltin, request, parent, isMain);
+				const cachedRequest = resolveNativeRuntimePath(resolvedRequest, { packageRoot: __dirname });
+				if (cachedRequest !== resolvedRequest) return originalLoad.call(this, cachedRequest, parent, isMain);
+			} catch {}
+		}
 		return originalLoad.call(this, request, parent, isMain);
 	};
 }