blun-king-cli 9.1.208 → 9.1.210

package/bin/launcher-runtime.js

@@ -33,12 +33,19 @@ const {
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
+  RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
+  clearActiveRuntime,
   handoffArgsForMode,
   handoffRuntime,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
+  recordRunningUpdateEvent,
   readActiveRuntime,
+  readPendingRuntime,
+  restoreActiveRuntime,
+  clearPendingRuntime,
+  stageRuntime,
 } = require('./running-update.cjs');
 const {
   RUNNING_UPDATE_MODES,
@@ -62,9 +69,9 @@ const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.ar
 const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
 const RUNTIME_READY_TIMEOUT_MS = 60_000;
-const RUNNING_UPDATE_RECHECK_MS = 60_000;
-const RUNNING_UPDATE_RECHECK_JITTER_MS = 30_000;
-const RUNNING_UPDATE_HANDOFF_NOTICE = 'Ein Update wird geladen. Die TUI wird anschließend neu gestartet.';
+const RUNNING_UPDATE_RECHECK_MS = 5 * 60_000;
+const RUNNING_UPDATE_RECHECK_JITTER_MS = 2 * 60_000;
+const RUNNING_UPDATE_STABILIZATION_MS = 2 * 60 * 1000;
 
 function runningUpdateRecheckDelay(randomValue = Math.random()) {
   const normalized = Number.isFinite(randomValue)
@@ -83,10 +90,6 @@ function scheduleRunningUpdateRecheck(callback, options = {}) {
   return timer;
 }
 
-function writeRunningUpdateHandoffNotice(output = process.stdout) {
-  output.write(`\n${RUNNING_UPDATE_HANDOFF_NOTICE}\n`);
-}
-
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
 }
@@ -268,6 +271,14 @@ function resolveHandoffCwd(candidate, fallback) {
   }
 }
 
+function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
+  if (recovery === undefined || options.runtimeExitIntent === true) return false;
+  const signal = result?.signal;
+  if (signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP') return false;
+  const now = options.now ?? Date.now();
+  return now - recovery.activatedAt <= RUNNING_UPDATE_STABILIZATION_MS;
+}
+
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
@@ -276,6 +287,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   let handoffCwd = cwd;
   let updateStarted = false;
   let runtimeReady = false;
+  let runtimeExitIntent = false;
   let runningUpdatePollTimer;
   let runningUpdateMode = readRunningUpdateMode(env.BLUN_HOME);
   const automaticMode = () => runningUpdateMode === RUNNING_UPDATE_MODES.RESUME
@@ -306,11 +318,17 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   };
   const announcePrepared = (child) => {
     if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
-    child.send({
-      type: RUNNING_UPDATE_PREPARED_MESSAGE,
-      version: preparedTarget.version,
-      mode: runningUpdateMode,
-    });
+    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;
@@ -332,6 +350,15 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         return;
       }
       preparedTarget = target;
+      (options.stageRuntime || stageRuntime)(sharedHome, target, { mode: runningUpdateMode });
+      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+        event: 'prepared-for-next-start',
+        fromVersion: readPackageVersionAt(packageRoot),
+        toVersion: target.version,
+      }, { now: options.nowImpl });
+      Promise.resolve((options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(sharedHome, {
+        activePackageRoot: packageRoot,
+      })).catch((error) => options.onRunningUpdateError?.(error));
       clearRunningUpdatePoll();
       announcePrepared(child);
     }).catch((error) => {
@@ -341,6 +368,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     });
   };
   const handleCoreMessage = (message, child) => {
+    if (message?.type === RUNTIME_EXIT_INTENT_MESSAGE) runtimeExitIntent = true;
     if (message?.type === RUNTIME_READY_MESSAGE) {
       runtimeReady = true;
       refreshRunningUpdateMode();
@@ -369,6 +397,13 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       handoffSessionId = message.sessionId;
       handoffMode = runningUpdateMode;
       handoffCwd = resolveHandoffCwd(message.cwd, cwd);
+      if (preparedTarget !== undefined) {
+        (options.stageRuntime || stageRuntime)(env.BLUN_SHARED_HOME, preparedTarget, {
+          mode: handoffMode,
+          sessionId: handoffSessionId,
+          cwd: handoffCwd,
+        });
+      }
     }
   };
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
@@ -382,6 +417,21 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     core.child.on('message', existingMessageHandler);
   }
   const loaded = await core.loaded;
+  if (loaded && options.startupPendingRuntime !== undefined) {
+    await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, options.startupPendingRuntime);
+    (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, options.startupPendingRuntime);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: 'activated-on-start',
+      version: options.startupPendingRuntime.version,
+    }, { now: options.nowImpl });
+  } else if (loaded && options.staleActiveRuntime !== undefined) {
+    (options.clearActiveRuntime || clearActiveRuntime)(env.BLUN_SHARED_HOME, options.staleActiveRuntime);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: 'stale-active-cleared',
+      staleVersion: options.staleActiveRuntime.version,
+      runningVersion: readPackageVersionAt(packageRoot),
+    }, { now: options.nowImpl });
+  }
   if (loaded && !runtimeReady) {
     // Core load is an independent readiness signal. Start the download even
     // when the later TUI-ready IPC message is lost; handoff still waits for
@@ -395,12 +445,12 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const result = await core.completed;
   clearRunningUpdatePoll();
   if (existingMessageHandler) core.child.off('message', existingMessageHandler);
-  if (result.error) throw result.error;
   if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
     && preparedTarget !== undefined
     && handoffSessionId !== undefined
     && handoffMode !== undefined) {
-    writeRunningUpdateHandoffNotice(options.runningUpdateNoticeOutput || process.stdout);
+    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) },
@@ -421,6 +471,11 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       },
       activateTarget: async (target) => {
         await (options.activateRuntime || activateRuntime)(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,
@@ -437,8 +492,49 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       ...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)(),
+    runtimeExitIntent,
+  })) {
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: 'post-activation-exit',
+      activeVersion: readPackageVersionAt(packageRoot),
+      code: Number.isInteger(result.code) ? result.code : null,
+      error: result.error?.message || null,
+      signal: result.signal || null,
+      recoveryVersion: recovery.version,
+    }, { now: options.nowImpl });
+    await (options.restoreActiveRuntime || restoreActiveRuntime)(env.BLUN_SHARED_HOME, recovery.activeRuntime);
+    const fallback = spawnCore(args, env, cwd, { packageRoot: recovery.packageRoot });
+    const fallbackLoaded = await fallback.loaded;
+    const fallbackReady = fallbackLoaded && await waitForRuntimeReady(fallback, options.readyTimeoutMs);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: fallbackReady ? 'recovery-ready' : 'recovery-failed',
+      version: recovery.version,
+    }, { now: options.nowImpl });
+    if (fallbackReady) {
+      return superviseProtectedCore(args, env, cwd, async () => {}, {
+        ...options,
+        existingCore: fallback,
+        packageRoot: recovery.packageRoot,
+        startupPendingRuntime: undefined,
+        staleActiveRuntime: undefined,
+        recoveryRuntime: undefined,
+      });
+    }
+  }
+  if (result.error) throw result.error;
   return exitCodeForChild(result, loaded);
 }
 
@@ -512,12 +608,12 @@ function spawnManagedLauncher(binary, cwd) {
   });
 }
 
