blun-king-cli 9.1.392 → 9.1.394

package/bin/launcher-runtime.js

@@ -1,8 +1,10 @@
 'use strict';
+
 /*
- * BLUN CLI Launcher (npm) — Erststart richtet alles ein:
- *   1. King richtet das Telegram-Plugin im BLUN_HOME ein
- * Danach: TUI starten. Anmeldung und Modellkatalog kommen ueber BLUN OAuth.
+ * BLUN CLI launcher. It prepares the local profile and then starts the bundled
+ * core directly. Updates are offered only through the interactive startup
+ * picker; no background download or deferred activation runs here. A user-
+ * selected update may relaunch only an explicit `king -c` resume request.
  */
 const fs = require('node:fs');
 const path = require('node:path');
@@ -23,36 +25,12 @@ const {
   seedStandardSkills,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
-const { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE } = require('./core-bootstrap');
+const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
-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,
-  prepareRunningUpdate,
-  pruneRunningUpdateReleases,
-  recordRunningUpdateEvent,
-  readActiveRuntime,
-  readPendingRuntime,
-  restoreActiveRuntime,
-  clearPendingRuntime,
-  handoffArgsForMode,
-  stageRuntime,
-} = require('./running-update.cjs');
-const {
-  RUNNING_UPDATE_MODES,
-  normalizeRunningUpdateMode,
-  readRunningUpdateMode,
-} = require('./running-update-preference.cjs');
+const { acquireSharedRuntimeLease } = require('./update-lease');
+const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
   ensurePrivateDirectory,
   securePrivateFile,
@@ -69,40 +47,6 @@ const RAW_ARGS = process.argv.slice(2);
 const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.argv));
 const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
-const RUNNING_UPDATE_RESUME_SESSION_ENV = 'BLUN_RUNNING_UPDATE_RESUME_SESSION_ID';
-const RUNTIME_READY_TIMEOUT_MS = 60_000;
-const RUNNING_UPDATE_RECHECK_MS = 5 * 60_000;
-const RUNNING_UPDATE_RECHECK_JITTER_MS = 2 * 60_000;
-const RUNNING_UPDATE_ERROR_RETRY_MS = 10_000;
-const RUNNING_UPDATE_STABILIZATION_MS = 2 * 60 * 1000;
-
-function runningUpdateRecheckDelay(randomValue = Math.random()) {
-  const normalized = Number.isFinite(randomValue)
-    ? Math.min(Math.max(randomValue, 0), 0.999999999)
-    : 0;
-  return RUNNING_UPDATE_RECHECK_MS
-    + Math.floor(normalized * RUNNING_UPDATE_RECHECK_JITTER_MS);
-}
-
-function scheduleRunningUpdateRecheck(callback, options = {}) {
-  const timer = (options.setTimeoutImpl || setTimeout)(
-    callback,
-    options.delayMs ?? runningUpdateRecheckDelay((options.randomImpl || Math.random)()),
-  );
-  timer.unref?.();
-  return timer;
-}
-
-function runningUpdateFailureDetails(error) {
-  const safeField = (value, fallback) => typeof value === 'string'
-    && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/u.test(value)
-    ? value
-    : fallback;
-  return {
-    errorName: safeField(error?.name, 'Error'),
-    errorCode: safeField(error?.code, 'UNKNOWN'),
-  };
-}
 
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
@@ -209,10 +153,8 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
     },
   );
   let loadedSettled = false;
-  let readySettled = false;
   let completedSettled = false;
   let resolveLoaded;
-  let resolveReady;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
     try {
@@ -220,7 +162,6 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
     } catch {}
   }, CORE_LOAD_TIMEOUT_MS);
   const loaded = new Promise((resolve) => { resolveLoaded = resolve; });
-  const ready = new Promise((resolve) => { resolveReady = resolve; });
   const completed = new Promise((resolve) => { resolveCompleted = resolve; });
   const settleLoaded = (value) => {
     if (loadedSettled) return;
@@ -228,17 +169,11 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
     clearTimeout(loadTimer);
     resolveLoaded(value);
   };
-  const settleReady = (value) => {
-    if (readySettled) return;
-    readySettled = true;
-    resolveReady(value);
-  };
   const settleCompleted = (result) => {
     if (completedSettled) return;
     completedSettled = true;
     for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
     settleLoaded(false);
-    settleReady(false);
     resolveCompleted(result);
   };
   const signalHandlers = new Map();
@@ -253,416 +188,40 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
   }
   child.on('message', (message) => {
     if (message?.type === CORE_LOADED_MESSAGE) settleLoaded(true);
-    if (message?.type === RUNTIME_READY_MESSAGE) settleReady(true);
     options.onMessage?.(message, child);
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded, packageRoot, ready };
+  return { child, completed, loaded, packageRoot };
 }
 
-async function waitForRuntimeReady(core, timeoutMs = RUNTIME_READY_TIMEOUT_MS) {
-  let timer;
-  const timedOut = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(false), timeoutMs);
-    timer.unref?.();
-  });
-  try {
-    return await Promise.race([core.ready, timedOut]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function resolveHandoffCwd(candidate, fallback) {
-  if (typeof candidate !== 'string' || candidate.trim().length === 0 || !path.isAbsolute(candidate)) {
-    return fallback;
-  }
-  try {
-    return fs.statSync(candidate).isDirectory() ? path.resolve(candidate) : fallback;
-  } catch {
-    return fallback;
-  }
-}
-
-function isAutomaticRunningUpdateMode(mode) {
-  return mode === RUNNING_UPDATE_MODES.RESUME || mode === RUNNING_UPDATE_MODES.NEW;
-}
-
-function shouldLaunchPreparedRuntimeAutomatically(runtime, mode) {
-  return runtime !== undefined
-    && runtime !== null
-    && isAutomaticRunningUpdateMode(mode)
-    && runtime.mode === mode;
-}
-
-async function prepareAutomaticStartupRuntime(options) {
-  if (options.existingRuntime !== undefined) return options.existingRuntime;
-  const runningUpdateMode = readRunningUpdateMode(options.profileHome);
-  if (!isAutomaticRunningUpdateMode(runningUpdateMode)) return undefined;
-  const target = await (options.prepareRunningUpdate || prepareRunningUpdate)({
-    currentVersion: options.currentVersion,
-    sharedHome: options.sharedHome,
-    env: options.env,
-  });
-  if (target === null) return undefined;
-  (options.stageRuntime || stageRuntime)(options.sharedHome, target, {
-    mode: runningUpdateMode,
-    cwd: options.cwd,
-  });
-  (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(options.sharedHome, {
-    event: 'prepared-on-cold-start',
-    fromVersion: options.currentVersion,
-    toVersion: target.version,
-  });
-  return (options.readPendingRuntime || readPendingRuntime)(options.sharedHome)
-    || Object.freeze({ ...target, mode: runningUpdateMode, cwd: options.cwd });
+function exitCodeForChild(result, loaded) {
+  if (!loaded && result.code === 75) return 0;
+  if (Number.isInteger(result.code)) return result.code;
+  if (result.signal === 'SIGINT') return 130;
+  if (result.signal === 'SIGTERM') return 143;
+  return 1;
 }
 
-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;
+function shouldResumeAfterStartupUpdate(args, updateResult) {
+  return updateResult?.kind === 'installed'
+    && Array.isArray(args)
+    && args.length === 1
+    && args[0] === '-c';
 }
 
-async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
-  const packageRoot = path.resolve(options.packageRoot || PKG);
-  let preparedTarget;
-  let updateStarted = false;
-  let runtimeReady = options.initialRuntimeReady === true;
-  let activeSession = options.initialActiveSession;
-  let acceptedHandoff;
-  let runtimeExitIntent = false;
-  let supervisionCompleted = false;
-  let runningUpdatePollTimer;
-  let runningUpdateMode = readRunningUpdateMode(env.BLUN_HOME);
-  const automaticMode = () => runningUpdateMode === RUNNING_UPDATE_MODES.RESUME
-    || runningUpdateMode === RUNNING_UPDATE_MODES.NEW;
-  const refreshRunningUpdateMode = () => {
-    const persistedMode = readRunningUpdateMode(env.BLUN_HOME);
-    if (persistedMode !== runningUpdateMode) {
-      runningUpdateMode = persistedMode;
-    }
-  };
-  const clearRunningUpdatePoll = () => {
-    if (runningUpdatePollTimer === undefined) return;
-    (options.clearTimeoutImpl || clearTimeout)(runningUpdatePollTimer);
-    runningUpdatePollTimer = undefined;
-  };
-  const validSessionMessage = (message) => typeof message?.sessionId === 'string'
-    && message.sessionId.length > 0
-    && message.sessionId.length <= 256
-    && !/[\u0000-\u001f\u007f]/u.test(message.sessionId)
-    && resolveHandoffCwd(message.cwd, '') !== '';
-  const stagedRuntimeOptions = () => ({
-    mode: runningUpdateMode,
-    ...(runningUpdateMode === RUNNING_UPDATE_MODES.RESUME && activeSession !== undefined
-      ? { cwd: activeSession.cwd, sessionId: activeSession.sessionId }
-      : {}),
-  });
-  const persistPreparedRuntime = () => {
-    if (preparedTarget === undefined) return;
-    const sharedHome = env.BLUN_SHARED_HOME;
-    if (typeof sharedHome !== 'string' || sharedHome.length === 0) return;
-    (options.stageRuntime || stageRuntime)(sharedHome, preparedTarget, stagedRuntimeOptions());
-  };
-  const scheduleNextPreparation = (child, scheduleOptions = {}) => {
-    clearRunningUpdatePoll();
-    if (supervisionCompleted || updateStarted) return;
-    runningUpdatePollTimer = (options.scheduleRunningUpdateRecheck || scheduleRunningUpdateRecheck)(() => {
-      runningUpdatePollTimer = undefined;
-      refreshRunningUpdateMode();
-      if (automaticMode()) startPreparation(child);
-      else scheduleNextPreparation(child);
-    }, scheduleOptions);
-  };
-  const startPreparation = (child) => {
-    if (supervisionCompleted || updateStarted
-      || options.runningUpdate === false || !automaticMode()) return;
-    updateStarted = true;
-    const sharedHome = env.BLUN_SHARED_HOME;
-    if (typeof sharedHome !== 'string' || sharedHome.length === 0) {
-      updateStarted = false;
-      scheduleNextPreparation(child);
-      return;
-    }
-    Promise.resolve((options.prepareRunningUpdate || prepareRunningUpdate)({
-      currentVersion: JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8')).version,
-      sharedHome,
-      env,
-    })).then((target) => {
-      if (target === null) {
-        updateStarted = false;
-        scheduleNextPreparation(child);
-        return;
-      }
-      const previousTarget = preparedTarget;
-      if (previousTarget !== undefined
-        && compareSemver(target.version, previousTarget.version) !== 1) {
-        updateStarted = false;
-        scheduleNextPreparation(child);
-        return;
-      }
-      preparedTarget = target;
-      persistPreparedRuntime();
-      if (child?.connected === true) {
-        try {
-          child.send({
-            type: RUNNING_UPDATE_PREPARED_MESSAGE,
-            version: target.version,
-            mode: runningUpdateMode,
-          });
-        } catch {}
-      }
-      const runningVersion = readPackageVersionAt(packageRoot);
-      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, previousTarget === undefined ? {
-        event: 'prepared-for-next-start',
-        fromVersion: runningVersion,
-        toVersion: target.version,
-      } : {
-        event: 'prepared-target-refreshed',
-        fromVersion: previousTarget.version,
-        toVersion: target.version,
-        runningVersion,
-      }, { now: options.nowImpl });
-      Promise.resolve((options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(sharedHome, {
-        activePackageRoot: packageRoot,
-      })).catch((error) => options.onRunningUpdateError?.(error));
-      updateStarted = false;
-      scheduleNextPreparation(child);
-    }).catch((error) => {
-      updateStarted = false;
-      options.onRunningUpdateError?.(error);
-      try {
-        (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
-          event: 'prepare-failed',
-          runningVersion: readPackageVersionAt(packageRoot),
-          ...runningUpdateFailureDetails(error),
-        }, { now: options.nowImpl });
-      } catch (recordError) {
-        options.onRunningUpdateError?.(recordError);
-      }
-      scheduleNextPreparation(child, { delayMs: RUNNING_UPDATE_ERROR_RETRY_MS });
-    });
-  };
-  const handleCoreMessage = (message, child) => {
-    if (message?.type === RUNTIME_EXIT_INTENT_MESSAGE) runtimeExitIntent = true;
-    if (message?.type === RUNTIME_READY_MESSAGE) {
-      if (validSessionMessage(message)) {
-        activeSession = Object.freeze({
-          cwd: resolveHandoffCwd(message.cwd, cwd),
-          sessionId: message.sessionId,
-        });
-        try {
-          persistPreparedRuntime();
-        } catch (error) {
-          options.onRunningUpdateError?.(error);
-        }
-      }
-      runtimeReady = true;
-      refreshRunningUpdateMode();
-      if (automaticMode()) startPreparation(child);
-      else scheduleNextPreparation(child);
-    }
-    if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
-      runningUpdateMode = normalizeRunningUpdateMode(message.mode);
-      clearRunningUpdatePoll();
-      if (automaticMode()) {
-        if (runtimeReady && !updateStarted) startPreparation(child);
-      } else if (runtimeReady) scheduleNextPreparation(child);
-    }
-    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE) {
-      refreshRunningUpdateMode();
-      const requestedCwd = resolveHandoffCwd(message.cwd, '');
-      const requestMatches = preparedTarget !== undefined
-        && automaticMode()
-        && validSessionMessage(message)
-        && activeSession !== undefined
-        && message.version === preparedTarget.version
-        && message.mode === runningUpdateMode
-        && message.sessionId === activeSession.sessionId
-        && requestedCwd === activeSession.cwd;
-      if (!requestMatches) return;
-      acceptedHandoff = Object.freeze({
-        cwd: requestedCwd,
-        mode: runningUpdateMode,
-        sessionId: message.sessionId,
-        target: preparedTarget,
-      });
-      if (child?.connected === true) {
-        try {
-          child.send({
-            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-            version: preparedTarget.version,
-            mode: runningUpdateMode,
-            sessionId: message.sessionId,
-          });
-        } catch {}
-      }
-    }
-  };
+async function superviseProtectedCore(args, env, cwd, releaseLauncherLeases, options = {}) {
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
   const core = options.existingCore || spawnCore(args, env, cwd, {
-    packageRoot,
-    onMessage: handleCoreMessage,
+    packageRoot: options.packageRoot || PKG,
   });
-  let existingMessageHandler;
-  if (options.existingCore) {
-    existingMessageHandler = (message) => handleCoreMessage(message, core.child);
-    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
-    // the TUI's fully idle boundary.
-    runtimeReady = true;
-    refreshRunningUpdateMode();
-    if (automaticMode()) startPreparation(core.child);
-    else scheduleNextPreparation(core.child);
-  }
-  await releaseNotice();
+  if (loaded) await releaseLauncherLeases();
   const result = await core.completed;
-  supervisionCompleted = true;
-  clearRunningUpdatePoll();
-  if (existingMessageHandler) core.child.off('message', existingMessageHandler);
-  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE && acceptedHandoff !== undefined) {
-    const sharedHome = env.BLUN_SHARED_HOME;
-    const previousActiveRuntime = (options.readActiveRuntime || readActiveRuntime)(sharedHome);
-    const previousVersion = readPackageVersionAt(packageRoot);
-    const handoffArgs = handoffArgsForMode(args, acceptedHandoff.mode, acceptedHandoff.sessionId);
-    let targetSession;
-    const targetCore = spawnCore(handoffArgs, env, acceptedHandoff.cwd, {
-      packageRoot: acceptedHandoff.target.packageRoot,
-      onMessage(message) {
-        if (message?.type === RUNTIME_READY_MESSAGE && validSessionMessage(message)) {
-          targetSession = Object.freeze({
-            cwd: resolveHandoffCwd(message.cwd, acceptedHandoff.cwd),
-            sessionId: message.sessionId,
-          });
-        }
-      },
-    });
-    const targetLoaded = await targetCore.loaded;
-    const targetReady = targetLoaded
-      && await (options.waitForRuntimeReady || waitForRuntimeReady)(targetCore, options.readyTimeoutMs);
-    if (targetReady) {
-      await (options.activateRuntime || activateRuntime)(sharedHome, acceptedHandoff.target);
-      (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, acceptedHandoff.target);
-      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
-        event: 'activated-live-handoff',
-        fromVersion: previousVersion,
-        toVersion: acceptedHandoff.target.version,
-        mode: acceptedHandoff.mode,
-        sessionId: acceptedHandoff.sessionId,
-      }, { now: options.nowImpl });
-      return superviseProtectedCore(handoffArgs, env, acceptedHandoff.cwd, async () => {}, {
-        ...options,
-        existingCore: targetCore,
-        initialActiveSession: targetSession,
-        initialRuntimeReady: true,
-        packageRoot: acceptedHandoff.target.packageRoot,
-        startupPendingRuntime: undefined,
-        staleActiveRuntime: undefined,
-        recoveryRuntime: {
-          activeRuntime: previousActiveRuntime,
-          activatedAt: (options.nowImpl || Date.now)(),
-          packageRoot,
-          version: previousVersion,
-        },
-      });
-    }
-    try {
-      targetCore.child.kill();
-    } catch {}
-    await (options.restoreActiveRuntime || restoreActiveRuntime)(sharedHome, previousActiveRuntime);
-    (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, acceptedHandoff.target);
-    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
-      event: 'live-handoff-rolled-back',
-      failedVersion: acceptedHandoff.target.version,
-      recoveryVersion: previousVersion,
-    }, { now: options.nowImpl });
-    const fallback = spawnCore(handoffArgs, env, acceptedHandoff.cwd, { packageRoot });
-    const fallbackLoaded = await fallback.loaded;
-    const fallbackReady = fallbackLoaded
-      && await (options.waitForRuntimeReady || waitForRuntimeReady)(fallback, options.readyTimeoutMs);
-    if (fallbackReady) {
-      return superviseProtectedCore(handoffArgs, env, acceptedHandoff.cwd, async () => {}, {
-        ...options,
-        existingCore: fallback,
-        initialActiveSession: activeSession,
-        initialRuntimeReady: true,
-        packageRoot,
-        startupPendingRuntime: undefined,
-        staleActiveRuntime: undefined,
-        recoveryRuntime: undefined,
-      });
-    }
-    const fallbackResult = await fallback.completed;
-    if (fallbackResult.error) throw fallbackResult.error;
-    return exitCodeForChild(fallbackResult, fallbackLoaded);
-  }
-  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);
 }
 
-function exitCodeForChild(result, loaded) {
-  if (!loaded && result.code === 75) return 0;
-  if (Number.isInteger(result.code)) return result.code;
-  if (result.signal === 'SIGINT') return 130;
-  if (result.signal === 'SIGTERM') return 143;
-  return 1;
-}
-
 function installTelegramForProfile(packageRoot, blunDir) {
   installManagedTelegramPlugin({ packageRoot, blunDir });
   const channelsDir = path.join(blunDir, 'channels');
@@ -725,101 +284,22 @@ function spawnManagedLauncher(binary, cwd) {
   });
 }
 
-function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS, options = {}) {
-  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), ...args], {
-      cwd,
-      env: {
-        ...process.env,
-        BLUN_ACTIVE_RUNTIME_ROOT: packageRoot,
-        ...(typeof options.resumeSessionId === 'string' && options.resumeSessionId.length > 0
-          ? { [RUNNING_UPDATE_RESUME_SESSION_ENV]: options.resumeSessionId }
-          : {}),
-      },
-      stdio: 'inherit',
-      windowsHide: true,
-    });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (Number.isInteger(code)) resolve(code);
-      else if (signal === 'SIGINT') resolve(130);
-      else if (signal === 'SIGTERM') resolve(143);
-      else resolve(1);
-    });
-  });
-}
-
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
-  let startupPendingRuntime;
-  let deferredPendingRuntime;
-  let staleActiveRuntime;
-  if (options.skipActiveRuntime !== true) {
-    const activeHome = resolveLauncherPrivatePaths().sharedHome;
-    const pendingRuntime = readPendingRuntime(activeHome);
-    const activeRuntime = readActiveRuntime(activeHome);
-    const currentVersion = readPackageVersion();
-    if (pendingRuntime !== null
-      && path.resolve(pendingRuntime.packageRoot) !== PKG
-      && compareSemver(currentVersion, pendingRuntime.version) === -1) {
-      deferredPendingRuntime = pendingRuntime;
-    }
-    if (pendingRuntime !== null && path.resolve(pendingRuntime.packageRoot) === PKG) {
-      startupPendingRuntime = pendingRuntime;
-    }
-    if (startupPendingRuntime === undefined && deferredPendingRuntime === 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);
   const explicitToolsRequest = String(ARGS[0] || '').toLowerCase() === 'tools';
-  const noticeResult = options.skipUpdateNotice === true
-    ? { acquired: true, lease: { assertOwned() {}, async release() {} } }
-    : options.noticeLease
-    ? { acquired: true, lease: options.noticeLease }
-    : await tryAcquireUpdateLease({ packageRoot: PKG, role: 'notice' });
-  if (!noticeResult.acquired) {
-    if (explicitUpdateRequest) {
-      process.stderr.write('Das Update konnte nicht verifiziert werden.\n');
-      process.exitCode = 1;
-    }
-    return;
-  }
-  const noticeLease = noticeResult.lease;
+  const launcherLease = options.noticeLease;
   let runtimeLease = options.runtimeLease;
-  let noticeReleased = false;
-  const releaseNotice = async () => {
-    if (noticeReleased) return;
-    noticeReleased = true;
-    await noticeLease.release();
+  let leasesReleased = false;
+  const releaseLauncherLeases = async () => {
+    if (leasesReleased) return;
+    leasesReleased = true;
+    await launcherLease?.release();
     await runtimeLease?.release();
   };
 
   try {
-    if (!runtimeLease && !explicitUpdateRequest) {
-      const installProbe = await tryAcquireUpdateLease({ packageRoot: PKG, role: 'install' });
-      if (!installProbe.acquired) {
-        process.stderr.write(explicitUpdateRequest
-          ? 'Das Update konnte nicht verifiziert werden.\n'
-          : 'Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
-        process.exitCode = 1;
-        return;
-      }
-      await installProbe.lease.release();
-    }
-
     if (explicitToolsRequest) {
       const action = String(ARGS[1] || '').toLowerCase();
       const available = availableStandardToolNames({ packageRoot: PKG });
@@ -855,28 +335,12 @@ async function runLauncher(options = {}) {
       process.exitCode = 1;
       return;
     }
+
     if (ARGS.some((arg) => arg === '--version' || arg === '-V')) {
       process.stdout.write(`${readPackageVersion()}\n`);
       return;
     }
 
-    if (explicitUpdateRequest) {
-      const privatePaths = resolveLauncherPrivatePaths();
-      const result = await runExplicitUpdate({
-        currentVersion: readPackageVersion(),
-        env: process.env,
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-        blunDir: privatePaths.sharedHome,
-        packageRoot: PKG,
-        noticeLease,
-        request: ARGS[0],
-      });
-      if (result.kind === 'failed') process.exitCode = result.exitCode || 1;
-      return;
-    }
-
     let privatePathsCache;
     const getPrivatePaths = () => {
       privatePathsCache ||= resolveLauncherPrivatePaths();
@@ -892,11 +356,28 @@ async function runLauncher(options = {}) {
     }
     if (nodeRuntime.kind === 'managed') {
       process.stdout.write('BLUN hat die passende Node.js-Laufzeit eingerichtet.\n');
-      await releaseNotice();
+      await releaseLauncherLeases();
       process.exitCode = await spawnManagedLauncher(nodeRuntime.binary, callerCwd);
       return;
     }
 
+    if (explicitUpdateRequest) {
+      const privatePaths = getPrivatePaths();
+      ensurePrivateDirectory(privatePaths.sharedHome);
+      const result = await runExplicitUpdate({
+        currentVersion: readPackageVersion(),
+        env: process.env,
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        blunDir: privatePaths.sharedHome,
+        packageRoot: PKG,
+        noticeLease: launcherLease,
+      });
+      if (result.kind === 'failed') process.exitCode = result.exitCode || 1;
+      return;
+    }
+
     if (ARGS.some((arg) => arg === '--help' || arg === '-h')) {
       process.stdout.write(launcherHelpText());
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
@@ -904,12 +385,25 @@ async function runLauncher(options = {}) {
       delete informationalEnv.BLUN_HOME;
       delete informationalEnv.BLUN_SHARED_HOME;
       const privatePaths = resolveLauncherPrivatePaths({ env: informationalEnv });
-      const profilePaths = privatePaths.profilePaths;
-      env.BLUN_HOME = profilePaths.home;
+      env.BLUN_HOME = privatePaths.profilePaths.home;
       env.BLUN_SHARED_HOME = privatePaths.sharedHome;
       env.BLUN_LOG_HOME = privatePaths.sharedHome;
       env.BLUN_PROFILE = PROFILE.profileName;
-      process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
+      if (!runtimeLease) {
+        const runtimeResult = await acquireSharedRuntimeLease({ packageRoot: PKG });
+        if (!runtimeResult.acquired) {
+          process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+          process.exitCode = 1;
+          return;
+        }
+        runtimeLease = runtimeResult.lease;
+      }
+      process.exitCode = await superviseProtectedCore(
+        ARGS,
+        env,
+        callerCwd,
+        releaseLauncherLeases,
+      );
       return;
     }
 
@@ -922,68 +416,20 @@ async function runLauncher(options = {}) {
     const blunDir = profilePaths.home;
     ensurePrivateDirectory(blunDir);
 
-    const runningUpdateMode = readRunningUpdateMode(profilePaths.home);
-    if (deferredPendingRuntime === undefined && isAutomaticRunningUpdateMode(runningUpdateMode)) {
-      try {
-        deferredPendingRuntime = await prepareAutomaticStartupRuntime({
-          currentVersion: readPackageVersion(),
-          cwd: callerCwd,
-          env: process.env,
-          profileHome: profilePaths.home,
-          sharedHome: privatePaths.sharedHome,
-        });
-      } catch {}
-    }
-
-    if (shouldLaunchPreparedRuntimeAutomatically(deferredPendingRuntime, runningUpdateMode)) {
-      const pendingArgs = deferredPendingRuntime.mode === RUNNING_UPDATE_MODES.RESUME
-        && deferredPendingRuntime.sessionId !== undefined
-        ? handoffArgsForMode(RAW_ARGS, deferredPendingRuntime.mode, deferredPendingRuntime.sessionId)
-        : RAW_ARGS;
-      await releaseNotice();
-      process.exitCode = await spawnActiveLauncher(
-        deferredPendingRuntime.packageRoot,
-        deferredPendingRuntime.cwd || callerCwd,
-        pendingArgs,
-        deferredPendingRuntime.mode === RUNNING_UPDATE_MODES.RESUME
-          ? { resumeSessionId: deferredPendingRuntime.sessionId }
-          : {},
-      );
-      return;
-    }
-
-    // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
-    const updateResult = options.skipUpdateNotice === true
-      ? { kind: 'continue', reason: 'notice_busy' }
-      : await runUpdateNotice({
-        currentVersion: readPackageVersion(),
-        argv: ARGS,
-        env: process.env,
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-        blunDir: privatePaths.sharedHome,
-        packageRoot: PKG,
-        preparedRuntime: deferredPendingRuntime,
-        autoInstallPreparedRuntime: isAutomaticRunningUpdateMode(runningUpdateMode),
-        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,
-        deferredPendingRuntime.mode === RUNNING_UPDATE_MODES.RESUME
-          ? { resumeSessionId: deferredPendingRuntime.sessionId }
-          : {},
-      );
+    const updateResult = await runUpdateNotice({
+      currentVersion: readPackageVersion(),
+      argv: ARGS,
+      env: process.env,
+      stdin: process.stdin,
+      stdout: process.stdout,
+      stderr: process.stderr,
+      blunDir: privatePaths.sharedHome,
+      packageRoot: PKG,
+      noticeLease: launcherLease,
+    });
+    if (shouldResumeAfterStartupUpdate(ARGS, updateResult)) {
+      await releaseLauncherLeases();
+      process.exitCode = await spawnManagedLauncher(process.execPath, callerCwd);
       return;
     }
     if (updateResult.kind === 'installed' || updateResult.kind === 'update_in_progress') return;
@@ -998,13 +444,9 @@ async function runLauncher(options = {}) {
       runtimeLease = runtimeResult.lease;
     }
 
-  // --- 2. Bestehende Konfiguration absichern -------------------------------
-  // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
-  // provisioniert King ueber den BLUN-OAuth-Server.
     const cfgFile = path.join(blunDir, 'config.toml');
     if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
 
-    // --- 3. BLUN-Standard-MCPs additiv im Benutzerprofil einrichten ---------
     const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
       .filter((name) => name !== 'telegram');
     seedStandardTools({
@@ -1013,14 +455,8 @@ async function runLauncher(options = {}) {
       names: standardMcpNames,
     });
     seedConfiguredMnemoMcp({ blunDir, env: process.env });
-
-  // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
     seedStandardSkills({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
-
-    // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
-    if (mode === LAUNCHER_MODES.KING) {
-      installTelegramForProfile(PKG, blunDir);
-    }
+    if (mode === LAUNCHER_MODES.KING) installTelegramForProfile(PKG, blunDir);
 
     const nativeModules = repairConfiguredNativeModules({
       blunDir,
@@ -1033,7 +469,6 @@ async function runLauncher(options = {}) {
       process.stdout.write('Native Node.js-Module sind wieder einsatzbereit.\n');
     }
 
-    // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
     env.BLUN_HOME = profilePaths.home;
     env.BLUN_SHARED_HOME = privatePaths.sharedHome;
@@ -1051,31 +486,21 @@ async function runLauncher(options = {}) {
         ARGS,
         env,
         callerCwd,
-        releaseNotice,
-        { startupPendingRuntime, staleActiveRuntime },
+        releaseLauncherLeases,
       );
     } finally {
       await mnemoConnect.stop();
     }
   } finally {
-    await releaseNotice();
+    await releaseLauncherLeases();
   }
 }
 
 module.exports = {
-  RUNNING_UPDATE_ERROR_RETRY_MS,
-  RUNNING_UPDATE_RECHECK_JITTER_MS,
-  RUNNING_UPDATE_RECHECK_MS,
-  RUNNING_UPDATE_STABILIZATION_MS,
   createManagedNodeEnvironment,
-  prepareAutomaticStartupRuntime,
   resolveLauncherPrivatePaths,
-  resolveHandoffCwd,
-  runningUpdateRecheckDelay,
   runLauncher,
-  scheduleRunningUpdateRecheck,
-  shouldLaunchPreparedRuntimeAutomatically,
-  shouldRecoverActivatedRuntime,
+  shouldResumeAfterStartupUpdate,
   shouldDetachProtectedCore,
   spawnManagedLauncher,
   superviseProtectedCore,