blun-king-cli 9.1.220 → 9.1.222

package/bin/launcher-runtime.js

@@ -29,16 +29,11 @@ const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
-  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
-  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-  RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
-  RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
   clearActiveRuntime,
   handoffArgsForMode,
-  handoffRuntime,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
   recordRunningUpdateEvent,
@@ -283,9 +278,6 @@ function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
-  let handoffSessionId;
-  let handoffMode;
-  let handoffCwd = cwd;
   let updateStarted = false;
   let runtimeReady = false;
   let runtimeExitIntent = false;
@@ -297,9 +289,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     const persistedMode = readRunningUpdateMode(env.BLUN_HOME);
     if (persistedMode !== runningUpdateMode) {
       runningUpdateMode = persistedMode;
-      handoffSessionId = undefined;
-      handoffMode = undefined;
-      handoffCwd = cwd;
     }
   };
   const clearRunningUpdatePoll = () => {
@@ -317,20 +306,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       else scheduleNextPreparation(child);
     });
   };
-  const announcePrepared = (child) => {
-    if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
-    try {
-      child.send({
-        type: RUNNING_UPDATE_PREPARED_MESSAGE,
-        version: preparedTarget.version,
-        mode: runningUpdateMode,
-      }, (error) => {
-        if (error) options.onRunningUpdateError?.(error);
-      });
-    } catch (error) {
-      options.onRunningUpdateError?.(error);
-    }
-  };
   const startPreparation = (child) => {
     if (updateStarted || options.runningUpdate === false || !automaticMode()) return;
     updateStarted = true;
@@ -361,7 +336,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         activePackageRoot: packageRoot,
       })).catch((error) => options.onRunningUpdateError?.(error));
       clearRunningUpdatePoll();