-function spawnActiveLauncher(packageRoot, cwd) {
+function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS) {
   const entryName = path.basename(process.argv[1] || 'king.js').toLowerCase() === 'blun.js'
     ? 'blun.js'
     : 'king.js';
   return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [path.join(packageRoot, 'bin', entryName), ...RAW_ARGS], {
+    const child = spawn(process.execPath, [path.join(packageRoot, 'bin', entryName), ...args], {
       cwd,
       env: { ...process.env, BLUN_ACTIVE_RUNTIME_ROOT: packageRoot },
       stdio: 'inherit',
@@ -535,16 +631,40 @@ function spawnActiveLauncher(packageRoot, cwd) {
 
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
+  let startupPendingRuntime;
+  let staleActiveRuntime;
   if (options.skipActiveRuntime !== true) {
     const activeHome = resolveLauncherPrivatePaths().sharedHome;
+    const pendingRuntime = readPendingRuntime(activeHome);
     const activeRuntime = readActiveRuntime(activeHome);
     const currentVersion = readPackageVersion();
-    if (activeRuntime !== null
+    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;
+    }
+    if (pendingRuntime !== null && path.resolve(pendingRuntime.packageRoot) === PKG) {
+      startupPendingRuntime = pendingRuntime;
+    }
+    if (startupPendingRuntime === undefined && activeRuntime !== null
       && path.resolve(activeRuntime.packageRoot) !== PKG
       && compareSemver(currentVersion, activeRuntime.version) === -1) {
       process.exitCode = await spawnActiveLauncher(activeRuntime.packageRoot, callerCwd);
       return;
     }
+    if (activeRuntime !== null
+      && path.resolve(activeRuntime.packageRoot) !== PKG
+      && compareSemver(currentVersion, activeRuntime.version) >= 0) {
+      staleActiveRuntime = activeRuntime;
+    }
   }
   const mode = options.mode || launcherModeFromArgv(process.argv);
   const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
@@ -759,6 +879,7 @@ async function runLauncher(options = {}) {
       env,
       callerCwd,
       releaseNotice,
+      { startupPendingRuntime, staleActiveRuntime },
     );
   } finally {
     await releaseNotice();
@@ -768,14 +889,15 @@ async function runLauncher(options = {}) {
 module.exports = {
   RUNNING_UPDATE_RECHECK_JITTER_MS,
   RUNNING_UPDATE_RECHECK_MS,
+  RUNNING_UPDATE_STABILIZATION_MS,
   createManagedNodeEnvironment,
   resolveLauncherPrivatePaths,
   resolveHandoffCwd,
   runningUpdateRecheckDelay,
   runLauncher,
   scheduleRunningUpdateRecheck,
+  shouldRecoverActivatedRuntime,
   shouldDetachProtectedCore,
   spawnManagedLauncher,
   superviseProtectedCore,
-  writeRunningUpdateHandoffNotice,
 };

package/bin/running-update.cjs

@@ -14,11 +14,13 @@ const PACKAGE_NAME = 'blun-king-cli';
 const MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
 const REGISTRY_URL = 'https://registry.npmjs.org/blun-king-cli';
 const ACTIVE_RUNTIME_FILE = 'active-runtime.json';
+const PENDING_RUNTIME_FILE = 'pending-runtime.json';
 const RUNNING_UPDATE_HANDOFF_EXIT_CODE = 76;
 const RUNNING_UPDATE_PREPARED_MESSAGE = 'blun-running-update-prepared';
 const RUNNING_UPDATE_HANDOFF_MESSAGE = 'blun-running-update-handoff';
 const RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
 const RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
+const RUNTIME_EXIT_INTENT_MESSAGE = 'blun-runtime-exit-intent';
 const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
 const AUTO_UPDATE_SETTLE_MS = 30 * 60 * 1000;
 const DEFAULT_RETAINED_RELEASE_VERSIONS = 3;
@@ -203,6 +205,10 @@ function activeRuntimePath(sharedHome) {
   return path.join(path.resolve(sharedHome), 'updates', ACTIVE_RUNTIME_FILE);
 }
 
+function pendingRuntimePath(sharedHome) {
+  return path.join(path.resolve(sharedHome), 'updates', PENDING_RUNTIME_FILE);
+}
+
 function pathWithin(root, candidate) {
   const relative = path.relative(root, candidate);
   return relative === '' || (relative !== '..'
@@ -229,9 +235,8 @@ function verifyRuntimePackage(packageRoot, version, options = {}) {
   }
 }
 
-function readActiveRuntime(sharedHome) {
+function readRuntimeRecord(sharedHome, filePath) {
   try {
-    const filePath = activeRuntimePath(sharedHome);
     const stat = fs.lstatSync(filePath);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024) return null;
     const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -245,13 +250,31 @@ function readActiveRuntime(sharedHome) {
       || !verifyRuntimePackage(packageRoot, version, { sharedHome })) {
       return null;
     }
-    return Object.freeze({ version, packageRoot: path.resolve(packageRoot), integrity });
+    const mode = ownData(record, 'mode');
+    const sessionId = ownData(record, 'sessionId');
+    const cwd = ownData(record, 'cwd');
+    return Object.freeze({
+      version,
+      packageRoot: path.resolve(packageRoot),
+      integrity,
+      ...(mode === 'resume' || mode === 'new' ? { mode } : {}),
+      ...(typeof sessionId === 'string' && sessionId.length > 0 ? { sessionId } : {}),
+      ...(typeof cwd === 'string' && path.isAbsolute(cwd) ? { cwd: path.resolve(cwd) } : {}),
+    });
   } catch {
     return null;
   }
 }
 
-function activateRuntime(sharedHome, target) {
+function readActiveRuntime(sharedHome) {
+  return readRuntimeRecord(sharedHome, activeRuntimePath(sharedHome));
+}
+
+function readPendingRuntime(sharedHome) {
+  return readRuntimeRecord(sharedHome, pendingRuntimePath(sharedHome));
+}
+
+function writeRuntimeRecord(sharedHome, fileName, target, extra = {}) {
   if (!verifyRuntimePackage(target.packageRoot, target.version, { sharedHome })
     || !validIntegrity(target.integrity)) {
     throw new Error('RUNNING_UPDATE_TARGET_INVALID');
@@ -259,14 +282,14 @@ function activateRuntime(sharedHome, target) {
   const updateRoot = path.join(path.resolve(sharedHome), 'updates');
   ensurePrivateDirectory(path.resolve(sharedHome));
   ensurePrivateDirectory(updateRoot);
-  const filePath = activeRuntimePath(sharedHome);
-  const temporaryPath = path.join(updateRoot, `.${ACTIVE_RUNTIME_FILE}.${process.pid}.${randomUUID()}.tmp`);
+  const filePath = path.join(updateRoot, fileName);
+  const temporaryPath = path.join(updateRoot, `.${fileName}.${process.pid}.${randomUUID()}.tmp`);
   try {
     writePrivateFile(temporaryPath, `${JSON.stringify({
       version: target.version,
       packageRoot: path.resolve(target.packageRoot),
       integrity: target.integrity,
-      activatedAt: new Date().toISOString(),
+      ...extra,
     })}\n`);
     fs.renameSync(temporaryPath, filePath);
     securePrivateFile(filePath);
@@ -276,6 +299,70 @@ function activateRuntime(sharedHome, target) {
   }
 }
 
+function activateRuntime(sharedHome, target) {
+  writeRuntimeRecord(sharedHome, ACTIVE_RUNTIME_FILE, target, {
+    activatedAt: new Date().toISOString(),
+  });
+}
+
+function stageRuntime(sharedHome, target, options = {}) {
+  const mode = options.mode === 'resume' || options.mode === 'new' ? options.mode : undefined;
+  const sessionId = typeof options.sessionId === 'string' && options.sessionId.length > 0
+    ? options.sessionId
+    : undefined;
+  const cwd = typeof options.cwd === 'string' && path.isAbsolute(options.cwd)
+    ? path.resolve(options.cwd)
+    : undefined;
+  writeRuntimeRecord(sharedHome, PENDING_RUNTIME_FILE, target, {
+    preparedAt: new Date((options.now || Date.now)()).toISOString(),
+    ...(mode === undefined ? {} : { mode }),
+    ...(sessionId === undefined ? {} : { sessionId }),
+    ...(cwd === undefined ? {} : { cwd }),
+  });
+}
+
+function clearRuntimeRecord(sharedHome, expected, readRecord, filePath) {
+  const runtime = readRecord(sharedHome);
+  if (runtime === null) return false;
+  if (expected !== undefined
+    && (runtime.version !== expected.version
+      || runtime.packageRoot !== path.resolve(expected.packageRoot))) {
+    return false;
+  }
+  fs.rmSync(filePath(sharedHome), { force: true });
+  return true;
+}
+
+function clearActiveRuntime(sharedHome, expected) {
+  return clearRuntimeRecord(sharedHome, expected, readActiveRuntime, activeRuntimePath);
+}
+
+function clearPendingRuntime(sharedHome, expected) {
+  return clearRuntimeRecord(sharedHome, expected, readPendingRuntime, pendingRuntimePath);
+}
+
+function restoreActiveRuntime(sharedHome, runtime) {
+  if (runtime === null || runtime === undefined) {
+    fs.rmSync(activeRuntimePath(sharedHome), { force: true });
+    return;
+  }
+  activateRuntime(sharedHome, runtime);
+}
+
+function recordRunningUpdateEvent(sharedHome, event, options = {}) {
+  if (typeof sharedHome !== 'string' || !path.isAbsolute(sharedHome)) return false;
+  const updateRoot = path.join(path.resolve(sharedHome), 'updates');
+  ensurePrivateDirectory(path.resolve(sharedHome));
+  ensurePrivateDirectory(updateRoot);
+  const filePath = path.join(updateRoot, 'handoff.jsonl');
+  fs.appendFileSync(filePath, `${JSON.stringify({
+    at: new Date((options.now || Date.now)()).toISOString(),
+    ...event,
+  })}\n`, { encoding: 'utf8', mode: 0o600 });
+  securePrivateFile(filePath);
+  return true;
+}
+
 function registryRelease(registry, version) {
   const versions = ownData(registry, 'versions');
   const entry = ownData(versions, version);
@@ -469,22 +556,31 @@ async function prepareRunningUpdate(options) {
 
 module.exports = {
   ACTIVE_RUNTIME_FILE,
+  PENDING_RUNTIME_FILE,
   AUTO_UPDATE_SETTLE_MS,
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
+  RUNTIME_EXIT_INTENT_MESSAGE,
   RUNTIME_READY_MESSAGE,
   activateRuntime,
   activeRuntimePath,
+  clearActiveRuntime,
+  clearPendingRuntime,
   defaultProbeRuntime,
   handoffArgsForMode,
   handoffRuntime,
   isSafeRuntimeBoundary,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
+  recordRunningUpdateEvent,
   readActiveRuntime,
+  readPendingRuntime,
+  restoreActiveRuntime,
   resumeArgsForHandoff,
   selectRunningUpdateTarget,
+  stageRuntime,
+  pendingRuntimePath,
   verifyRuntimePackage,
 };

package/blun.mjs

@@ -78012,7 +78012,10 @@ function parseLoopInterval(rawInterval) {
 			cron: hours === 1 ? "0 * * * *" : `0 */${String(hours)} * * *`
 		};
 	}
-	throw invalidLoopInterval(rawInterval);
+	return {
+		interval: `${String(amount)}${unit}`,
+		cron: "* * * * *"
+	};
 }
 function invalidLoopInterval(rawInterval) {
 	return new BlunError(ErrorCodes.LOOP_INTERVAL_INVALID, `Invalid loop interval ${JSON.stringify(rawInterval)}`);
@@ -422400,9 +422403,14 @@ function parseLoopCommand(rawArgs) {
 	}
 	if (LOOP_CREATE_FILLERS.has(tokens[startIndex]?.toLowerCase() ?? "")) startIndex += 1;
 	const intervalToken = tokens[startIndex];
-	const interval = intervalToken === void 0 ? null : normalizeLoopIntervalToken(intervalToken);
+	let interval = intervalToken === void 0 ? null : normalizeLoopIntervalToken(intervalToken);
+	let intervalTokenCount = 1;
+	if (interval === null && /^\d+$/u.test(intervalToken ?? "") && tokens[startIndex + 1] !== void 0) {
+		interval = normalizeLoopIntervalToken(`${intervalToken}${tokens[startIndex + 1]}`);
+		if (interval !== null) intervalTokenCount = 2;
+	}
 	if (interval !== null) {
-		const prompt = tokens.slice(startIndex + 1).join(" ").trim();
+		const prompt = tokens.slice(startIndex + intervalTokenCount).join(" ").trim();
 		if (prompt.length === 0) return { kind: "error" };
 		return {
 			kind: "create",
@@ -515041,6 +515049,7 @@ const {
 	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
+	RUNTIME_EXIT_INTENT_MESSAGE,
 	RUNTIME_READY_MESSAGE,
 	isSafeRuntimeBoundary,
 	pruneRunningUpdateReleases
@@ -515066,17 +515075,6 @@ function notifyRunningRuntimeReady(tui) {
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
 	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
-	const waitMs = tui.runningUpdateNotBeforeMs - Date.now();
-	if (Number.isFinite(waitMs) && waitMs > 0) {
-		if (tui.runningUpdateDelayTimer === void 0) {
-			tui.runningUpdateDelayTimer = setTimeout(() => {
-				tui.runningUpdateDelayTimer = void 0;
-				requestRunningUpdateAtSafeBoundary(tui);
-			}, waitMs);
-			tui.runningUpdateDelayTimer.unref?.();
-		}
-		return false;
-	}
 	const boundaryState = () => ({
 		isShuttingDown: tui.isShuttingDown,
 		streamingPhase: tui.state.appState.streamingPhase,
@@ -515100,9 +515098,7 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 		}, (error) => {
 			if (error || !isSafeRuntimeBoundary(boundaryState())) {
 				tui.runningUpdateHandoffStarted = false;
-				return;
 			}
-			void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 		});
 	} catch {
 		tui.runningUpdateHandoffStarted = false;
@@ -515115,6 +515111,7 @@ function installRunningUpdateListener(tui) {
 		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 nächsten Start aktiviert.`, "success");
 		requestRunningUpdateAtSafeBoundary(tui);
 	};
 	process.on("message", handler);
@@ -515207,8 +515204,6 @@ var BlunTUI = class {
 	runningUpdatePreparedVersion;
 	runningUpdatePreparedMode;
 	runningUpdateHandoffStarted = false;
-	runningUpdateNotBeforeMs = Date.now() + AUTO_UPDATE_SETTLE_MS;
-	runningUpdateDelayTimer;
 	runningUpdateMessageDispose;
 	startupPhaseMs = {};
 	lastActivityMode;
@@ -515734,6 +515729,9 @@ var BlunTUI = class {
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
+		if (exitCode === 0 && process.connected) try {
+			process.send({ type: RUNTIME_EXIT_INTENT_MESSAGE });
+		} catch {}
 		this.unregisterSignalHandlers();
 		this.aborted = true;
 		this.channelQueueDeadline?.dispose();

package/package.json

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