blun-king-cli 9.1.263 → 9.1.265

package/bin/identity-context-policy.cjs

@@ -95,8 +95,8 @@ function addField(lines, label, value) {
   if (text) lines.push(`- ${label}: ${text}`);
 }
 
-function addList(lines, label, value) {
-  const items = cleanList(value);
+function addList(lines, label, value, maxItems = 5) {
+  const items = cleanList(value, maxItems);
   if (items.length > 0) lines.push(`- ${label}: ${items.join('; ')}`);
 }
 
@@ -127,6 +127,7 @@ function renderRelationship(lines, relationship) {
   addList(lines, 'Confirmed preferences', relationship.confirmed_preferences);
   addList(lines, 'No-go topics or patterns', relationship.no_gos);
   addList(lines, 'Open threads', relationship.open_threads);
+  addList(lines, 'Confirmed repair lessons', relationship.repair_lessons, 3);
 }
 
 function renderGroup(lines, group) {
@@ -195,6 +196,7 @@ function recordChannelIdentity(envelope, env = process.env) {
     confirmed_preferences: [],
     no_gos: [],
     open_threads: [],
+    repair_lessons: [],
   })) created.push('relationship');
   if (groupId && createJsonOnce(root, ['groups', `${groupId}.json`], {
     version: 1,

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

@@ -10,9 +10,11 @@ const PERSONALITY_CURIOSITY_BLOCK = `When personality context is enabled and the
 
 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 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.`;
+
 function naturalPresenceSystemBlock(env = process.env) {
   if (!personalityContextEnabled(env)) return NATURAL_PRESENCE_BLOCK;
-  return `${NATURAL_PRESENCE_BLOCK}\n\n${PERSONALITY_CURIOSITY_BLOCK}\n\n${OPEN_THREAD_BLOCK}`;
+  return `${NATURAL_PRESENCE_BLOCK}\n\n${PERSONALITY_CURIOSITY_BLOCK}\n\n${OPEN_THREAD_BLOCK}\n\n${RELATIONSHIP_REPAIR_BLOCK}`;
 }
 
 module.exports = {

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.263",
+  "version": "9.1.265",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {