blun-king-cli 9.1.485 → 9.1.486

package/LIESMICH.txt

@@ -20,16 +20,13 @@ Start
 Beide Startbefehle verwenden dieselbe Version, dasselbe Konto, dasselbe Modell
 und dieselben Befehle.
 
-king und king -c prüfen beim interaktiven Start auf eine neuere Version. Ist
-eine vorhanden, erscheint der sichtbare Dialog:
-
-  1. Jetzt aktualisieren
-  2. Überspringen
-  3. Auf den nächsten Release warten
-
-Es gibt keinen Download und keine Installation im Hintergrund. Nach einer
-gewählten Installation endet king; king -c setzt die letzte Sitzung mit der
-neuen Version fort.
+king und king -c prüfen beim interaktiven Start auf eine neuere Version.
+Automatische Updates sind standardmäßig aktiv und installieren den geprüften
+Zielstand ohne zusätzliche Bestätigung. Danach endet king; king -c setzt die
+letzte Sitzung mit der neuen Version fort. Mit
+[upgrade].auto_install = false in tui.toml erscheint stattdessen der sichtbare
+Auswahldialog. Start- und Update-Meldungen sind bei einer neuen Installation
+standardmäßig Englisch; eine ausdrücklich gewählte Sprache bleibt erhalten.
 
 Standard-MCPs und Eingabesteuerung
 ---------------------------------

package/README.md

@@ -36,11 +36,12 @@ gilt nur für den laufenden Prozess; die gespeicherte
 Plugin-Konfiguration wird nicht umgeschrieben.
 
 `king` und `king -c` prüfen beim interaktiven Start, ob eine neuere Version
-vorliegt. Dann erscheint der sichtbare Dialog mit den Optionen jetzt
-aktualisieren, überspringen oder auf den nächsten Release warten. Im Hintergrund
-wird nichts heruntergeladen oder installiert. Nach einer gewählten Installation
-endet `king`; `king -c` setzt dagegen die letzte Sitzung mit der neuen Version
-fort.
+vorliegt. Automatische Updates sind standardmäßig aktiv und installieren den
+geprüften Zielstand ohne zusätzliche Bestätigung. Danach endet `king`; `king -c`
+setzt die letzte Sitzung mit der neuen Version fort. Mit
+`[upgrade].auto_install = false` in `tui.toml` erscheint stattdessen der sichtbare
+Auswahldialog. Start- und Update-Meldungen sind bei einer neuen Installation
+standardmäßig Englisch; eine ausdrücklich gewählte Sprache bleibt erhalten.
 
 Telegram-Chats werden ohne manuell eingegebene IDs verbunden. In der Konsole
 erzeugt `/telegram:access connect` einen einmaligen Code. `/connect CODE` im

package/bin/launcher-runtime.js

@@ -42,6 +42,11 @@ const {
   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);
@@ -398,6 +403,9 @@ async function runLauncher(options = {}) {
     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,
@@ -405,6 +413,7 @@ async function runLauncher(options = {}) {
         stdout: process.stdout,
         stderr: process.stderr,
         blunDir: privatePaths.sharedHome,
+        uiLocale: resolveStartupUiLocale(startupPreferences.uiLocale, process.env),
         packageRoot: PKG,
         noticeLease: launcherLease,
       });
@@ -449,6 +458,8 @@ async function runLauncher(options = {}) {
     }
     const blunDir = profilePaths.home;
     ensurePrivateDirectory(blunDir);
