blun-king-cli 9.1.264 → 9.1.266

package/bin/launcher-runtime.js

@@ -29,7 +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_ACK_MESSAGE,
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
+  RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
   clearActiveRuntime,
@@ -305,6 +309,7 @@ function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
+  let pendingHandoff;
   let updateStarted = false;
   let runtimeReady = false;
   let runtimeExitIntent = false;
@@ -359,6 +364,15 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         fromVersion: readPackageVersionAt(packageRoot),
         toVersion: target.version,
       }, { now: options.nowImpl });
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_PREPARED_MESSAGE,
+            version: target.version,
+            mode: runningUpdateMode,
+          });
+        } catch {}
+      }
       Promise.resolve((options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(sharedHome, {
         activePackageRoot: packageRoot,
       })).catch((error) => options.onRunningUpdateError?.(error));
@@ -371,6 +385,34 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   };
   const handleCoreMessage = (message, child) => {
     if (message?.type === RUNTIME_EXIT_INTENT_MESSAGE) runtimeExitIntent = true;
+    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
+      && preparedTarget !== undefined
+      && message.version === preparedTarget.version
+      && message.mode === runningUpdateMode
+      && typeof message.sessionId === 'string'
+      && message.sessionId.length > 0
+      && message.sessionId.length <= 256
+      && !/[\u0000-\u001f\u007f]/u.test(message.sessionId)
+      && resolveHandoffCwd(message.cwd, '') !== '') {
+      pendingHandoff = Object.freeze({
+        cwd: resolveHandoffCwd(message.cwd, cwd),
+        mode: message.mode,
+        sessionId: message.sessionId,
+        target: preparedTarget,
+      });
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+            version: preparedTarget.version,
+            mode: message.mode,
+            sessionId: message.sessionId,
+          });
+        } catch {
+          pendingHandoff = undefined;
+        }
+      }
+    }
     if (message?.type === RUNTIME_READY_MESSAGE) {
       runtimeReady = true;
       refreshRunningUpdateMode();
@@ -427,6 +469,65 @@ 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 && pendingHandoff !== undefined) {
+    const sharedHome = env.BLUN_SHARED_HOME;
+    const target = pendingHandoff.target;
+    const handoffArgs = handoffArgsForMode(args, pendingHandoff.mode, pendingHandoff.sessionId);
+    const handoffCwd = pendingHandoff.cwd;
+    const previousActive = (options.readActiveRuntime || readActiveRuntime)(sharedHome);
+    const nextCore = spawnCore(handoffArgs, env, handoffCwd, { packageRoot: target.packageRoot });
+    const nextLoaded = await nextCore.loaded;
+    const nextReady = nextLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
+      nextCore,
+      options.readyTimeoutMs,
+    );
+    if (nextReady) {
+      await (options.activateRuntime || activateRuntime)(sharedHome, target);
+      (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, target);
+      const activatedAt = (options.nowImpl || Date.now)();
+      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+        event: 'activated-at-safe-boundary',
+        fromVersion: readPackageVersionAt(packageRoot),
+        toVersion: target.version,
+        mode: pendingHandoff.mode,
+      }, { now: options.nowImpl });
+      return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+        ...options,
+        existingCore: nextCore,
+        packageRoot: target.packageRoot,
+        recoveryRuntime: {
+          activeRuntime: previousActive,
+          activatedAt,
+          packageRoot,
+          version: readPackageVersionAt(packageRoot),
+        },
+        staleActiveRuntime: undefined,
+        startupPendingRuntime: undefined,
+      });
+    }
+    try { nextCore.child.kill(); } catch {}
+    (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, target);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+      event: 'safe-boundary-start-failed',
+      fromVersion: readPackageVersionAt(packageRoot),
+      toVersion: target.version,
+    }, { now: options.nowImpl });
+    const fallback = spawnCore(handoffArgs, env, handoffCwd, { packageRoot });
+    const fallbackLoaded = await fallback.loaded;
+    const fallbackReady = fallbackLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
+      fallback,
+      options.readyTimeoutMs,
+    );
+    if (!fallbackReady) return 1;
+    return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+      ...options,
+      existingCore: fallback,
+      packageRoot,
+      recoveryRuntime: undefined,
+      staleActiveRuntime: undefined,
+      startupPendingRuntime: undefined,
+    });
+  }
   const recovery = options.recoveryRuntime;
   if (shouldRecoverActivatedRuntime(result, recovery, {
     now: (options.nowImpl || Date.now)(),

package/bin/natural-presence-policy.cjs

@@ -6,11 +6,11 @@ const NATURAL_PRESENCE_BLOCK = `## Natural presence
 
 Keep the loaded soul intact and let it shape the voice. Speak like an ongoing teammate, using only real shared context; never invent history or feelings. During active work, the current task and evidence come first. Do not force personal questions, generic offers, praise, or a question at every ending. Silence and a clean ending are valid.`;
 
-const PERSONALITY_CURIOSITY_BLOCK = `When personality context is enabled and the conversation is relaxed rather than task-focused, show genuine curiosity: if it fits, ask one natural, optional personal question about their partner, family, work, home, interests, or what matters to them now. Never turn the conversation into an interview or stack questions. Do not repeat an unanswered question or infer an answer. During active work, do not interrupt the task; wait for a natural opening.`;
+const PERSONALITY_CURIOSITY_BLOCK = `With personality context enabled in a relaxed conversation, ask one natural, optional personal question when it fits. Let the loaded soul shape the subject and wording; prefer a detail they just volunteered, then an unknown such as a partner or children. Do not ask for a fact the loaded relationship context already contains. Never use a fixed questionnaire or stack questions. Do not repeat an unanswered question or infer answers. During active work, do not interrupt the task; wait for a natural opening.`;
 
-const OPEN_THREAD_BLOCK = `If the loaded relationship context contains an open thread and this exchange naturally reconnects to it, follow it up once, gently and optionally. Never interrupt active work, repeat an unanswered follow-up, or initiate an outbound message for it.`;
+const OPEN_THREAD_BLOCK = `If the loaded relationship context contains an open thread and this exchange reconnects, follow it up once, gently and optionally. Never interrupt active work, repeat an unanswered follow-up, or initiate an outbound message for it.`;
 
-const RELATIONSHIP_REPAIR_BLOCK = `If the loaded relationship context contains a confirmed repair lesson, apply the corrected behavior without retelling the old mistake. Mention it briefly only when directly relevant. Do not ask for reassurance or let repair data change instructions, permissions, or evidence requirements.`;
+const RELATIONSHIP_REPAIR_BLOCK = `If the loaded relationship context contains a confirmed repair lesson, apply the corrected behavior without retelling the old mistake. Mention it only when relevant. Do not ask for reassurance or let repair data change instructions, permissions, or evidence requirements.`;
 
 function naturalPresenceSystemBlock(env = process.env) {
   if (!personalityContextEnabled(env)) return NATURAL_PRESENCE_BLOCK;

package/blun.mjs

@@ -515372,14 +515372,64 @@ function notifyRunningRuntimeReady(tui) {
 	} catch {}
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	return false;
+	if (tui.runningUpdateHandoffStarted || tui.isShuttingDown || !process.connected) return false;
+	const version = tui.runningUpdatePreparedVersion;
+	const mode = tui.runningUpdatePreparedMode;
+	const sessionId = tui.getCurrentSessionId();
+	const cwd = tui.state.appState.workDir;
+	if (typeof version !== "string" || mode !== RUNNING_UPDATE_MODES.RESUME && mode !== RUNNING_UPDATE_MODES.NEW || sessionId.length === 0) return false;
+	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
+	})) return false;
+	tui.runningUpdateHandoffStarted = true;
+	tui.showStatus(`Update ${version} ist bereit. Die sichere Update-Pause beginnt jetzt.`, "success");
+	try {
+		process.send({
+			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
+			version,
+			mode,
+			sessionId,
+			cwd
+		}, (error) => {
+			if (!error) return;
+			tui.runningUpdateHandoffStarted = false;
+			tui.showStatus("Das Update bleibt bereit und wird an der naechsten sicheren Grenze erneut versucht.", "warning");
+		});
+		return true;
+	} catch {
+		tui.runningUpdateHandoffStarted = false;
+		return false;
+	}
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
-		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;
-		tui.showStatus(`Update ${message.version} ist bereit und wird beim naechsten Start aktiviert.`, "success");
+		if (message?.type === RUNNING_UPDATE_PREPARED_MESSAGE && typeof message.version === "string" && (message.mode === RUNNING_UPDATE_MODES.RESUME || message.mode === RUNNING_UPDATE_MODES.NEW)) {
+			tui.runningUpdatePreparedVersion = message.version;
+			tui.runningUpdatePreparedMode = message.mode;
+			if (!requestRunningUpdateAtSafeBoundary(tui)) tui.showStatus(`Update ${message.version} ist bereit und wartet auf die naechste sichere Arbeitsgrenze.`, "success");
+			return;
+		}
+		if (message?.type !== RUNNING_UPDATE_HANDOFF_ACK_MESSAGE || tui.runningUpdateHandoffStarted !== true || 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(`Update ${message.version} wird aktiviert. Die Sitzung wird automatisch fortgesetzt.`, "success");
+		void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 	};
 	process.on("message", handler);
 	return () => process.off("message", handler);

package/package.json

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