blun-king-cli 9.1.60 → 9.1.61

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.59
+  npm install -g blun-king-cli@9.1.61
 
 Start
 -----

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.59
+npm install -g blun-king-cli@9.1.61
 ```
 
 ## Reproduzierbares Staging und Packen

package/bin/core-bootstrap.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
 const { acquireSharedRuntimeLease } = require('./update-lease');
+const { RUNTIME_READY_MESSAGE } = require('./running-update.cjs');
 
 const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
 
@@ -31,11 +32,7 @@ async function runCoreBootstrap() {
 
   if (process.connected) {
     try {
-      process.send({ type: CORE_LOADED_MESSAGE }, () => {
-        try {
-          process.disconnect();
-        } catch {}
-      });
+      process.send({ type: CORE_LOADED_MESSAGE });
     } catch {}
   }
 }
@@ -49,4 +46,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { CORE_LOADED_MESSAGE, runCoreBootstrap };
+module.exports = { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE, runCoreBootstrap };

package/bin/launcher-runtime.js

@@ -21,11 +21,21 @@ const {
   seedStandardDesignSkill,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
-const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
+const { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
-const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
+const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
+const {
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
+  RUNNING_UPDATE_PREPARED_MESSAGE,
+  activateRuntime,
+  handoffRuntime,
+  prepareRunningUpdate,
+  readActiveRuntime,
+  resumeArgsForHandoff,
+} = require('./running-update.cjs');
 const {
   ensurePrivateDirectory,
   securePrivateFile,
@@ -42,6 +52,7 @@ 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 RUNTIME_READY_TIMEOUT_MS = 60_000;
 
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
@@ -130,10 +141,11 @@ function shouldDetachProtectedCore(options = {}) {
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd) {
+function spawnProtectedCore(args, env, cwd, options = {}) {
+  const packageRoot = path.resolve(options.packageRoot || PKG);
   const child = spawn(
     process.execPath,
-    [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
+    [path.join(packageRoot, 'bin', 'core-bootstrap.js'), ...args],
     {
       cwd,
       detached: shouldDetachProtectedCore(),
@@ -143,8 +155,10 @@ function spawnProtectedCore(args, env, cwd) {
     },
   );
   let loadedSettled = false;
+  let readySettled = false;
   let completedSettled = false;
   let resolveLoaded;
+  let resolveReady;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
     try {
@@ -152,6 +166,7 @@ function spawnProtectedCore(args, env, cwd) {
     } 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;
@@ -159,11 +174,17 @@ function spawnProtectedCore(args, env, cwd) {
     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();
@@ -177,23 +198,93 @@ function spawnProtectedCore(args, env, cwd) {
     process.once(signal, handler);
   }
   child.on('message', (message) => {
-    if (message?.type !== CORE_LOADED_MESSAGE) return;
-    settleLoaded(true);
-    try {
-      child.disconnect();
-    } catch {}
+    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 };
+  return { child, completed, loaded, packageRoot, ready };
+}
+
+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);
+  }
 }
 
-async function superviseProtectedCore(args, env, cwd, releaseNotice) {
-  const core = spawnProtectedCore(args, env, cwd);
+async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
+  const packageRoot = path.resolve(options.packageRoot || PKG);
+  let preparedTarget;
+  let handoffSessionId;
+  let updateStarted = false;
+  const startPreparation = (child) => {
+    if (updateStarted || options.runningUpdate === false) return;
+    updateStarted = true;
+    const sharedHome = env.BLUN_SHARED_HOME;
+    if (typeof sharedHome !== 'string' || sharedHome.length === 0) 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 || child.connected !== true) return;
+      preparedTarget = target;
+      child.send({ type: RUNNING_UPDATE_PREPARED_MESSAGE, version: target.version });
+    }).catch((error) => {
+      options.onRunningUpdateError?.(error);
+    });
+  };
+  const core = spawnProtectedCore(args, env, cwd, {
+    packageRoot,
+    onMessage(message, child) {
+      if (message?.type === RUNTIME_READY_MESSAGE) startPreparation(child);
+      if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
+        && typeof message.sessionId === 'string'
+        && message.sessionId.length > 0) {
+        handoffSessionId = message.sessionId;
+      }
+    },
+  });
   const loaded = await core.loaded;
   await releaseNotice();
   const result = await core.completed;
   if (result.error) throw result.error;
+  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
+    && preparedTarget !== undefined
+    && handoffSessionId !== undefined) {
+    const handoff = await handoffRuntime({
+      target: preparedTarget,
+      previous: { packageRoot, version: readPackageVersion() },
+      sessionId: handoffSessionId,
+      args,
+      probeTarget: options.probeRunningUpdate || (() => true),
+      stopOld: async () => {},
+      startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
+        const nextCore = spawnProtectedCore(nextArgs, env, cwd, { packageRoot: nextRoot });
+        const nextLoaded = await nextCore.loaded;
+        const ready = nextLoaded && await waitForRuntimeReady(nextCore, options.readyTimeoutMs);
+        if (!ready) {
+          try { nextCore.child.kill(); } catch {}
+          await nextCore.completed;
+        }
+        return { ...nextCore, ready };
+      },
+      activateTarget: (target) => (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target),
+    });
+    const resumed = handoff.core;
+    if (resumed === undefined || resumed.ready !== true) return 1;
+    const resumedResult = await resumed.completed;
+    if (resumedResult.error) throw resumedResult.error;
+    return exitCodeForChild(resumedResult, true);
+  }
   return exitCodeForChild(result, loaded);
 }
 
@@ -246,8 +337,40 @@ function spawnManagedLauncher(binary, cwd) {
   });
 }
 
+function spawnActiveLauncher(packageRoot, cwd) {
+  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], {
+      cwd,
+      env: { ...process.env, BLUN_ACTIVE_RUNTIME_ROOT: packageRoot },
+      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();
+  if (options.skipActiveRuntime !== true) {
+    const activeHome = resolveLauncherPrivatePaths().sharedHome;
+    const activeRuntime = readActiveRuntime(activeHome);
+    const currentVersion = readPackageVersion();
+    if (activeRuntime !== null
+      && path.resolve(activeRuntime.packageRoot) !== PKG
+      && compareSemver(currentVersion, activeRuntime.version) === -1) {
+      process.exitCode = await spawnActiveLauncher(activeRuntime.packageRoot, callerCwd);
+      return;
+    }
+  }
   const mode = options.mode || launcherModeFromArgv(process.argv);
   const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
   const explicitToolsRequest = String(ARGS[0] || '').toLowerCase() === 'tools';

package/bin/profile-runtime.cjs

@@ -26,6 +26,8 @@ const LEGACY_PROFILE_ENTRIES = Object.freeze([
   'tui.toml',
 ]);
 const MIGRATION_MARKER = '.legacy-profile-migrated-v1';
+const SESSION_PATH_MIGRATION_MARKER = '.legacy-profile-session-paths-v2';
+const SESSION_PATH_BACKUP_DIR = '.legacy-profile-session-paths-v2-backup';
 
 function normalizeProfileName(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -102,27 +104,161 @@ function copyLegacyEntry(source, target, fsImpl) {
   if (stat.isFile()) fsImpl.copyFileSync(source, target);
 }
 
-function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
-  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
-  const marker = path.join(paths.home, MIGRATION_MARKER);
-  if (fsImpl.existsSync(marker)) return paths;
+function relativePathInside(parent, child) {
+  const relative = path.relative(path.resolve(parent), path.resolve(child));
+  if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  return relative;
+}
 
-  fsImpl.mkdirSync(paths.home, { recursive: true });
-  for (const entry of LEGACY_PROFILE_ENTRIES) {
-    copyLegacyEntry(path.join(sharedHome, entry), path.join(paths.home, entry), fsImpl);
+function replaceTextFileIfUnchanged(target, original, replacement, fsImpl) {
+  if (fsImpl.readFileSync(target, 'utf8') !== original) {
+    throw new Error(`Sitzungsdatei wurde waehrend der Migration geaendert: ${target}`);
   }
+  const temporary = `${target}.migration-${process.pid}-${Date.now()}.tmp`;
+  fsImpl.writeFileSync(temporary, replacement, 'utf8');
   try {
-    fsImpl.writeFileSync(marker, 'legacy profile state copied once\n', { encoding: 'utf8', flag: 'wx' });
+    fsImpl.renameSync(temporary, target);
   } catch (error) {
-    if (error?.code !== 'EEXIST') throw error;
+    try {
+      fsImpl.rmSync(temporary, { force: true });
+    } catch {}
+    throw error;
   }
+}
+
+function backupFile(source, target, fsImpl) {
+  if (fsImpl.existsSync(target)) return;
+  fsImpl.mkdirSync(path.dirname(target), { recursive: true });
+  fsImpl.copyFileSync(source, target);
+}
+
+function rewriteSessionState(statePath, legacySessionDir, profileSessionDir, backupRoot, relativeSessionDir, fsImpl) {
+  if (!fsImpl.existsSync(statePath)) return false;
+  const original = fsImpl.readFileSync(statePath, 'utf8');
+  let state;
+  try {
+    state = JSON.parse(original);
+  } catch {
+    return false;
+  }
+  if (!state || typeof state !== 'object' || Array.isArray(state) || !state.agents || typeof state.agents !== 'object') {
+    return false;
+  }
+
+  let changed = false;
+  const agents = {};
+  for (const [agentId, value] of Object.entries(state.agents)) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.homedir !== 'string') {
+      agents[agentId] = value;
+      continue;
+    }
+    const relativeAgentPath = relativePathInside(legacySessionDir, value.homedir);
+    if (relativeAgentPath === null) {
+      agents[agentId] = value;
+      continue;
+    }
+    agents[agentId] = {
+      ...value,
+      homedir: path.join(profileSessionDir, relativeAgentPath),
+    };
+    changed = true;
+  }
+  if (!changed) return false;
+
+  backupFile(statePath, path.join(backupRoot, 'sessions', relativeSessionDir, 'state.json'), fsImpl);
+  const replacement = `${JSON.stringify({ ...state, agents }, null, 2)}\n`;
+  replaceTextFileIfUnchanged(statePath, original, replacement, fsImpl);
+  return true;
+}
+
+function repairDefaultProfileSessionPaths(sharedHome, fsImpl = fs, options = {}) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, SESSION_PATH_MIGRATION_MARKER);
+  const filteredWorkDir = options.workDir === undefined ? null : path.resolve(options.workDir);
+  if (filteredWorkDir === null && fsImpl.existsSync(marker)) return paths;
+  if (!fsImpl.existsSync(paths.sessionIndex)) {
+    if (filteredWorkDir === null) fsImpl.writeFileSync(marker, 'legacy session paths repaired once\n', 'utf8');
+    return paths;
+  }
+
+  const legacySessions = path.join(sharedHome, 'sessions');
+  const backupRoot = path.join(paths.home, SESSION_PATH_BACKUP_DIR);
+  const original = fsImpl.readFileSync(paths.sessionIndex, 'utf8');
+  const output = [];
+  let changed = false;
+  for (const line of original.split(/\r?\n/u)) {
+    if (line.trim() === '') {
+      output.push(line);
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      output.push(line);
+      continue;
+    }
+    if (!entry || typeof entry !== 'object' || typeof entry.sessionId !== 'string'
+      || typeof entry.sessionDir !== 'string' || typeof entry.workDir !== 'string'
+      || (filteredWorkDir !== null && path.resolve(entry.workDir) !== filteredWorkDir)) {
+      output.push(line);
+      continue;
+    }
+    const relativeSessionDir = relativePathInside(legacySessions, entry.sessionDir);
+    if (relativeSessionDir === null || path.basename(relativeSessionDir) !== entry.sessionId) {
+      output.push(line);
+      continue;
+    }
+    const profileSessionDir = path.join(paths.sessions, relativeSessionDir);
+    if (!fsImpl.existsSync(profileSessionDir)) {
+      output.push(line);
+      continue;
+    }
+
+    rewriteSessionState(
+      path.join(profileSessionDir, 'state.json'),
+      path.resolve(entry.sessionDir),
+      profileSessionDir,
+      backupRoot,
+      relativeSessionDir,
+      fsImpl,
+    );
+    output.push(JSON.stringify({ ...entry, sessionDir: profileSessionDir }));
+    changed = true;
+  }
+
+  if (changed) {
+    backupFile(paths.sessionIndex, path.join(backupRoot, 'session_index.jsonl'), fsImpl);
+    replaceTextFileIfUnchanged(paths.sessionIndex, original, output.join('\n'), fsImpl);
+  }
+  if (filteredWorkDir === null) fsImpl.writeFileSync(marker, 'legacy session paths repaired once\n', 'utf8');
   return paths;
 }
 
+function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, MIGRATION_MARKER);
+  fsImpl.mkdirSync(paths.home, { recursive: true });
+  if (!fsImpl.existsSync(marker)) {
+    for (const entry of LEGACY_PROFILE_ENTRIES) {
+      copyLegacyEntry(path.join(sharedHome, entry), path.join(paths.home, entry), fsImpl);
+    }
+    try {
+      fsImpl.writeFileSync(marker, 'legacy profile state copied once\n', { encoding: 'utf8', flag: 'wx' });
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+  }
+  return repairDefaultProfileSessionPaths(sharedHome, fsImpl);
+}
+
 module.exports = {
   DEFAULT_PROFILE,
   normalizeProfileName,
   parseProfileLaunchArgs,
+  repairDefaultProfileSessionPaths,
   resolveProfilePaths,
   seedDefaultProfileFromLegacy,
 };

package/bin/running-update.cjs

@@ -0,0 +1,389 @@
+'use strict';
+
+const { createHash, randomUUID } = require('node:crypto');
+const fs = require('node:fs');
+const https = require('node:https');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const { compareSemver, requestTrustedJson } = require('./update-notice');
+const { ensurePrivateDirectory, securePrivateFile, writePrivateFile } = require('./private-paths');
+
+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 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 RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
+const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
+
+function ownData(value, key) {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
+}
+
+function validIntegrity(value) {
+  if (typeof value !== 'string') return false;
+  const match = /^sha512-([A-Za-z0-9+/]+={0,2})$/u.exec(value);
+  if (!match) return false;
+  try {
+    return Buffer.from(match[1], 'base64').length === 64;
+  } catch {
+    return false;
+  }
+}
+
+function selectRunningUpdateTarget(currentVersion, manifest) {
+  const name = ownData(manifest, 'name');
+  const version = ownData(manifest, 'latest');
+  const integrity = ownData(manifest, 'integrity');
+  const releasedAt = ownData(manifest, 'releasedAt');
+  if (name !== PACKAGE_NAME
+    || typeof version !== 'string'
+    || compareSemver(currentVersion, version) !== -1
+    || !validIntegrity(integrity)
+    || typeof releasedAt !== 'string'
+    || !Number.isFinite(Date.parse(releasedAt))) {
+    return null;
+  }
+  return Object.freeze({ version, integrity });
+}
+
+function isSafeRuntimeBoundary(state) {
+  return state?.isShuttingDown === false
+    && state.streamingPhase === 'idle'
+    && state.isCompacting === false
+    && state.queuedMessages === 0
+    && state.activeToolCalls === 0
+    && state.shellCommands === 0
+    && state.queueCommandRunning === false;
+}
+
+function resumeArgsForHandoff(args, sessionId) {
+  const filtered = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '-c' || arg === '--continue') continue;
+    if (arg === '-r' || arg === '--resume' || arg === '--session') {
+      index += 1;
+      continue;
+    }
+    if (/^(?:--resume|--session)=/u.test(arg)) continue;
+    filtered.push(arg);
+  }
+  return [...filtered, '--resume', sessionId];
+}
+
+async function handoffRuntime(options) {
+  const handoffArgs = resumeArgsForHandoff(options.args, options.sessionId);
+  if (!await options.probeTarget(options.target)) {
+    return { kind: 'probe-failed', runtime: options.previous };
+  }
+  await options.stopOld();
+  const targetCore = await options.startCore({
+    packageRoot: options.target.packageRoot,
+    args: handoffArgs,
+  });
+  if (targetCore.ready === true) {
+    await options.activateTarget(options.target);
+    return { kind: 'activated', runtime: options.target, core: targetCore };
+  }
+  const fallbackCore = await options.startCore({
+    packageRoot: options.previous.packageRoot,
+    args: handoffArgs,
+  });
+  return { kind: 'rolled-back', runtime: options.previous, core: fallbackCore };
+}
+
+function releasesRoot(sharedHome) {
+  return path.join(path.resolve(sharedHome), 'updates', 'releases');
+}
+
+function activeRuntimePath(sharedHome) {
+  return path.join(path.resolve(sharedHome), 'updates', ACTIVE_RUNTIME_FILE);
+}
+
+function pathWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (relative !== '..'
+    && !relative.startsWith(`..${path.sep}`)
+    && !path.isAbsolute(relative));
+}
+
+function verifyRuntimePackage(packageRoot, version, options = {}) {
+  try {
+    const root = path.resolve(packageRoot);
+    const allowedRoot = path.resolve(options.allowedRoot || releasesRoot(options.sharedHome));
+    if (!pathWithin(allowedRoot, root)) return false;
+    const manifestPath = path.join(root, 'package.json');
+    const bundlePath = path.join(root, 'blun.mjs');
+    const bootstrapPath = path.join(root, 'bin', 'core-bootstrap.js');
+    for (const filePath of [manifestPath, bundlePath, bootstrapPath]) {
+      const stat = fs.lstatSync(filePath);
+      if (!stat.isFile() || stat.isSymbolicLink()) return false;
+    }
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    return ownData(manifest, 'name') === PACKAGE_NAME && ownData(manifest, 'version') === version;
+  } catch {
+    return false;
+  }
+}
+
+function readActiveRuntime(sharedHome) {
+  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'));
+    const version = ownData(record, 'version');
+    const packageRoot = ownData(record, 'packageRoot');
+    const integrity = ownData(record, 'integrity');
+    if (typeof version !== 'string'
+      || typeof packageRoot !== 'string'
+      || !path.isAbsolute(packageRoot)
+      || !validIntegrity(integrity)
+      || !verifyRuntimePackage(packageRoot, version, { sharedHome })) {
+      return null;
+    }
+    return Object.freeze({ version, packageRoot: path.resolve(packageRoot), integrity });
+  } catch {
+    return null;
+  }
+}
+
+function activateRuntime(sharedHome, target) {
+  if (!verifyRuntimePackage(target.packageRoot, target.version, { sharedHome })
+    || !validIntegrity(target.integrity)) {
+    throw new Error('RUNNING_UPDATE_TARGET_INVALID');
+  }
+  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`);
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({
+      version: target.version,
+      packageRoot: path.resolve(target.packageRoot),
+      integrity: target.integrity,
+      activatedAt: new Date().toISOString(),
+    })}\n`);
+    fs.renameSync(temporaryPath, filePath);
+    securePrivateFile(filePath);
+  } catch (error) {
+    fs.rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+}
+
+function registryRelease(registry, version) {
+  const versions = ownData(registry, 'versions');
+  const entry = ownData(versions, version);
+  const dist = ownData(entry, 'dist');
+  const integrity = ownData(dist, 'integrity');
+  const tarball = ownData(dist, 'tarball');
+  if (!validIntegrity(integrity) || typeof tarball !== 'string') return null;
+  let url;
+  try {
+    url = new URL(tarball);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== 'https:'
+    || url.hostname !== 'registry.npmjs.org'
+    || url.username !== ''
+    || url.password !== '') {
+    return null;
+  }
+  return { integrity, tarball: url.href };
+}
+
+function downloadTarball(url, destination, options = {}) {
+  const httpsImpl = options.httpsImpl || https;
+  return new Promise((resolve, reject) => {
+    const request = httpsImpl.get(url, {
+      headers: { 'user-agent': 'blun-king-running-update' },
+      timeout: options.timeoutMs || 30_000,
+    }, (response) => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`RUNNING_UPDATE_DOWNLOAD_${String(response.statusCode)}`));
+        return;
+      }
+      let bytes = 0;
+      const handle = fs.openSync(destination, 'wx', 0o600);
+      let settled = false;
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        try { fs.closeSync(handle); } catch {}
+        fs.rmSync(destination, { force: true });
+        reject(error);
+      };
+      response.on('data', (chunk) => {
+        bytes += chunk.length;
+        if (bytes > MAX_TARBALL_BYTES) {
+          response.destroy(new Error('RUNNING_UPDATE_TARBALL_TOO_LARGE'));
+          return;
+        }
+        try {
+          fs.writeSync(handle, chunk);
+        } catch (error) {
+          response.destroy(error);
+        }
+      });
+      response.once('error', fail);
+      response.once('end', () => {
+        if (settled) return;
+        settled = true;
+        fs.fsyncSync(handle);
+        fs.closeSync(handle);
+        resolve();
+      });
+    });
+    request.once('timeout', () => request.destroy(new Error('RUNNING_UPDATE_DOWNLOAD_TIMEOUT')));
+    request.once('error', reject);
+  });
+}
+
+function resolveNpmCliPath(execPath = process.execPath) {
+  const executableDirectory = path.dirname(path.resolve(execPath));
+  const candidates = [
+    path.join(executableDirectory, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(executableDirectory, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(executableDirectory, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(__dirname, '..', '..', 'npm', 'bin', 'npm-cli.js'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const resolved = fs.realpathSync(candidate);
+      if (fs.statSync(resolved).isFile() && path.basename(resolved) === 'npm-cli.js') return resolved;
+    } catch {}
+  }
+  throw new Error('TRUSTED_NPM_CLI_NOT_FOUND');
+}
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = (options.spawnImpl || spawn)(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: options.stdio || 'ignore',
+      windowsHide: true,
+    });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`RUNNING_UPDATE_PROCESS_FAILED:${code ?? signal ?? 'unknown'}`));
+    });
+  });
+}
+
+async function defaultInstallTarball(tarballPath, installPrefix, options = {}) {
+  const npmCliPath = resolveNpmCliPath(options.execPath);
+  const env = {
+    ...process.env,
+    TEMP: installPrefix,
+    TMP: installPrefix,
+    TMPDIR: installPrefix,
+    npm_config_registry: 'https://registry.npmjs.org/',
+    npm_config_strict_ssl: 'true',
+  };
+  await runProcess(options.execPath || process.execPath, [
+    npmCliPath,
+    'install',
+    `--prefix=${installPrefix}`,
+    '--ignore-scripts=false',
+    '--package-lock=false',
+    '--audit=false',
+    '--fund=false',
+    tarballPath,
+  ], { cwd: installPrefix, env, spawnImpl: options.spawnImpl });
+}
+
+async function defaultProbeRuntime(packageRoot, options = {}) {
+  try {
+    await runProcess(options.execPath || process.execPath, ['--check', path.join(packageRoot, 'blun.mjs')], options);
+    await runProcess(options.execPath || process.execPath, ['--check', path.join(packageRoot, 'bin', 'core-bootstrap.js')], options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function prepareRunningUpdate(options) {
+  if (String(options.env?.BLUN_NO_AUTO_UPDATE || '') === '1') return null;
+  const manifest = await (options.loadManifest
+    ? options.loadManifest()
+    : requestTrustedJson(MANIFEST_URL));
+  const target = selectRunningUpdateTarget(options.currentVersion, manifest);
+  if (target === null) return null;
+  const registry = await (options.loadRegistry
+    ? options.loadRegistry()
+    : requestTrustedJson(REGISTRY_URL));
+  const release = registryRelease(registry, target.version);
+  if (release === null || release.integrity !== target.integrity) {
+    throw new Error('RUNNING_UPDATE_INTEGRITY_SOURCE_MISMATCH');
+  }
+  const digest = createHash('sha256').update(target.integrity).digest('hex').slice(0, 16);
+  const releaseDirectory = path.join(releasesRoot(options.sharedHome), target.version, digest);
+  const packageRoot = path.join(releaseDirectory, 'node_modules', PACKAGE_NAME);
+  if (verifyRuntimePackage(packageRoot, target.version, { sharedHome: options.sharedHome })) {
+    return Object.freeze({ ...target, packageRoot });
+  }
+
+  const updateRoot = path.join(path.resolve(options.sharedHome), 'updates');
+  const stagingRoot = path.join(updateRoot, 'staging');
+  ensurePrivateDirectory(path.resolve(options.sharedHome));
+  ensurePrivateDirectory(updateRoot);
+  ensurePrivateDirectory(stagingRoot);
+  const temporaryRoot = fs.mkdtempSync(path.join(stagingRoot, 'runtime-'));
+  ensurePrivateDirectory(temporaryRoot);
+  const tarballPath = path.join(temporaryRoot, `${PACKAGE_NAME}.tgz`);
+  const installPrefix = path.join(temporaryRoot, 'install');
+  ensurePrivateDirectory(installPrefix);
+  try {
+    await (options.downloadTarball || downloadTarball)(release.tarball, tarballPath);
+    const actualIntegrity = `sha512-${createHash('sha512').update(fs.readFileSync(tarballPath)).digest('base64')}`;
+    if (actualIntegrity !== target.integrity) throw new Error('RUNNING_UPDATE_TARBALL_INTEGRITY_FAILED');
+    await (options.installTarball || defaultInstallTarball)(tarballPath, installPrefix, options);
+    const installedRoot = path.join(installPrefix, 'node_modules', PACKAGE_NAME);
+    if (!verifyRuntimePackage(installedRoot, target.version, { allowedRoot: installPrefix })) {
+      throw new Error('RUNNING_UPDATE_PACKAGE_INVALID');
+    }
+    if (!await (options.probeRuntime || defaultProbeRuntime)(installedRoot, options)) {
+      throw new Error('RUNNING_UPDATE_PROBE_FAILED');
+    }
+    ensurePrivateDirectory(releasesRoot(options.sharedHome));
+    ensurePrivateDirectory(path.dirname(releaseDirectory));
+    if (fs.existsSync(releaseDirectory)) fs.rmSync(releaseDirectory, { recursive: true, force: true });
+    fs.renameSync(installPrefix, releaseDirectory);
+    if (!verifyRuntimePackage(packageRoot, target.version, { sharedHome: options.sharedHome })) {
+      throw new Error('RUNNING_UPDATE_ACTIVATION_PACKAGE_INVALID');
+    }
+    return Object.freeze({ ...target, packageRoot });
+  } finally {
+    fs.rmSync(temporaryRoot, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  ACTIVE_RUNTIME_FILE,
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
+  RUNNING_UPDATE_PREPARED_MESSAGE,
+  RUNTIME_READY_MESSAGE,
+  activateRuntime,
+  activeRuntimePath,
+  defaultProbeRuntime,
+  handoffRuntime,
+  isSafeRuntimeBoundary,
+  prepareRunningUpdate,
+  readActiveRuntime,
+  resumeArgsForHandoff,
+  selectRunningUpdateTarget,
+  verifyRuntimePackage,
+};

package/bin/update-notice.js

@@ -54,8 +54,18 @@ const LEGACY_MANIFEST_KEYS = Object.freeze([
   'notesUrl',
   'releasedAt',
 ]);
+const RELEASE_NOTES_MANIFEST_KEYS = Object.freeze([
+  'install',
+  'latest',
+  'minSupported',
+  'name',
+  'notesUrl',
+  'releaseNotes',
+  'releasedAt',
+]);
 const MANIFEST_KEYS = Object.freeze([
   'install',
+  'integrity',
   'latest',
   'minSupported',
   'name',
@@ -214,8 +224,20 @@ function parseReleaseNotes(value) {
   return Object.freeze(notes);
 }
 
+function validIntegrity(value) {
+  if (typeof value !== 'string') return false;
+  const match = /^sha512-([A-Za-z0-9+/]+={0,2})$/u.exec(value);
+  if (!match) return false;
+  try {
+    return Buffer.from(match[1], 'base64').length === 64;
+  } catch {
+    return false;
+  }
+}
+
 function parseFallbackManifest(value) {
   const record = exactDataRecord(value, MANIFEST_KEYS)
+    || exactDataRecord(value, RELEASE_NOTES_MANIFEST_KEYS)
     || exactDataRecord(value, LEGACY_MANIFEST_KEYS);
   const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
   const releaseNotes = record && Object.hasOwn(record, 'releaseNotes')
@@ -228,6 +250,7 @@ function parseFallbackManifest(value) {
     || compareSemver(record.minSupported, record.latest) === 1
     || !isIsoTimestamp(record.releasedAt)
     || !notesUrl
+    || (Object.hasOwn(record, 'integrity') && !validIntegrity(record.integrity))
     || (Object.hasOwn(record, 'releaseNotes') && releaseNotes === undefined)
     || !isBoundedText(record.install, 256)) {
     return undefined;
@@ -238,6 +261,7 @@ function parseFallbackManifest(value) {
     minSupported: record.minSupported,
     releasedAt: record.releasedAt,
     notesUrl,
+    ...(Object.hasOwn(record, 'integrity') ? { integrity: record.integrity } : {}),
     ...(releaseNotes === undefined ? {} : { releaseNotes }),
     install: record.install,
   });

package/blun.mjs

@@ -503099,8 +503099,8 @@ registerUiCatalogFragment({
 *   0 = most recent clipped lines visible
 *   N = N lines up from the bottom
 */
-/** Maximum lines retained before the oldest are evicted. */
-const MAX_BUFFER_LINES = 1e4;
+/** Retain the complete rendered session unless the process itself ends. */
+const MAX_BUFFER_LINES = Number.POSITIVE_INFINITY;
 var ScrollbackBuffer = class {
 	lines = [];
 	scrollOffset = 0;
@@ -505264,6 +505264,7 @@ var SessionEventHandler = class {
 		this.goalCompletionTurnEnded = true;
 		this.scheduleQueuedGoalPromotion();
 		if (event.reason === "completed") this.host.refreshManagedQuotaWindows();
+		requestRunningUpdateAtSafeBoundary(this.host);
 	}
 	handleStepBegin(event) {
 		this.host.commitQueuedSteerAtStepStart(event.turnId);
@@ -505311,12 +505312,13 @@ var SessionEventHandler = class {
 		const duration = durationMs === void 0 ? "—" : formatResponseDuration(durationMs);
 		const tokens = this.currentTurnTokenCount === void 0 ? "—" : formatTokenCount(this.currentTurnTokenCount);
 		const tokenKey = this.currentTurnTokenCount === 1 ? "thinking.tokens.one" : "thinking.tokens.other";
+		const startedAt = formatLiveStartedAt(this.currentTurnStartedAtMs ?? Date.now());
 		this.host.appendTranscriptEntry({
 			id: nextTranscriptId(),
 			kind: "status",
 			turnId: String(event.turnId),
 			renderMode: "plain",
-			content: `${duration} · ${uiText(tokenKey, { count: tokens })}`
+			content: `${duration} · ${uiText(tokenKey, { count: tokens })} · ${startedAt}`
 		});
 	}
 	markActiveAgentSwarmsCancelled() {
@@ -506297,12 +506299,6 @@ function createReplayRenderContext() {
 		suppressNextPlanModeOffNotice: false
 	};
 }
-function limitReplayRecordsByTurn(records, maxTurns) {
-	if (maxTurns <= 0) return [];
-	const turnStarts = records.flatMap((record, index) => isReplayUserTurnRecord(record) ? [index] : []);
-	if (turnStarts.length <= maxTurns) return records;
-	return records.slice(turnStarts[turnStarts.length - maxTurns]);
-}
 function replayEntry(context, kind, content, renderMode, extras = {}) {
 	return {
 		id: nextTranscriptId(),
@@ -506630,7 +506626,7 @@ var SessionReplayRenderer = class {
 	}
 	renderRecords(agent) {
 		const context = createReplayRenderContext();
-		for (const record of limitReplayRecordsByTurn(agent.replay, 10)) this.renderRecord(context, record);
+		for (const record of agent.replay) this.renderRecord(context, record);
 		this.flushAssistant(context);
 		this.cleanupRuntime(context);
 	}
@@ -508034,7 +508030,7 @@ var FooterComponent = class {
 			const persona = personaName();
 			const profileLabel = process.env["BLUN_PROFILE"] ?? "default";
 			const profile = chalk.hex(colors.textDim)(profileLabel) + sep;
-			const brand = chalk.hex(colors.primary).bold("● BLUN") + sep + profile + (persona !== void 0 ? chalk.hex(colors.text)(persona) + sep : "");
+			const brand = chalk.hex(colors.primary).bold("● BL") + chalk.hex(colors.text)("UN") + sep + profile + (persona !== void 0 ? chalk.hex(colors.text)(persona) + sep : "");
 			const modelLabel = model;
 			const modeLabel = uiText(state.permissionMode === "yolo" ? "footer.mode.god" : state.permissionMode === "auto" ? "footer.mode.auto" : "footer.mode.manual");
 			const modeSuffix = sep + chalk.hex(colors.textDim)(uiText("footer.mode", { mode: modeLabel }));
@@ -511396,12 +511392,18 @@ var CustomEditor = class extends Editor {
 		if (isKeyRelease(normalized)) return;
 		if (!matchesKey(normalized, Key.escape)) this.onNonEscapeInput?.();
 		if (this.consumingPaste) {
-			this.consumeBuffer += normalized;
-			if (this.consumeBuffer.includes(BRACKET_PASTE_END)) {
+			const cancelPaste = matchesKey(normalized, Key.ctrl("c")) || matchesKey(normalized, Key.escape);
+			if (cancelPaste) {
 				this.consumingPaste = false;
 				this.consumeBuffer = "";
+			} else {
+				this.consumeBuffer += normalized;
+				if (this.consumeBuffer.includes(BRACKET_PASTE_END)) {
+					this.consumingPaste = false;
+					this.consumeBuffer = "";
+				}
+				return;
 			}
-			return;
 		}
 		if (normalized.includes(BRACKET_PASTE_START) && this.expandPasteMarkerAtCursor()) {
 			if (!normalized.includes(BRACKET_PASTE_END)) this.consumingPaste = true;
@@ -511456,6 +511458,7 @@ var CustomEditor = class extends Editor {
 		if (this.inputMode === "bash" && this.getText().length === 0 && (matchesKey(normalized, Key.escape) || matchesKey(normalized, Key.backspace))) {
 			this.inputMode = "prompt";
 			this.onInputModeChange?.("prompt");
+			if (matchesKey(normalized, Key.escape)) this.onEscape?.(true);
 			return;
 		}
 		if (matchesKey(normalized, Key.up)) {
@@ -511742,6 +511745,7 @@ var GhostSuggestEditor = class extends CustomEditor {
 			if (matchesKey(normalized, Key.escape)) {
 				this.ghostSuggestion = null;
 				this.onGhostDismissed?.();
+				this.onEscape?.(true);
 				return;
 			}
 			if (this.isCursorAtTextEnd() && !this.isShowingAutocomplete()) {
@@ -513049,13 +513053,13 @@ function readEnvInt(name, fallback) {
 	return value;
 }
 /** Keep the most recent N turns. `0` disables trimming. */
-const TRANSCRIPT_MAX_TURNS = readEnvInt("BLUN_TUI_MAX_TURNS", 15);
+const TRANSCRIPT_MAX_TURNS = readEnvInt("BLUN_TUI_MAX_TURNS", 0);
 /** Only the most recent E turns are allowed to expand (Ctrl+O). `0` disables expanding. */
 const TRANSCRIPT_EXPAND_TURNS = readEnvInt("BLUN_TUI_EXPAND_TURNS", 3);
 /** Only trim once the window exceeds maxTurns by this much (avoids churn). */
 const TRANSCRIPT_HYSTERESIS = readEnvInt("BLUN_TUI_HYSTERESIS", 5);
 /** Keep this many recent steps untouched inside a turn; older steps are merged into a summary. `0` disables merging. */
-const TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("BLUN_TUI_KEEP_RECENT_STEPS", 30);
+const TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("BLUN_TUI_KEEP_RECENT_STEPS", 0);
 /**
 * Group consecutive entries into turns by `turnId`. Entries with the same
 * non-undefined `turnId` that are adjacent belong to the same turn.
@@ -513112,6 +513116,60 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 }
 //#endregion
 //#region src/tui/blun-tui.ts
+const {
+	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+	RUNNING_UPDATE_HANDOFF_MESSAGE,
+	RUNNING_UPDATE_PREPARED_MESSAGE,
+	RUNTIME_READY_MESSAGE,
+	isSafeRuntimeBoundary
+} = __require("./bin/running-update.cjs");
+function notifyRunningRuntimeReady(tui) {
+	if (!process.connected) return;
+	const sessionId = tui.getCurrentSessionId();
+	if (sessionId.length === 0) return;
+	try {
+		process.send({
+			type: RUNTIME_READY_MESSAGE,
+			sessionId
+		});
+	} catch {}
+}
+function requestRunningUpdateAtSafeBoundary(tui) {
+	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdateHandoffStarted || !process.connected) 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;
+	const sessionId = tui.getCurrentSessionId();
+	if (sessionId.length === 0) return false;
+	tui.runningUpdateHandoffStarted = true;
+	try {
+		process.send({
+			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
+			sessionId,
+			version: tui.runningUpdatePreparedVersion
+		});
+	} catch {
+		tui.runningUpdateHandoffStarted = false;
+		return false;
+	}
+	void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
+	return true;
+}
+function installRunningUpdateListener(tui) {
+	const handler = (message) => {
+		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string") return;
+		tui.runningUpdatePreparedVersion = message.version;
+		requestRunningUpdateAtSafeBoundary(tui);
+	};
+	process.on("message", handler);
+	return () => process.off("message", handler);
+}
 function loadingTipKind(mode) {
 	if (mode === "waiting" || mode === "tool") return "blun";
 	if (mode === "composing") return "composing";
@@ -513196,6 +513254,9 @@ var BlunTUI = class {
 	startupLoginRequired = false;
 	startupWorkspaceSelectionPending = false;
 	startupGoalPromptedSessionId;
+	runningUpdatePreparedVersion;
+	runningUpdateHandoffStarted = false;
+	runningUpdateMessageDispose;
 	startupPhaseMs = {};
 	lastActivityMode;
 	currentLoadingTip = void 0;
@@ -513309,6 +513370,7 @@ var BlunTUI = class {
 		this.editorKeyboard.install();
 		this.scrollbackController = new ScrollbackController(this.state);
 		this.scrollbackController.install();
+		this.runningUpdateMessageDispose = installRunningUpdateListener(this);
 		this.buildLayout();
 	}
 	getSlashCommands() {
@@ -513739,6 +513801,8 @@ var BlunTUI = class {
 		this.managedQuotaWarningController.dispose();
 		this.state.loopIndicator.dispose();
 		this.state.footer.dispose();
+		this.runningUpdateMessageDispose?.();
+		this.runningUpdateMessageDispose = void 0;
 		for (const dispose of this.reverseRpcDisposers) dispose();
 		this.reverseRpcDisposers.length = 0;
 		this.disposeTerminalTracking();
@@ -513962,6 +514026,7 @@ var BlunTUI = class {
 		if (this.shellOutputStreams.size === 0) {
 			this.setAppState({ streamingPhase: "idle" });
 			this.drainOneQueuedMessage();
+			requestRunningUpdateAtSafeBoundary(this);
 		}
 	}
 	queueDrainTimer;
@@ -516409,22 +516474,27 @@ async function runShell(opts, version, updateStartupNotice) {
 	tui.onExit = async (exitCode = 0) => {
 		const sessionId = tui.getCurrentSessionId();
 		const hasContent = tui.hasSessionContent();
+		const runningUpdateHandoff = exitCode === RUNNING_UPDATE_HANDOFF_EXIT_CODE;
 		setCrashPhase("shutdown");
 		trackLifecycle("exit", { duration_ms: Date.now() - startedAt });
 		await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
 		const gutter = " ".repeat(1);
-		process.stdout.write(`${gutter}Bye!\n`);
+		if (!runningUpdateHandoff) process.stdout.write(`${gutter}Bye!\n`);
 		const hints = [];
-		if (sessionId !== "" && hasContent) hints.push(`${gutter}To resume this session: blun -r ${sessionId}`);
-		if (tui.exitOpenUrl !== void 0) hints.push(`${gutter}open ${toTerminalHyperlink$1(tui.exitOpenUrl, tui.exitOpenUrl)}`);
+		if (!runningUpdateHandoff && sessionId !== "" && hasContent) hints.push(`${gutter}To resume this session: blun -r ${sessionId}`);
+		if (!runningUpdateHandoff && tui.exitOpenUrl !== void 0) hints.push(`${gutter}open ${toTerminalHyperlink$1(tui.exitOpenUrl, tui.exitOpenUrl)}`);
 		if (hints.length > 0) process.stderr.write(`\n${hints.join("\n")}\n`);
 		removeCrashHandlers();
 		restoreStty();
+		if (process.connected) try {
+			process.disconnect();
+		} catch {}
 		process.exit(exitCode);
 	};
 	try {
 		const initStartedAt = Date.now();
 		await tui.start();
+		notifyRunningRuntimeReady(tui);
 		const initMs = Date.now() - initStartedAt;
 		const startupSessionId = tui.getCurrentSessionId();
 		const mcpMs = await tui.getStartupMcpMs();

package/package.json

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