+    migrateLegacyStartupPreferences(blunDir);
+    const startupPreferences = readStartupPreferences(blunDir);
 
     const updateResult = await runUpdateNotice({
       currentVersion: readPackageVersion(),
@@ -458,6 +469,8 @@ async function runLauncher(options = {}) {
       stdout: process.stdout,
       stderr: process.stderr,
       blunDir: privatePaths.sharedHome,
+      autoInstall: startupPreferences.autoInstall,
+      uiLocale: resolveStartupUiLocale(startupPreferences.uiLocale, process.env),
       packageRoot: PKG,
       noticeLease: launcherLease,
     });

package/bin/startup-preferences.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CONFIG_FILE = 'tui.toml';
+const MIGRATION_MARKER = '.legacy-auto-ui-locale-v1';
+const MIGRATION_BACKUP = 'tui.toml.vor-english-default-v1';
+const MAX_CONFIG_BYTES = 256 * 1024;
+
+function safeConfigPath(profileHome, fsImpl = fs) {
+  const configPath = path.join(path.resolve(profileHome), CONFIG_FILE);
+  if (!fsImpl.existsSync(configPath)) return undefined;
+  const stat = fsImpl.lstatSync(configPath);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_CONFIG_BYTES) {
+    return undefined;
+  }
+  return configPath;
+}
+
+function parseStartupPreferences(text) {
+  let section = '';
+  let autoInstall = true;
+  let uiLocale = 'en';
+
+  for (const line of String(text).replace(/^\uFEFF/u, '').split(/\r?\n/u)) {
+    const sectionMatch = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/u.exec(line);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim().toLowerCase();
+      continue;
+    }
+    if (section === '') {
+      const localeMatch = /^\s*ui_locale\s*=\s*"([^"]+)"\s*(?:#.*)?$/u.exec(line);
+      if (localeMatch && /^(?:auto|[a-z]{2}(?:-[a-z0-9]+)*)$/iu.test(localeMatch[1])) {
+        uiLocale = localeMatch[1].toLowerCase();
+      }
+      continue;
+    }
+    if (section === 'upgrade') {
+      const automaticMatch = /^\s*auto_install\s*=\s*(true|false)\s*(?:#.*)?$/iu.exec(line);
+      if (automaticMatch) autoInstall = automaticMatch[1].toLowerCase() === 'true';
+    }
+  }
+
+  return { autoInstall, uiLocale };
+}
+
+function readStartupPreferences(profileHome, fsImpl = fs) {
+  const configPath = safeConfigPath(profileHome, fsImpl);
+  if (!configPath) return { autoInstall: true, uiLocale: 'en' };
+  try {
+    return parseStartupPreferences(fsImpl.readFileSync(configPath, 'utf8'));
+  } catch {
+    return { autoInstall: true, uiLocale: 'en' };
+  }
+}
+
+function resolveStartupUiLocale(uiLocale, env = process.env) {
+  const normalized = String(uiLocale || 'en').trim().toLowerCase();
+  if (normalized !== 'auto') return normalized;
+  const operatingSystemLocale = String(env.LC_ALL || env.LC_MESSAGES || env.LANG || '')
+    .trim()
+    .toLowerCase();
+  return operatingSystemLocale === 'de'
+    || operatingSystemLocale.startsWith('de-')
+    || operatingSystemLocale.startsWith('de_')
+    || operatingSystemLocale.startsWith('de.')
+    ? 'de'
+    : 'en';
+}
+
+function writeMarkerOnce(markerPath, fsImpl) {
+  try {
+    fsImpl.writeFileSync(markerPath, 'legacy automatic UI locale reviewed once\n', {
+      encoding: 'utf8',
+      flag: 'wx',
+    });
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+}
+
+function replaceIfUnchanged(target, original, replacement, fsImpl) {
+  if (fsImpl.readFileSync(target, 'utf8') !== original) {
+    throw new Error(`Startup preferences changed during migration: ${target}`);
+  }
+  const temporary = `${target}.migration-${process.pid}-${Date.now()}.tmp`;
+  fsImpl.writeFileSync(temporary, replacement, 'utf8');
+  try {
+    fsImpl.renameSync(temporary, target);
+  } catch (error) {
+    try {
+      fsImpl.rmSync(temporary, { force: true });
+    } catch {}
+    throw error;
+  }
+}
+
+function migrateLegacyStartupPreferences(profileHome, fsImpl = fs) {
+  const resolvedHome = path.resolve(profileHome);
+  fsImpl.mkdirSync(resolvedHome, { recursive: true });
+  const markerPath = path.join(resolvedHome, MIGRATION_MARKER);
+  const backupPath = path.join(resolvedHome, MIGRATION_BACKUP);
+  if (fsImpl.existsSync(markerPath)) return { changed: false };
+
+  const configPath = safeConfigPath(resolvedHome, fsImpl);
+  if (!configPath) {
+    writeMarkerOnce(markerPath, fsImpl);
+    return { changed: false };
+  }
+
+  const original = fsImpl.readFileSync(configPath, 'utf8');
+  const legacyLocale = /^(\s*ui_locale\s*=\s*)"auto"(\s*(?:#.*)?)$/mu;
+  if (!legacyLocale.test(original)) {
+    writeMarkerOnce(markerPath, fsImpl);
+    return { changed: false };
+  }
+
+  if (!fsImpl.existsSync(backupPath)) fsImpl.copyFileSync(configPath, backupPath);
+  const replacement = original.replace(legacyLocale, '$1"en"$2');
+  replaceIfUnchanged(configPath, original, replacement, fsImpl);
+  writeMarkerOnce(markerPath, fsImpl);
+  return { backupPath, changed: true };
+}
+
+module.exports = {
+  migrateLegacyStartupPreferences,
+  readStartupPreferences,
+  resolveStartupUiLocale,
+};

package/bin/update-notice.js

@@ -621,6 +621,54 @@ function installCommandText(version) {
   return `npm i -g ${PACKAGE_NAME}@${version}`;
 }
 
+function updateCopy(uiLocale) {
+  const german = String(uiLocale || '').toLowerCase().startsWith('de');
+  if (german) {
+    return {
+      available: (current, next) => `BLUN Code-Update verfügbar: ${current} -> ${next}`,
+      current: (version) => `Kein Update verfügbar. Installiert: ${version} · Aktuell: ${version}.`,
+      enter: 'Enter drücken, um fortzufahren',
+      failed: (code) => `Update fehlgeschlagen (Code ${code}).`,
+      install: (version) => `Jetzt aktualisieren (führt \`${installCommandText(version)}\` aus)`,
+      installFailed: (code) => `Update fehlgeschlagen (Code ${code}). Die vorhandene Version wird gestartet.`,
+      installed: 'Installation geprüft',
+      installedContinue: (current, next) => `Update ${current} -> ${next} erfolgreich installiert. Die letzte Sitzung wird mit der neuen Version fortgesetzt.`,
+      installedRestart: (current, next) => `Update ${current} -> ${next} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.`,
+      installerReady: 'Installer bereit',
+      installing: 'Paket wird installiert',
+      invalidTarget: (version) => `Kein sicherer Update-Zielstand verfügbar. Installiert: ${version}.`,
+      nextRelease: 'Auf den nächsten Release warten',
+      notes: 'Versionshinweise',
+      skip: 'Überspringen',
+      startupNoticeFailed: (version) => `Update ${version} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.`,
+      updateChecked: 'Update geprüft',
+      verificationFailed: 'Das Update konnte nicht verifiziert werden.',
+      verificationRestart: 'Update konnte nicht verifiziert werden. Starte BLUN Code neu.',
+    };
+  }
+  return {
+    available: (current, next) => `BLUN Code update available: ${current} -> ${next}`,
+    current: (version) => `No update available. Installed: ${version} · Current: ${version}.`,
+    enter: 'Press Enter to continue',
+    failed: (code) => `Update failed (code ${code}).`,
+    install: (version) => `Update now (runs \`${installCommandText(version)}\`)`,
+    installFailed: (code) => `Update failed (code ${code}). The installed version will start.`,
+    installed: 'Installation verified',
+    installedContinue: (current, next) => `Update ${current} -> ${next} installed successfully. The last session will continue with the new version.`,
+    installedRestart: (current, next) => `Update ${current} -> ${next} installed successfully. Restart BLUN Code to use the new version.`,
+    installerReady: 'Installer ready',
+    installing: 'Installing package',
+    invalidTarget: (version) => `No safe update target is available. Installed: ${version}.`,
+    nextRelease: 'Wait for the next release',
+    notes: 'Release notes',
+    skip: 'Skip',
+    startupNoticeFailed: (version) => `Update ${version} was installed, but the startup notice could not be saved.`,
+    updateChecked: 'Update checked',
+    verificationFailed: 'The update could not be verified.',
+    verificationRestart: 'The update could not be verified. Restart BLUN Code.',
+  };
+}
+
 function createUpdateProgress(output) {
   const enabled = output?.isTTY === true;
   const phaseCount = 4;
@@ -646,7 +694,14 @@ function createUpdateProgress(output) {
   return update;
 }
 
-function promptUpdateAction({ currentVersion, release, input, output, processRef = process }) {
+function promptUpdateAction({
+  currentVersion,
+  release,
+  input,
+  output,
+  processRef = process,
+  uiLocale = 'en',
+}) {
   return new Promise((resolve, reject) => {
     let selected = 0;
     let settled = false;
@@ -659,13 +714,14 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
     const dim = '\u001B[2m';
     const underline = '\u001B[4m';
     const reset = '\u001B[0m';
+    const copy = updateCopy(uiLocale);
     const actions = [
       {
         choice: 'install',
-        label: `Jetzt aktualisieren (führt \`${installCommandText(release.version)}\` aus)`,
+        label: copy.install(release.version),
       },
-      { choice: 'skip-once', label: 'Überspringen' },
-      { choice: 'skip-version', label: 'Auf den nächsten Release warten' },
+      { choice: 'skip-once', label: copy.skip },
+      { choice: 'skip-version', label: copy.nextRelease },
     ];
     const signalHandlers = new Map();
 
@@ -675,7 +731,7 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         const line = `${selected === index ? '›' : ' '} ${index + 1}. ${actions[index].label}`;
         output.write(`\r\u001B[2K${selected === index ? cyan : ''}${line}${selected === index ? reset : ''}\n`);
       }
-      output.write(`\r\u001B[2K${dim}Enter drücken, um fortzufahren${reset}\n`);
+      output.write(`\r\u001B[2K${dim}${copy.enter}${reset}\n`);
     };
     const cleanup = () => {
       if (escapeTimer !== undefined) clearTimeout(escapeTimer);
@@ -830,9 +886,9 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         signalHandlers.set(signal, handler);
         processRef.once(signal, handler);
       }
-      output.write(`\nBLUN Code-Update verfügbar: ${currentVersion} -> ${release.version}\n`);
+      output.write(`\n${copy.available(currentVersion, release.version)}\n`);
       if (release.notesUrl) {
-        output.write(`${dim}Versionshinweise:${reset} ${underline}${release.notesUrl}${reset}\n`);
+        output.write(`${dim}${copy.notes}:${reset} ${underline}${release.notesUrl}${reset}\n`);
       }
       output.write('\n');
       cursorHidden = true;
@@ -1290,19 +1346,21 @@ function noReleaseReason(currentVersion, registryTags, fallbackManifest) {
   return parseSemver(latest) || fallbackManifest ? 'current' : 'unavailable';
 }
 
-function explicitNoTarget(stdout, reason, currentVersion) {
+function explicitNoTarget(stdout, reason, currentVersion, uiLocale) {
+  const copy = updateCopy(uiLocale);
   stdout.write(reason === 'current'
-    ? `Kein Update verfügbar. Installiert: ${currentVersion} · Aktuell: ${currentVersion}.\n`
-    : `Kein sicherer Update-Zielstand verfügbar. Installiert: ${currentVersion}.\n`);
+    ? `${copy.current(currentVersion)}\n`
+    : `${copy.invalidTarget(currentVersion)}\n`);
   return { kind: 'current', reason };
 }
 
-function explicitFailure(stderr, reason, exitCode) {
+function explicitFailure(stderr, reason, exitCode, uiLocale) {
+  const copy = updateCopy(uiLocale);
   const hasExitCode = Number.isInteger(exitCode) && exitCode !== 0;
   if (hasExitCode) {
-    stderr.write(`Update fehlgeschlagen (Code ${exitCode}).\n`);
+    stderr.write(`${copy.failed(exitCode)}\n`);
   } else {
-    stderr.write('Das Update konnte nicht verifiziert werden.\n');
+    stderr.write(`${copy.verificationFailed}\n`);
   }
   return {
     kind: 'failed',
@@ -1321,12 +1379,14 @@ async function runUpdateFlow(options, explicitUpdate) {
     stderr,
     blunDir,
   } = options;
+  const uiLocale = options.uiLocale || 'en';
+  const copy = updateCopy(uiLocale);
   if (!explicitUpdate && !isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
     return { kind: 'continue', reason: 'not_interactive' };
   }
   if (!parseSemver(currentVersion)) {
     return explicitUpdate
-      ? explicitFailure(stderr, 'invalid_current_version')
+      ? explicitFailure(stderr, 'invalid_current_version', undefined, uiLocale)
       : { kind: 'continue', reason: 'invalid_current_version' };
   }
 
@@ -1340,7 +1400,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       leaseResult = await (options.acquireLease || tryAcquireUpdateLease)({ packageRoot });
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
   } else {
@@ -1351,6 +1411,8 @@ async function runUpdateFlow(options, explicitUpdate) {
       return explicitFailure(
         stderr,
         leaseResult?.reason === 'busy' ? 'update_in_progress' : 'lease_unavailable',
+        undefined,
+        uiLocale,
       );
     }
     return leaseResult?.reason === 'busy'
@@ -1366,7 +1428,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
     } catch {
       return explicitUpdate
-        ? explicitNoTarget(stdout, 'unavailable', currentVersion)
+        ? explicitNoTarget(stdout, 'unavailable', currentVersion, uiLocale)
         : { kind: 'continue', reason: 'unavailable' };
     }
     const registryTags = parseRegistryDocument(sources?.registryDocument);
@@ -1375,7 +1437,7 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (!release) {
       const reason = noReleaseReason(currentVersion, registryTags, fallbackManifest);
       return explicitUpdate
-        ? explicitNoTarget(stdout, reason, currentVersion)
+        ? explicitNoTarget(stdout, reason, currentVersion, uiLocale)
         : { kind: 'continue', reason };
     }
     if (!explicitUpdate
@@ -1385,12 +1447,12 @@ async function runUpdateFlow(options, explicitUpdate) {
     const initialInstallLease = await probeInstallLease(options, packageRoot);
     if (initialInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (initialInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!explicitUpdate
@@ -1401,25 +1463,25 @@ async function runUpdateFlow(options, explicitUpdate) {
       try {
         ensurePrivateDirectory(blunDir);
       } catch {
-        return explicitFailure(stderr, 'private_home_unavailable');
+        return explicitFailure(stderr, 'private_home_unavailable', undefined, uiLocale);
       }
     }
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     const prePromptInstallLease = await probeInstallLease(options, packageRoot);
     if (prePromptInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (prePromptInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!options.installVersion) {
@@ -1429,7 +1491,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       );
       if (!installerSession?.ready) {
         if (explicitUpdate) {
-          return explicitFailure(stderr, 'installer_unavailable');
+          return explicitFailure(stderr, 'installer_unavailable', undefined, uiLocale);
         }
         return installerSession?.reason === 'failed'
           ? { kind: 'continue', reason: 'installer_unavailable' }
@@ -1437,7 +1499,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
     }
     let action;
-    if (explicitUpdate) {
+    if (explicitUpdate || options.autoInstall === true) {
       action = 'install';
     } else {
       try {
@@ -1446,6 +1508,7 @@ async function runUpdateFlow(options, explicitUpdate) {
           release,
           input: stdin,
           output: stdout,
+          uiLocale,
         });
       } catch {
         return { kind: 'continue', reason: 'prompt_failed' };
@@ -1476,18 +1539,18 @@ async function runUpdateFlow(options, explicitUpdate) {
     }
 
     const updateProgress = createUpdateProgress(stdout);
-    updateProgress(1, 'Update geprüft');
-    updateProgress(2, 'Installer bereit');
+    updateProgress(1, copy.updateChecked);
+    updateProgress(2, copy.installerReady);
 
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     let installResult;
-    updateProgress(3, 'Paket wird installiert');
+    updateProgress(3, copy.installing);
     try {
       installResult = options.installVersion
         ? await options.installVersion(release.version)
@@ -1500,11 +1563,11 @@ async function runUpdateFlow(options, explicitUpdate) {
       || installResult?.unknownState === true) {
       updateProgress.finish();
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
-      updateProgress(4, 'Installation geprüft');
+      updateProgress(4, copy.installed);
       clearPendingUpdate(blunDir);
       try {
         writeCoreInstallSuccess(
@@ -1512,21 +1575,19 @@ async function runUpdateFlow(options, explicitUpdate) {
           currentVersion,
           release.version,
           release.releaseNotes,
-          explicitUpdate ? 'manual' : 'startup_prompt',
+          explicitUpdate ? 'manual' : options.autoInstall === true ? 'startup_auto' : 'startup_prompt',
           (options.now || Date.now)(),
         );
       } catch {
-        stderr.write(
-          `Update ${release.version} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.\n`,
-        );
+        stderr.write(`${copy.startupNoticeFailed(release.version)}\n`);
       }
       const continuesLastSession = Array.isArray(options.argv)
         && options.argv.length === 1
         && options.argv[0] === '-c';
-      stdout.write(continuesLastSession
-        ? `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Die letzte Sitzung wird mit der neuen Version fortgesetzt.\n`
-        : `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n`);
-      if (release.notesUrl) stdout.write(`Versionshinweise: ${release.notesUrl}\n`);
+      stdout.write(`${continuesLastSession
+        ? copy.installedContinue(currentVersion, release.version)
+        : copy.installedRestart(currentVersion, release.version)}\n`);
+      if (release.notesUrl) stdout.write(`${copy.notes}: ${release.notesUrl}\n`);
       return {
         kind: 'installed',
         version: release.version,
@@ -1536,14 +1597,14 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {
       updateProgress.finish();
       if (explicitUpdate) {
-        return explicitFailure(stderr, 'install_failed', installResult.code);
+        return explicitFailure(stderr, 'install_failed', installResult.code, uiLocale);
       }
-      stderr.write(`Update fehlgeschlagen (Code ${installResult.code}). Die vorhandene Version wird gestartet.\n`);
+      stderr.write(`${copy.installFailed(installResult.code)}\n`);
       return { kind: 'continue', reason: 'install_failed', exitCode: installResult.code };
     }
     updateProgress.finish();
-    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed');
-    stderr.write('Update konnte nicht verifiziert werden. Starte BLUN Code neu.\n');
+    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed', undefined, uiLocale);
+    stderr.write(`${copy.verificationRestart}\n`);
     return { kind: 'update_in_progress' };
   } finally {
     if (installerSession?.ready) {

package/blun.mjs

@@ -342525,6 +342525,7 @@ const NotificationsConfigSchema = object({
 	enabled: boolean$1(),
 	condition: NotificationConditionSchema
 });
+const UpgradePreferencesSchema = object({ autoInstall: boolean$1() });
 const InlineSuggestConfigSchema = object({ languages: record(string(), boolean$1()) });
 const HexColorSchema = string().regex(/^#[0-9A-Fa-f]{6}$/u);
 const AppearanceConfigSchema = object({
@@ -342541,7 +342542,8 @@ const TuiConfigFileSchema = object({
 	notifications: object({
 		enabled: boolean$1().optional(),
 		notification_condition: NotificationConditionSchema.optional()
-	}).optional()
+	}).optional(),
+	upgrade: object({ auto_install: boolean$1().optional() }).optional()
 });
 const TuiConfigSchema = object({
 	theme: TuiThemeSchema,
@@ -342550,12 +342552,14 @@ const TuiConfigSchema = object({
 	disablePasteBurst: boolean$1(),
 	editorCommand: string().nullable(),
 	notifications: NotificationsConfigSchema,
+	upgrade: UpgradePreferencesSchema,
 	inlineSuggest: InlineSuggestConfigSchema
 });
 const DEFAULT_NOTIFICATIONS_CONFIG = {
 	enabled: true,
 	condition: "unfocused"
 };
+const DEFAULT_UPGRADE_PREFERENCES = { autoInstall: true };
 /**
 * F2 Tippen-mit-Vorschlag: Code-Sprachen standardmäßig an, md/plain aus.
 * Unbekannte Sprachen fallen auf "an" zurück (Opt-out über tui.toml).
@@ -342573,6 +342577,7 @@ const DEFAULT_TUI_CONFIG = TuiConfigSchema.parse({
 	disablePasteBurst: false,
 	editorCommand: null,
 	notifications: DEFAULT_NOTIFICATIONS_CONFIG,
+	upgrade: DEFAULT_UPGRADE_PREFERENCES,
 	inlineSuggest: { languages: DEFAULT_INLINE_SUGGEST_LANGUAGES }
 });
 /**
@@ -342649,6 +342654,7 @@ function normalizeTuiConfig(config) {
 			enabled: config.notifications?.enabled ?? DEFAULT_NOTIFICATIONS_CONFIG.enabled,
 			condition: config.notifications?.notification_condition ?? DEFAULT_NOTIFICATIONS_CONFIG.condition
 		},
+		upgrade: { autoInstall: config.upgrade?.auto_install ?? DEFAULT_UPGRADE_PREFERENCES.autoInstall },
 		inlineSuggest: { languages: {
 			...DEFAULT_INLINE_SUGGEST_LANGUAGES,
 			...config.inline_suggest?.languages
@@ -342673,6 +342679,9 @@ command = "${escapeTomlBasicString(config.editorCommand ?? "")}" # Empty uses $V
 enabled = ${String(config.notifications.enabled)} # true | false
 notification_condition = "${config.notifications.condition}" # "unfocused" | "always"
 
+[upgrade]
+auto_install = ${String(config.upgrade.autoInstall)} # true | false
+
 # F2 Tippen-mit-Vorschlag: Inline-Suggest je Sprache an/aus (wirkt ohne Neustart)
 [inline_suggest.languages]
 ${renderInlineSuggestLanguages(config.inlineSuggest.languages)}
@@ -420717,6 +420726,7 @@ async function currentTuiConfig(host) {
 		editorCommand: host.state.appState.editorCommand,
 		disablePasteBurst: host.state.appState.disablePasteBurst ?? DEFAULT_TUI_CONFIG.disablePasteBurst,
 		notifications: host.state.appState.notifications,
+		upgrade: host.state.appState.upgrade ?? DEFAULT_UPGRADE_PREFERENCES,
 		inlineSuggest
 	};
 }
@@ -516915,6 +516925,7 @@ function createInitialAppState(input) {
 		editorCommand: input.tuiConfig.editorCommand,
 		disablePasteBurst: input.tuiConfig.disablePasteBurst,
 		notifications: input.tuiConfig.notifications,
+		upgrade: input.tuiConfig.upgrade,
 		availableModels: {},
 		availableProviders: {},
 		sessionTitle: null,

package/package.json

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