-      announcePrepared(child);
     }).catch((error) => {
       updateStarted = false;
       options.onRunningUpdateError?.(error);
@@ -378,48 +352,14 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     }
     if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
       runningUpdateMode = normalizeRunningUpdateMode(message.mode);
-      handoffSessionId = undefined;
-      handoffMode = undefined;
-      handoffCwd = cwd;
       clearRunningUpdatePoll();
       if (automaticMode()) {
-        if (preparedTarget !== undefined) announcePrepared(child);
-        else if (runtimeReady) {
+        if (preparedTarget === undefined && runtimeReady) {
           updateStarted = false;
           startPreparation(child);
         }
       } else if (runtimeReady) scheduleNextPreparation(child);
     }
-    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
-      && typeof message.sessionId === 'string'
-      && message.sessionId.length > 0
-      && message.mode === runningUpdateMode
-      && automaticMode()) {
-      handoffSessionId = message.sessionId;
-      handoffMode = runningUpdateMode;
-      handoffCwd = resolveHandoffCwd(message.cwd, cwd);
-      if (preparedTarget !== undefined && message.version === preparedTarget.version) {
-        try {
-          (options.stageRuntime || stageRuntime)(env.BLUN_SHARED_HOME, preparedTarget, {
-            mode: handoffMode,
-            sessionId: handoffSessionId,
-            cwd: handoffCwd,
-          });
-          child.send({
-            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-            version: preparedTarget.version,
-            mode: handoffMode,
-            sessionId: handoffSessionId,
-          }, (error) => {
-            if (error) options.onRunningUpdateError?.(error);
-          });
-        } catch (error) {
-          handoffSessionId = undefined;
-          handoffMode = undefined;
-          options.onRunningUpdateError?.(error);
-        }
-      }
-    }
   };
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
   const core = options.existingCore || spawnCore(args, env, cwd, {
@@ -460,67 +400,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const result = await core.completed;
   clearRunningUpdatePoll();
   if (existingMessageHandler) core.child.off('message', existingMessageHandler);
-  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
-    && preparedTarget !== undefined
-    && handoffSessionId !== undefined
-    && handoffMode !== undefined) {
-    const previousActiveRuntime = (options.readActiveRuntime || readActiveRuntime)(env.BLUN_SHARED_HOME);
-    const activatedAt = (options.nowImpl || Date.now)();
-    const handoff = await handoffRuntime({
-      target: preparedTarget,
-      previous: { packageRoot, version: readPackageVersionAt(packageRoot) },
-      sessionId: handoffSessionId,
-      mode: handoffMode,
-      args,
-      probeTarget: options.probeRunningUpdate || (() => true),
-      stopOld: async () => {},
-      startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
-        const nextCore = spawnCore(nextArgs, env, handoffCwd, { packageRoot: nextRoot });
-        const nextLoaded = await nextCore.loaded;
-        const ready = nextLoaded && await waitForRuntimeReady(nextCore, options.readyTimeoutMs);
-        if (!ready) {
-          try { nextCore.child.kill(); } catch {}
-          await nextCore.completed;
-        }
-        return { ...nextCore, ready };
-      },
-      activateTarget: async (target) => {
-        await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target);
-        (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, target);
-        (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
-          event: 'activated',
-          fromVersion: readPackageVersionAt(packageRoot),
-          toVersion: target.version,
-        }, { now: options.nowImpl });
-        try {
-          await (options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(env.BLUN_SHARED_HOME, {
-            activePackageRoot: target.packageRoot,
-          });
-        } catch (error) {
-          options.onRunningUpdateError?.(error);
-        }
-      },
-    });
-    if (handoff.kind !== 'activated') {
-      (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, preparedTarget);
-    }
-    const resumed = handoff.core;
-    if (resumed === undefined || resumed.ready !== true) return 1;
-    const resumedArgs = handoffArgsForMode(args, handoffMode, handoffSessionId);
-    return superviseProtectedCore(resumedArgs, env, handoffCwd, async () => {}, {
-      ...options,
-      existingCore: resumed,
-      packageRoot: handoff.runtime.packageRoot,
-      startupPendingRuntime: undefined,
-      staleActiveRuntime: undefined,
-      recoveryRuntime: handoff.kind === 'activated' ? {
-        activatedAt,
-        activeRuntime: previousActiveRuntime,
-        packageRoot,
-        version: readPackageVersionAt(packageRoot),
-      } : undefined,
-    });
-  }
   const recovery = options.recoveryRuntime;
   if (shouldRecoverActivatedRuntime(result, recovery, {
     now: (options.nowImpl || Date.now)(),
@@ -651,6 +530,7 @@ function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS) {
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
   let startupPendingRuntime;
+  let deferredPendingRuntime;
   let staleActiveRuntime;
   if (options.skipActiveRuntime !== true) {
     const activeHome = resolveLauncherPrivatePaths().sharedHome;
@@ -660,20 +540,12 @@ async function runLauncher(options = {}) {
     if (pendingRuntime !== null
       && path.resolve(pendingRuntime.packageRoot) !== PKG
       && compareSemver(currentVersion, pendingRuntime.version) === -1) {
-      const pendingArgs = pendingRuntime.mode !== undefined && pendingRuntime.sessionId !== undefined
-        ? handoffArgsForMode(RAW_ARGS, pendingRuntime.mode, pendingRuntime.sessionId)
-        : RAW_ARGS;
-      process.exitCode = await spawnActiveLauncher(
-        pendingRuntime.packageRoot,
-        pendingRuntime.cwd || callerCwd,
-        pendingArgs,
-      );
-      return;
+      deferredPendingRuntime = pendingRuntime;
     }
     if (pendingRuntime !== null && path.resolve(pendingRuntime.packageRoot) === PKG) {
       startupPendingRuntime = pendingRuntime;
     }
-    if (startupPendingRuntime === undefined && activeRuntime !== null
+    if (startupPendingRuntime === undefined && deferredPendingRuntime === undefined && activeRuntime !== null
       && path.resolve(activeRuntime.packageRoot) !== PKG
       && compareSemver(currentVersion, activeRuntime.version) === -1) {
       process.exitCode = await spawnActiveLauncher(activeRuntime.packageRoot, callerCwd);
@@ -837,8 +709,24 @@ async function runLauncher(options = {}) {
         stderr: process.stderr,
         blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
+        preparedRuntime: deferredPendingRuntime,
         noticeLease,
       });
+    if (updateResult.kind === 'installed'
+      && updateResult.source === 'prepared_runtime'
+      && deferredPendingRuntime !== undefined) {
+      const pendingArgs = deferredPendingRuntime.mode !== undefined
+        && deferredPendingRuntime.sessionId !== undefined
+        ? handoffArgsForMode(RAW_ARGS, deferredPendingRuntime.mode, deferredPendingRuntime.sessionId)
+        : RAW_ARGS;
+      await releaseNotice();
+      process.exitCode = await spawnActiveLauncher(
+        deferredPendingRuntime.packageRoot,
+        deferredPendingRuntime.cwd || callerCwd,
+        pendingArgs,
+      );
+      return;
+    }
     if (updateResult.kind === 'installed' || updateResult.kind === 'update_in_progress') return;
 
     if (!runtimeLease) {

package/bin/pending-token-estimate-policy.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+function createPendingTokenEstimateCache(estimateMessages) {
+  if (typeof estimateMessages !== 'function') {
+    throw new TypeError('estimateMessages must be a function');
+  }
+
+  let cachedHistory = null;
+  let cachedCoveredCount = -1;
+  let cachedRevision = -1;
+  let cachedEstimate = 0;
+
+  return {
+    read(history, coveredMessageCount, revision) {
+      const messages = Array.isArray(history) ? history : [];
+      const covered = Math.max(
+        0,
+        Math.min(messages.length, Math.floor(Number(coveredMessageCount) || 0)),
+      );
+      const currentRevision = Number.isSafeInteger(revision) ? revision : 0;
+
+      if (
+        messages === cachedHistory
+        && covered === cachedCoveredCount
+        && currentRevision === cachedRevision
+      ) {
+        return cachedEstimate;
+      }
+
+      cachedEstimate = estimateMessages(messages.slice(covered));
+      cachedHistory = messages;
+      cachedCoveredCount = covered;
+      cachedRevision = currentRevision;
+      return cachedEstimate;
+    },
+  };
+}
+
+module.exports = {
+  createPendingTokenEstimateCache,
+};

package/bin/update-notice.js

@@ -1393,6 +1393,13 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitNoTarget(stdout, reason, currentVersion)
         : { kind: 'continue', reason };
     }
+    const preparedRuntime = options.preparedRuntime;
+    const preparedRuntimeReady = preparedRuntime !== null
+      && typeof preparedRuntime === 'object'
+      && preparedRuntime.version === release.version
+      && typeof preparedRuntime.packageRoot === 'string'
+      && path.isAbsolute(preparedRuntime.packageRoot)
+      && verifyInstalledPackageVersion(preparedRuntime.packageRoot, release.version);
     if (!explicitUpdate
       && pendingVersion === undefined
       && readSnoozeState(blunDir, release.version, now)) {
@@ -1438,7 +1445,7 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitFailure(stderr, 'lease_unavailable')
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
-    if (!options.installVersion) {
+    if (!options.installVersion && !preparedRuntimeReady) {
       installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
         release.version,
         { blunDir, packageRoot },
@@ -1502,9 +1509,11 @@ async function runUpdateFlow(options, explicitUpdate) {
     let installResult;
     updateProgress(3, 'Paket wird installiert');
     try {
-      installResult = options.installVersion
-        ? await options.installVersion(release.version)
-        : await installerSession.commit();
+      installResult = preparedRuntimeReady
+        ? { code: 0, verified: true, preparedRuntime: true }
+        : options.installVersion
+          ? await options.installVersion(release.version)
+          : await installerSession.commit();
     } catch {
       installResult = { code: undefined };
     }
@@ -1536,7 +1545,11 @@ async function runUpdateFlow(options, explicitUpdate) {
         `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n`,
       );
       if (release.notesUrl) stdout.write(`Versionshinweise: ${release.notesUrl}\n`);
-      return { kind: 'installed', version: release.version };
+      return {
+        kind: 'installed',
+        version: release.version,
+        ...(installResult.preparedRuntime === true ? { source: 'prepared_runtime' } : {}),
+      };
     }
 
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {

package/blun.mjs

@@ -78650,12 +78650,13 @@ function formatUndoUnavailableMessage(requestedCount, undoableCount, stoppedAtCo
 		return `${String(count)} ${count === 1 ? "prompt" : "prompts"}`;
 	}
 }
-var TOOL_ERROR_STATUS$2, TOOL_EMPTY_STATUS$2, TOOL_EMPTY_ERROR_STATUS$2, TOOL_OUTPUT_EMPTY_TEXT$2, TOOL_INTERRUPTED_ON_RESUME_OUTPUT$1, ContextMemory;
+var TOOL_ERROR_STATUS$2, TOOL_EMPTY_STATUS$2, TOOL_EMPTY_ERROR_STATUS$2, TOOL_OUTPUT_EMPTY_TEXT$2, TOOL_INTERRUPTED_ON_RESUME_OUTPUT$1, createPendingTokenEstimateCache, ContextMemory;
 var init_context$2 = __esmMin((() => {
-	init_src$4();
-	init_errors$8();
-	init_image_compress();
-	init_tokens();
+		init_src$4();
+		init_errors$8();
+		init_image_compress();
+		init_tokens();
+		({ createPendingTokenEstimateCache } = createRequire(import.meta.url)("./bin/pending-token-estimate-policy.cjs"));
 	init_xml_escape();
 	init_compaction();
 	init_projector();
@@ -78669,8 +78670,10 @@ var init_context$2 = __esmMin((() => {
 	ContextMemory = class {
 		agent;
 		_history = [];
-		_tokenCount = 0;
-		tokenCountCoveredMessageCount = 0;
+			_tokenCount = 0;
+			tokenCountCoveredMessageCount = 0;
+			pendingTokenRevision = 0;
+			pendingTokenEstimateCache = createPendingTokenEstimateCache(estimateTokensForMessages);
 		openSteps = /* @__PURE__ */ new Map();
 		pendingToolResultIds = /* @__PURE__ */ new Set();
 		deferredMessages = [];
@@ -78679,9 +78682,12 @@ var init_context$2 = __esmMin((() => {
 		constructor(agent) {
 			this.agent = agent;
 		}
-		get lastAssistantAt() {
-			return this._lastAssistantAt;
-		}
+			get lastAssistantAt() {
+				return this._lastAssistantAt;
+			}
+			markPendingTokenEstimateDirty() {
+				this.pendingTokenRevision = (this.pendingTokenRevision + 1) % Number.MAX_SAFE_INTEGER;
+			}
 		appendUserMessage(content, origin = USER_PROMPT_ORIGIN) {
 			if (content.length === 0) return;
 			const { captions, parts } = origin.kind === "user" ? splitImageCompressionCaptions(content) : {
@@ -78783,8 +78789,11 @@ var init_context$2 = __esmMin((() => {
 			const last = lastDeferred ?? this._history.at(-1);
 			if (last === void 0) return false;
 			if (!matcher(last.origin)) return false;
-			if (lastDeferred !== void 0) this.deferredMessages.pop();
-			else this._history.pop();
+				if (lastDeferred !== void 0) this.deferredMessages.pop();
+				else {
+					this._history.pop();
+					this.markPendingTokenEstimateDirty();
+				}
 			return true;
 		}
 		/** Remove transient system reminders before the next model projection. */
@@ -78806,7 +78815,8 @@ var init_context$2 = __esmMin((() => {
 				removedMessages.add(message);
 				return false;
 			});
-			if (removedMessages.size === 0) return 0;
+				if (removedMessages.size === 0) return 0;
+				this.markPendingTokenEstimateDirty();
 			this.agent.replayBuilder.removeLastMessages(removedMessages);
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
@@ -78817,7 +78827,8 @@ var init_context$2 = __esmMin((() => {
 		}
 		clear() {
 			this.agent.records.logRecord({ type: "context.clear" });
-			this._history = [];
+				this._history = [];
+				this.markPendingTokenEstimateDirty();
 			this._tokenCount = 0;
 			this.tokenCountCoveredMessageCount = 0;
 			this.openSteps.clear();
@@ -78861,7 +78872,8 @@ var init_context$2 = __esmMin((() => {
 					if (removedUserCount >= count) break;
 				}
 			}
-			this.agent.replayBuilder.removeLastMessages(removedMessages);
+				this.agent.replayBuilder.removeLastMessages(removedMessages);
+				if (removedMessages.size > 0) this.markPendingTokenEstimateDirty();
 			this.openSteps.clear();
 			this.pendingToolResultIds.clear();
 			this.deferredMessages = [];
@@ -78940,7 +78952,8 @@ var init_context$2 = __esmMin((() => {
 				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 = isLegacyRestore ? [summaryMessage, ...this._history.slice(input.compactedCount)] : [...keptMessages, summaryMessage];
+				this.markPendingTokenEstimateDirty();
 			this.openSteps.clear();
 			this.pendingToolResultIds.clear();
 			this.deferredMessages = [];
@@ -78963,9 +78976,12 @@ var init_context$2 = __esmMin((() => {
 		get tokenCount() {
 			return this._tokenCount;
 		}
-		get tokenCountWithPending() {
-			const pendingMessages = this._history.slice(this.tokenCountCoveredMessageCount);
-			return this._tokenCount + estimateTokensForMessages(pendingMessages);
+			get tokenCountWithPending() {
+				return this._tokenCount + this.pendingTokenEstimateCache.read(
+					this._history,
+					this.tokenCountCoveredMessageCount,
+					this.pendingTokenRevision
+				);
 		}
 		get history() {
 			return this._history;
@@ -79120,6 +79136,7 @@ var init_context$2 = __esmMin((() => {
 							this._tokenCount += estimateTokensForMessages(this._history.slice(previousCoveredCount, coveredCount));
 						}
 						this.tokenCountCoveredMessageCount = coveredCount;
+						this.markPendingTokenEstimateDirty();
 					}
 					this.flushDeferredMessagesIfToolExchangeClosed();
 					return;
@@ -79127,18 +79144,20 @@ var init_context$2 = __esmMin((() => {
 				case "content.part": {
 					const openStep = this.openSteps.get(event.stepUuid);
 					if (openStep === void 0) throw new Error(`Received content_part for unknown step_uuid '${event.stepUuid}' (no open step_begin)`);
-					openStep.content.push(event.part);
+						openStep.content.push(event.part);
+						this.markPendingTokenEstimateDirty();
 					return;
 				}
 				case "tool.call": {
 					const openStep = this.openSteps.get(event.stepUuid);
 					if (openStep === void 0) throw new Error(`Received tool_call for unknown step_uuid '${event.stepUuid}' (no open step_begin)`);
-					openStep.toolCalls.push({
+						openStep.toolCalls.push({
 						type: "function",
 						id: event.toolCallId,
 						name: event.name,
-						arguments: event.args === void 0 ? null : JSON.stringify(event.args)
-					});
+							arguments: event.args === void 0 ? null : JSON.stringify(event.args)
+						});
+						this.markPendingTokenEstimateDirty();
 					this.pendingToolResultIds.add(event.toolCallId);
 					return;
 				}
@@ -79175,8 +79194,9 @@ var init_context$2 = __esmMin((() => {
 		hasOpenToolExchange() {
 			return this.pendingToolResultIds.size > 0;
 		}
-		pushHistory(...messages) {
-			this._history.push(...messages);
+			pushHistory(...messages) {
+				this._history.push(...messages);
+				this.markPendingTokenEstimateDirty();
 			for (const message of messages) {
 				if (message.role === "assistant") this._lastAssistantAt = this.agent.records.restoring?.time ?? Date.now();
 				if (message.origin?.kind === "background_task") this.agent.background.markDeliveredNotification(message.origin);
@@ -515099,8 +515119,6 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 const {
 	AUTO_UPDATE_SETTLE_MS,
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
-	RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_EXIT_INTENT_MESSAGE,
@@ -515128,64 +515146,14 @@ function notifyRunningRuntimeReady(tui) {
 	} catch {}
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
-	const boundaryState = () => ({
-		isShuttingDown: tui.isShuttingDown,
-		streamingPhase: tui.state.appState.streamingPhase,
-		isCompacting: tui.state.appState.isCompacting,
-		queuedMessages: tui.state.queuedMessages.length,
-		activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
-		shellCommands: tui.shellOutputStreams.size,
-		queueCommandRunning: tui.queueCommandRunning
-	});
-	if (!isSafeRuntimeBoundary(boundaryState())) return false;
-	const sessionId = tui.getCurrentSessionId();
-	if (sessionId.length === 0) return false;
-	tui.runningUpdateHandoffStarted = true;
-	try {
-		process.send({
-			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
-			sessionId,
-			version: tui.runningUpdatePreparedVersion,
-			mode: tui.runningUpdatePreparedMode,
-			cwd: tui.state.appState.workDir
-		}, (error) => {
-			if (error || !isSafeRuntimeBoundary(boundaryState())) {
-				tui.runningUpdateHandoffStarted = false;
-			}
-		});
-	} catch {
-		tui.runningUpdateHandoffStarted = false;
-		return false;
-	}
-	return true;
+	return false;
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
-		if (message?.type === RUNNING_UPDATE_HANDOFF_ACK_MESSAGE) {
-			if (!tui.runningUpdateHandoffStarted || message.version !== tui.runningUpdatePreparedVersion || message.mode !== tui.runningUpdatePreparedMode || message.sessionId !== tui.getCurrentSessionId()) return;
-			if (!isSafeRuntimeBoundary({
-				isShuttingDown: tui.isShuttingDown,
-				streamingPhase: tui.state.appState.streamingPhase,
-				isCompacting: tui.state.appState.isCompacting,
-				queuedMessages: tui.state.queuedMessages.length,
-				activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
-				shellCommands: tui.shellOutputStreams.size,
-				queueCommandRunning: tui.queueCommandRunning
-			})) {
-				tui.runningUpdateHandoffStarted = false;
-				return;
-			}
-			tui.showStatus("Ein Update wird geladen und die TUI wird neu gestartet.", "success");
-			void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE).catch(() => {
-				tui.runningUpdateHandoffStarted = false;
-			});
-			return;
-		}
 		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string" || message.mode !== RUNNING_UPDATE_MODES.RESUME && message.mode !== RUNNING_UPDATE_MODES.NEW) return;
 		tui.runningUpdatePreparedVersion = message.version;
 		tui.runningUpdatePreparedMode = message.mode;
-		requestRunningUpdateAtSafeBoundary(tui);
+		tui.showStatus(`Update ${message.version} ist bereit und wird beim naechsten Start aktiviert.`, "success");
 	};
 	process.on("message", handler);
 	return () => process.off("message", handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.220",
+  "version": "9.1.222",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {