blun-king-cli 9.1.587 → 9.1.588

package/bin/launcher-runtime.js

@@ -1,10 +1,8 @@
 'use strict';
-
 /*
- * 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.
+ * 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.
  */
 const fs = require('node:fs');
 const path = require('node:path');
@@ -13,53 +11,29 @@ const { spawn } = require('node:child_process');
 const {
   LAUNCHER_MODES,
   createLauncherEnvironment,
-  createProtectedCoreEnvironment,
   isNpmPackageUpdateRequest,
   launcherHelpText,
   launcherModeFromArgv,
 } = require('./launcher-mode');
-const {
-  installManagedAgentSpinePlugin,
-  installManagedTelegramPlugin,
-} = require('./plugin-bootstrap');
+const { installManagedTelegramPlugin, installManagedAgentSpinePlugin } = require('./plugin-bootstrap');
 const {
   availableStandardToolNames,
-  seedStandardSkills,
+  seedStandardDesignSkill,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
 const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
-const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
-const {
-  appendLauncherStatus,
-  claimLauncherRestart,
-  consumeIntentionalStopMarker,
-  isAbnormalCoreExit,
-  restartDelayMs,
-} = require('./launcher-restart-policy.cjs');
-const { acquireSharedRuntimeLease } = require('./update-lease');
+const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
   ensurePrivateDirectory,
   securePrivateFile,
   writePrivateFile,
 } = require('./private-paths');
-const {
-  parseProfileLaunchArgs,
-  resolveProfilePaths,
-  seedDefaultProfileFromLegacy,
-} = require('./profile-runtime.cjs');
-const {
-  migrateLegacyStartupPreferences,
-  readStartupPreferences,
-  resolveStartupUiLocale,
-} = require('./startup-preferences.cjs');
 
 const PKG = path.resolve(__dirname, '..');
-const RAW_ARGS = process.argv.slice(2);
-const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.argv));
-const ARGS = PROFILE.args;
+const ARGS = process.argv.slice(2);
 const CORE_LOAD_TIMEOUT_MS = 30_000;
 
 function normalizeWindowsPath(value) {
@@ -70,24 +44,10 @@ function resolveLauncherPrivatePaths(options = {}) {
   const env = options.env || process.env;
   const platform = options.platform || process.platform;
   const configuredHome = String(env.BLUN_HOME || '').trim();
-  const configuredSharedHome = String(env.BLUN_SHARED_HOME || '').trim();
-  const profileName = options.profileName || PROFILE.profileName;
   if (platform !== 'win32') {
     const userHome = (options.homedir || os.homedir)();
-    const sharedHome = configuredSharedHome
-      ? path.resolve(configuredSharedHome)
-      : configuredHome
-      ? path.resolve(configuredHome)
-      : path.join(userHome, '.blun');
-    const profilePaths = resolveProfilePaths(sharedHome, profileName);
-    if (configuredSharedHome && configuredHome
-      && path.resolve(configuredHome) !== path.resolve(profilePaths.home)) {
-      throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
-    }
     return {
-      blunHome: profilePaths.home,
-      profilePaths,
-      sharedHome,
+      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
       userHome,
     };
   }
@@ -111,40 +71,22 @@ function resolveLauncherPrivatePaths(options = {}) {
     throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
   }
 
-  const sharedHome = path.win32.join(userHome, '.blun');
-  const profilePaths = resolveProfilePaths(sharedHome, profileName, path.win32);
-  if (configuredSharedHome
-    && normalizeWindowsPath(path.win32.resolve(configuredSharedHome)) !== normalizeWindowsPath(sharedHome)) {
-    throw new Error(`BLUN_SHARED_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${sharedHome}`);
-  }
-  const configuredHomeIsLegacyShared = !configuredSharedHome
-    && configuredHome
-    && normalizeWindowsPath(path.win32.resolve(configuredHome)) === normalizeWindowsPath(sharedHome);
+  const blunHome = path.win32.join(userHome, '.blun');
   if (configuredHome
-    && !configuredHomeIsLegacyShared
-    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(profilePaths.home)) {
-    throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
+    throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
   }
-  return {
-    blunHome: profilePaths.home,
-    profilePaths,
-    sharedHome,
-    userHome,
-  };
+  return { blunHome, userHome };
 }
 
-function readPackageVersionAt(packageRoot = PKG) {
-  const { version } = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+function readPackageVersion() {
+  const { version } = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf8'));
   if (typeof version !== 'string' || version.length === 0) {
     throw new Error('Ungueltige Paketversion in package.json');
   }
   return version;
 }
 
-function readPackageVersion() {
-  return readPackageVersionAt(PKG);
-}
-
 function shouldDetachProtectedCore(options = {}) {
   const platform = options.platform || process.platform;
   const stdinIsTTY = Object.hasOwn(options, 'stdinIsTTY')
@@ -153,15 +95,14 @@ function shouldDetachProtectedCore(options = {}) {
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd, options = {}) {
-  const packageRoot = path.resolve(options.packageRoot || PKG);
+function spawnProtectedCore(args, env, cwd) {
   const child = spawn(
     process.execPath,
-    [path.join(packageRoot, 'bin', 'core-bootstrap.js'), ...args],
+    [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
     {
       cwd,
       detached: shouldDetachProtectedCore(),
-      env: createProtectedCoreEnvironment(env),
+      env,
       stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
       windowsHide: true,
     },
@@ -201,12 +142,24 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
     process.once(signal, handler);
   }
   child.on('message', (message) => {
-    if (message?.type === CORE_LOADED_MESSAGE) settleLoaded(true);
-    options.onMessage?.(message, child);
+    if (message?.type !== CORE_LOADED_MESSAGE) return;
+    settleLoaded(true);
+    try {
+      child.disconnect();
+    } catch {}
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded, packageRoot };
+  return { child, completed, loaded };
+}
+
+async function superviseProtectedCore(args, env, cwd, releaseNotice) {
+  const core = spawnProtectedCore(args, env, cwd);
+  const loaded = await core.loaded;
+  await releaseNotice();
+  const result = await core.completed;
+  if (result.error) throw result.error;
+  return exitCodeForChild(result, loaded);
 }
 
 function exitCodeForChild(result, loaded) {
@@ -217,83 +170,6 @@ function exitCodeForChild(result, loaded) {
   return 1;
 }
 
-function shouldResumeAfterStartupUpdate(args, updateResult) {
-  return updateResult?.kind === 'installed'
-    && Array.isArray(args)
-    && args.length === 1
-    && args[0] === '-c';
-}
-
-function clearStartupUpdateViewport(output = process.stdout) {
-  if (output?.isTTY !== true || typeof output.write !== 'function') return false;
-  output.write('\u001B[2J\u001B[H');
-  return true;
-}
-
-async function superviseProtectedCore(args, env, cwd, releaseLauncherLeases, options = {}) {
-  const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
-  const waitBeforeRestart = options.waitBeforeRestart
-    || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
-  const now = options.now || Date.now;
-  let core = options.existingCore || spawnCore(args, env, cwd, {
-    packageRoot: options.packageRoot || PKG,
-  });
-  let leasesReleased = false;
-  for (;;) {
-    const loaded = await core.loaded;
-    if (loaded && !leasesReleased) {
-      leasesReleased = true;
-      await releaseLauncherLeases();
-    }
-    const result = await core.completed;
-    const exitCode = result.error ? 1 : exitCodeForChild(result, loaded);
-    const intentionalStop = (options.consumeIntentionalStopMarker || consumeIntentionalStopMarker)({
-      homeDir: env.BLUN_HOME,
-      childPid: core.child?.pid,
-      nowMs: now(),
-    });
-    recordRuntimeExit({
-      homeDir: env.BLUN_HOME,
-      source: 'launcher',
-      kind: result.error ? 'child-error' : 'child-exit',
-      exitCode,
-      signal: result.signal,
-      phase: loaded ? 'runtime' : 'startup',
-      cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION,
-      profile: env.BLUN_PROFILE,
-      loaded,
-      childPid: core.child?.pid,
-      ...(result.error ? { error: result.error } : {}),
-    });
-    if (intentionalStop || !isAbnormalCoreExit(result, loaded)) {
-      if (result.error) throw result.error;
-      return exitCode;
-    }
-    const claim = (options.claimLauncherRestart || claimLauncherRestart)({
-      homeDir: env.BLUN_HOME,
-      nowMs: now(),
-    });
-    const status = {
-      homeDir: env.BLUN_HOME,
-      stateDir: env.BLUN_TELEGRAM_STATE_DIR
-        || path.join(env.BLUN_SHARED_HOME || env.BLUN_HOME, 'channels', 'telegram'),
-      nowMs: now(),
-      attempt: claim.attempt,
-      limit: claim.limit,
-      exitCode,
-      signal: result.signal,
-      kind: claim.allowed ? 'launcher-restart' : 'launcher-restart-exhausted',
-    };
-    try { (options.appendLauncherStatus || appendLauncherStatus)(status); } catch {}
-    if (!claim.allowed) {
-      if (result.error) throw result.error;
-      return exitCode;
-    }
-    await waitBeforeRestart(restartDelayMs(claim.attempt));
-    core = spawnCore(args, env, cwd, { packageRoot: options.packageRoot || PKG });
-  }
-}
-
 function installTelegramForProfile(packageRoot, blunDir) {
   installManagedTelegramPlugin({ packageRoot, blunDir });
   const channelsDir = path.join(blunDir, 'channels');
@@ -308,45 +184,11 @@ function installTelegramForProfile(packageRoot, blunDir) {
   }
 }
 
-function installAgentSpineForProfile(packageRoot, blunDir) {
-  installManagedAgentSpinePlugin({ packageRoot, blunDir });
-}
-
-function installAgentSpineForExistingProfiles(packageRoot, _sharedHome, currentProfileHome) {
-  // A dormant profile is verified when that profile is launched. Rescanning all
-  // profiles here makes every startup slower as old profiles accumulate.
-  const profileHome = path.resolve(currentProfileHome);
-  ensurePrivateDirectory(profileHome);
-  installAgentSpineForProfile(packageRoot, profileHome);
-  return [profileHome];
-}
-
-function createManagedNodeEnvironment(binary, env = process.env, platform = process.platform) {
-  const pathImpl = platform === 'win32' ? path.win32 : path.posix;
-  const separator = platform === 'win32' ? path.win32.delimiter : path.posix.delimiter;
-  const pathKeys = Object.keys(env).filter((key) => key.toLowerCase() === 'path');
-  const targetKey = pathKeys[0] || (platform === 'win32' ? 'Path' : 'PATH');
-  const managedDirectory = pathImpl.dirname(pathImpl.resolve(binary));
-  const normalize = (value) => {
-    const resolved = pathImpl.normalize(value);
-    return platform === 'win32' ? resolved.toLowerCase() : resolved;
-  };
-  const managedIdentity = normalize(managedDirectory);
-  const existing = pathKeys.flatMap((key) => String(env[key] || '').split(separator))
-    .map((entry) => entry.trim())
-    .filter(Boolean)
-    .filter((entry) => normalize(entry) !== managedIdentity);
-  const result = { ...env };
-  for (const key of pathKeys) delete result[key];
-  result[targetKey] = [managedDirectory, ...existing].join(separator);
-  return result;
-}
-
 function spawnManagedLauncher(binary, cwd) {
   return new Promise((resolve, reject) => {
     const child = spawn(binary, process.argv.slice(1), {
       cwd,
-      env: createManagedNodeEnvironment(binary, process.env, process.platform),
+      env: process.env,
       stdio: 'inherit',
       windowsHide: true,
     });
@@ -374,17 +216,41 @@ async function runLauncher(options = {}) {
   const mode = options.mode || launcherModeFromArgv(process.argv);
   const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
   const explicitToolsRequest = String(ARGS[0] || '').toLowerCase() === 'tools';
-  const launcherLease = options.noticeLease;
+  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;
   let runtimeLease = options.runtimeLease;
-  let leasesReleased = false;
-  const releaseLauncherLeases = async () => {
-    if (leasesReleased) return;
-    leasesReleased = true;
-    await launcherLease?.release();
+  let noticeReleased = false;
+  const releaseNotice = async () => {
+    if (noticeReleased) return;
+    noticeReleased = true;
+    await noticeLease.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 });
@@ -405,13 +271,12 @@ async function runLauncher(options = {}) {
         if (mcpNames.length > 0) {
           seedStandardTools({
             packageRoot: PKG,
-            blunDir: privatePaths.profilePaths.home,
+            blunDir: privatePaths.blunHome,
             names: mcpNames,
-            forceEnable: true,
           });
         }
         if (selected.includes('telegram')) {
-          installTelegramForProfile(PKG, privatePaths.profilePaths.home);
+          installTelegramForProfile(PKG, privatePaths.blunHome);
         }
         process.stdout.write(`${selected.join('\n')}\n`);
         return;
@@ -420,19 +285,35 @@ async function runLauncher(options = {}) {
       process.exitCode = 1;
       return;
     }
-
     if (ARGS.some((arg) => arg === '--version' || arg === '-V')) {
       process.stdout.write(`${readPackageVersion()}\n`);
       return;
     }
 
-    let privatePathsCache;
+    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.blunHome,
+        packageRoot: PKG,
+        noticeLease,
+        request: ARGS[0],
+      });
+      if (result.kind === 'failed') process.exitCode = result.exitCode || 1;
+      return;
+    }
+
+    let privatePaths;
     const getPrivatePaths = () => {
-      privatePathsCache ||= resolveLauncherPrivatePaths();
-      return privatePathsCache;
+      privatePaths ||= resolveLauncherPrivatePaths();
+      return privatePaths;
     };
     const nodeRuntime = await prepareManagedNodeRuntime({
-      getBlunDir: () => getPrivatePaths().sharedHome,
+      getBlunDir: () => getPrivatePaths().blunHome,
     });
     if (nodeRuntime.kind === 'failed') {
       process.stderr.write(`${nodeRuntime.message}\n`);
@@ -441,91 +322,38 @@ async function runLauncher(options = {}) {
     }
     if (nodeRuntime.kind === 'managed') {
       process.stdout.write('BLUN hat die passende Node.js-Laufzeit eingerichtet.\n');
-      await releaseLauncherLeases();
+      await releaseNotice();
       process.exitCode = await spawnManagedLauncher(nodeRuntime.binary, callerCwd);
       return;
     }
 
-    if (explicitUpdateRequest) {
-      const privatePaths = getPrivatePaths();
-      ensurePrivateDirectory(privatePaths.sharedHome);
-      ensurePrivateDirectory(privatePaths.profilePaths.home);
-      migrateLegacyStartupPreferences(privatePaths.profilePaths.home);
-      const startupPreferences = readStartupPreferences(privatePaths.profilePaths.home);
-      const result = await runExplicitUpdate({
-        currentVersion: readPackageVersion(),
-        env: process.env,
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-        blunDir: privatePaths.sharedHome,
-        uiLocale: resolveStartupUiLocale(startupPreferences.uiLocale, process.env),
-        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());
       const informationalEnv = { ...process.env };
       delete informationalEnv.BLUN_HOME;
-      delete informationalEnv.BLUN_SHARED_HOME;
-      const privatePaths = resolveLauncherPrivatePaths({ env: informationalEnv });
-      env.BLUN_HOME = privatePaths.profilePaths.home;
-      env.BLUN_SHARED_HOME = privatePaths.sharedHome;
-      env.BLUN_LOG_HOME = privatePaths.sharedHome;
-      env.BLUN_PROFILE = PROFILE.profileName;
-      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,
-      );
+      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    const privatePaths = getPrivatePaths();
-    const profilePaths = privatePaths.profilePaths;
-    ensurePrivateDirectory(privatePaths.sharedHome);
-    if (PROFILE.profileName === 'default') {
-      seedDefaultProfileFromLegacy(privatePaths.sharedHome);
-    }
-    const blunDir = profilePaths.home;
+    const blunDir = getPrivatePaths().blunHome;
     ensurePrivateDirectory(blunDir);
-    migrateLegacyStartupPreferences(blunDir);
-    const startupPreferences = readStartupPreferences(blunDir);
 
-    const updateResult = await runUpdateNotice({
-      currentVersion: readPackageVersion(),
-      argv: ARGS,
-      env: process.env,
-      stdin: process.stdin,
-      stdout: process.stdout,
-      stderr: process.stderr,
-      blunDir: privatePaths.sharedHome,
-      autoInstall: startupPreferences.autoInstall,
-      uiLocale: resolveStartupUiLocale(startupPreferences.uiLocale, process.env),
-      packageRoot: PKG,
-      noticeLease: launcherLease,
-    });
-    if (shouldResumeAfterStartupUpdate(ARGS, updateResult)) {
-      await releaseLauncherLeases();
-      clearStartupUpdateViewport(process.stdout);
-      process.exitCode = await spawnManagedLauncher(process.execPath, callerCwd);
-      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,
+        packageRoot: PKG,
+        noticeLease,
+      });
     if (updateResult.kind === 'installed' || updateResult.kind === 'update_in_progress') return;
 
     if (!runtimeLease) {
@@ -538,9 +366,14 @@ 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);
+    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
 
+    // --- 3. BLUN-Standard-MCPs additiv im Benutzerprofil einrichten ---------
     const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
       .filter((name) => name !== 'telegram');
     seedStandardTools({
@@ -548,9 +381,15 @@ async function runLauncher(options = {}) {
       blunDir,
       names: standardMcpNames,
     });
-    seedStandardSkills({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
-    installAgentSpineForExistingProfiles(PKG, privatePaths.sharedHome, blunDir);
-    if (mode === LAUNCHER_MODES.KING) installTelegramForProfile(PKG, blunDir);
+
+  // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
+    seedStandardDesignSkill({ packageRoot: PKG, blunDir });
+    installManagedAgentSpinePlugin({ packageRoot: PKG, blunDir });
+
+    // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
+    if (mode === LAUNCHER_MODES.KING) {
+      installTelegramForProfile(PKG, blunDir);
+    }
 
     const nativeModules = repairConfiguredNativeModules({
       blunDir,
@@ -563,30 +402,24 @@ 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;
-    env.BLUN_LOG_HOME = privatePaths.sharedHome;
-    env.BLUN_PROFILE = PROFILE.profileName;
-          process.exitCode = await superviseProtectedCore(
-        ARGS,
-        env,
-        callerCwd,
-        releaseLauncherLeases,
-      );
+    env.BLUN_HOME = blunDir;
+    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
+    process.exitCode = await superviseProtectedCore(
+      ARGS,
+      env,
+      callerCwd,
+      releaseNotice,
+    );
   } finally {
-    await releaseLauncherLeases();
+    await releaseNotice();
   }
 }
 
 module.exports = {
-  clearStartupUpdateViewport,
-  createManagedNodeEnvironment,
-  installAgentSpineForExistingProfiles,
   resolveLauncherPrivatePaths,
   runLauncher,
-  shouldResumeAfterStartupUpdate,
   shouldDetachProtectedCore,
   spawnManagedLauncher,
-  superviseProtectedCore,
 };

package/bin/managed-plugin-selection.cjs

@@ -89,7 +89,6 @@ function copySelectedAgentSpinePlugin({ blunDir, sourceRoot }) {
   const managed = path.join(plugins, 'managed');
   ensurePrivateDirectory(plugins);
   ensurePrivateDirectory(managed);
-  // Explicit installs must see current source bytes, not the bundled-source cache.
   const digest = digestPluginEntries(snapshotPluginTree(sourceRoot));
   const pluginRoot = path.join(managed, `agent-spine-${digest}`);
   if (fs.existsSync(pluginRoot)) {