blun-king-cli 9.1.587 → 9.1.588

package/bin/update-notice.js

@@ -9,6 +9,7 @@ const { StringDecoder } = require('node:string_decoder');
 const { types } = require('node:util');
 
 const { tryAcquireUpdateLease } = require('./update-lease');
+const { resolveUpdateLocale, updateText } = require('./update-copy');
 
 const {
   ensurePrivateDirectory,
@@ -22,7 +23,6 @@ const INSTALL_REGISTRY_URL = 'https://registry.npmjs.org/';
 const FALLBACK_MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
 const SNOOZE_MS = 7 * 24 * 60 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 2_500;
-const UPDATE_SOURCE_RETRY_DELAYS_MS = Object.freeze([250, 750]);
 const STATE_FILE = 'update-notice.json';
 const UPDATE_SKIP_FILE = 'update-skip-version.json';
 const PENDING_UPDATE_FILE = 'update-pending.json';
@@ -35,7 +35,6 @@ const UPDATE_SIGNAL_EXIT_CODES = Object.freeze({
   SIGTERM: 143,
 });
 const INTERACTIVE_START_MODE_FLAGS = new Set([
-  '-c',
   '-y',
   '--auto',
   '--auto-approve',
@@ -48,49 +47,19 @@ const SEMVER_PATTERN = new RegExp(
     + `(?:-(${SEMVER_IDENTIFIER}(?:\\.${SEMVER_IDENTIFIER})*))?`
     + '(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$',
 );
-const LEGACY_MANIFEST_KEYS = Object.freeze([
-  'install',
-  'latest',
-  'minSupported',
-  'name',
-  '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',
   'notesUrl',
-  'releaseNotes',
   'releasedAt',
 ]);
-const RELEASE_NOTES_MAX_COUNT = 8;
-const RELEASE_NOTE_MAX_BYTES = 240;
 const ENDPOINT_LIMITS = new Map([
   [REGISTRY_URL, 1024 * 1024],
   [FALLBACK_MANIFEST_URL, 64 * 1024],
 ]);
 
-function isInternalPackagePinned(packageRoot) {
-  try {
-    const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
-    return manifest?.blunUpdateChannel === 'internal';
-  } catch {
-    return false;
-  }
-}
-
 function parseSemver(value) {
   if (typeof value !== 'string' || value.length > 128) return undefined;
   const match = SEMVER_PATTERN.exec(value);
@@ -210,7 +179,7 @@ function canonicalOfficialNotesUrl(value) {
 
 function isIsoTimestamp(value) {
   if (typeof value !== 'string') return false;
-  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/.exec(value);
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?Z$/.exec(value);
   if (!match) {
     return false;
   }
@@ -225,35 +194,9 @@ function isIsoTimestamp(value) {
     && date.getUTCSeconds() === Number(match[6]);
 }
 
-function parseReleaseNotes(value) {
-  if (!Array.isArray(value) || value.length > RELEASE_NOTES_MAX_COUNT) return undefined;
-  const notes = [];
-  for (const note of value) {
-    if (!isBoundedText(note, RELEASE_NOTE_MAX_BYTES)) return undefined;
-    notes.push(note);
-  }
-  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 record = exactDataRecord(value, MANIFEST_KEYS);
   const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
-  const releaseNotes = record && Object.hasOwn(record, 'releaseNotes')
-    ? parseReleaseNotes(record.releaseNotes)
-    : undefined;
   if (!record
     || record.name !== PACKAGE_NAME
     || !parseSemver(record.latest)
@@ -261,8 +204,6 @@ 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;
   }
@@ -272,8 +213,6 @@ function parseFallbackManifest(value) {
     minSupported: record.minSupported,
     releasedAt: record.releasedAt,
     notesUrl,
-    ...(Object.hasOwn(record, 'integrity') ? { integrity: record.integrity } : {}),
-    ...(releaseNotes === undefined ? {} : { releaseNotes }),
     install: record.install,
   });
 }
@@ -306,14 +245,7 @@ function resolveEffectiveRelease(currentVersion, registryTags, fallbackManifest)
   if (compareSemver(version, currentVersion) <= 0) return undefined;
 
   if (validFallback && compareSemver(validFallback.latest, version) === 0) {
-    return {
-      channel: 'stable',
-      version,
-      notesUrl: validFallback.notesUrl,
-      ...(validFallback.releaseNotes === undefined
-        ? {}
-        : { releaseNotes: validFallback.releaseNotes }),
-    };
+    return { channel: 'stable', version, notesUrl: validFallback.notesUrl };
   }
   return { channel: 'stable', version };
 }
@@ -396,54 +328,10 @@ function requestTrustedJson(url, options = {}) {
   });
 }
 
-function retryableUpdateSourceError(error) {
-  const message = error instanceof Error ? error.message : String(error || '');
-  if (message === 'UPDATE_REQUEST_TIMEOUT') return true;
-  const statusMatch = /^UPDATE_HTTP_STATUS_(\d{3})$/u.exec(message);
-  if (statusMatch) {
-    const status = Number(statusMatch[1]);
-    return status === 408 || status === 425 || status === 429 || status >= 500;
-  }
-  return new Set([
-    'EAI_AGAIN',
-    'ECONNREFUSED',
-    'ECONNRESET',
-    'ENETDOWN',
-    'ENETUNREACH',
-    'ENOTFOUND',
-    'EPIPE',
-    'ETIMEDOUT',
-  ]).has(error?.code);
-}
-
-function sleepForUpdateRetry(delayMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-
-async function requestTrustedJsonWithRetry(url, options = {}) {
-  const request = options.request || requestTrustedJson;
-  const sleep = options.sleep || sleepForUpdateRetry;
-  const configuredDelays = Array.isArray(options.retryDelaysMs)
-    ? options.retryDelaysMs
-    : UPDATE_SOURCE_RETRY_DELAYS_MS;
-  const retryDelaysMs = configuredDelays
-    .slice(0, UPDATE_SOURCE_RETRY_DELAYS_MS.length)
-    .map((value) => (Number.isFinite(value) && value >= 0 ? Math.min(value, 2_000) : 0));
-
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      return await request(url, options);
-    } catch (error) {
-      if (attempt >= retryDelaysMs.length || !retryableUpdateSourceError(error)) throw error;
-      await sleep(retryDelaysMs[attempt]);
-    }
-  }
-}
-
-async function loadReleaseSources(options = {}) {
+async function loadReleaseSources() {
   const [registry, fallback] = await Promise.allSettled([
-    requestTrustedJsonWithRetry(REGISTRY_URL, options),
-    requestTrustedJsonWithRetry(FALLBACK_MANIFEST_URL, options),
+    requestTrustedJson(REGISTRY_URL),
+    requestTrustedJson(FALLBACK_MANIFEST_URL),
   ]);
   return {
     registryDocument: registry.status === 'fulfilled' ? registry.value : undefined,
@@ -455,9 +343,8 @@ function statePath(blunDir) {
   return path.join(blunDir, STATE_FILE);
 }
 
-function readSnoozeState(blunDir, targetVersion, now = Date.now()) {
+function readSnoozeState(blunDir, now = Date.now()) {
   try {
-    if (!parseSemver(targetVersion)) return false;
     const filePath = statePath(blunDir);
     if (!fs.existsSync(filePath)) return false;
     securePrivateFile(filePath);
@@ -465,13 +352,10 @@ function readSnoozeState(blunDir, targetVersion, now = Date.now()) {
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_024) return false;
     const record = exactDataRecord(JSON.parse(fs.readFileSync(filePath, 'utf8')), [
       'snoozedUntil',
-      'targetVersion',
       'version',
     ]);
     if (!record
-      || record.version !== 2
-      || record.targetVersion !== targetVersion
-      || !parseSemver(record.targetVersion)
+      || record.version !== 1
       || !Number.isSafeInteger(record.snoozedUntil)
       || record.snoozedUntil <= now
       || record.snoozedUntil > now + SNOOZE_MS) {
@@ -483,8 +367,7 @@ function readSnoozeState(blunDir, targetVersion, now = Date.now()) {
   }
 }
 
-function writeSnoozeState(blunDir, targetVersion, now = Date.now()) {
-  if (!parseSemver(targetVersion)) throw new Error('INVALID_UPDATE_VERSION');
+function writeSnoozeState(blunDir, now = Date.now()) {
   ensurePrivateDirectory(blunDir);
   const filePath = statePath(blunDir);
   const temporaryPath = path.join(
@@ -493,8 +376,7 @@ function writeSnoozeState(blunDir, targetVersion, now = Date.now()) {
   );
   try {
     writePrivateFile(temporaryPath, `${JSON.stringify({
-      version: 2,
-      targetVersion,
+      version: 1,
       snoozedUntil: now + SNOOZE_MS,
     })}\n`);
     const handle = fs.openSync(temporaryPath, 'r+');
@@ -566,18 +448,56 @@ function pendingUpdatePath(blunDir) {
   return path.join(blunDir, PENDING_UPDATE_FILE);
 }
 
+function readPendingUpdate(blunDir) {
+  try {
+    const filePath = pendingUpdatePath(blunDir);
+    if (!fs.existsSync(filePath)) return undefined;
+    securePrivateFile(filePath);
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_024) return undefined;
+    const record = exactDataRecord(JSON.parse(fs.readFileSync(filePath, 'utf8')), [
+      'targetVersion',
+      'version',
+    ]);
+    if (!record || record.version !== 1 || !parseSemver(record.targetVersion)) return undefined;
+    return record.targetVersion;
+  } catch {
+    return undefined;
+  }
+}
+
+function writePendingUpdate(blunDir, targetVersion) {
+  if (!parseSemver(targetVersion)) throw new Error('INVALID_UPDATE_VERSION');
+  ensurePrivateDirectory(blunDir);
+  const filePath = pendingUpdatePath(blunDir);
+  const temporaryPath = path.join(
+    blunDir,
+    `.${PENDING_UPDATE_FILE}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({
+      version: 1,
+      targetVersion,
+    })}\n`);
+    const handle = fs.openSync(temporaryPath, 'r+');
+    try {
+      fs.fsyncSync(handle);
+    } finally {
+      fs.closeSync(handle);
+    }
+    fs.renameSync(temporaryPath, filePath);
+    securePrivateFile(filePath);
+  } catch (error) {
+    fs.rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+}
+
 function clearPendingUpdate(blunDir) {
   fs.rmSync(pendingUpdatePath(blunDir), { force: true });
 }
 
-function writeCoreInstallSuccess(
-  blunDir,
-  fromVersion,
-  version,
-  releaseNotes,
-  initiatedBy,
-  now = Date.now(),
-) {
+function writeCoreInstallSuccess(blunDir, fromVersion, version, now = Date.now()) {
   if (!parseSemver(fromVersion) || !parseSemver(version)) {
     throw new Error('INVALID_UPDATE_VERSION');
   }
@@ -596,8 +516,6 @@ function writeCoreInstallSuccess(
       lastSuccess: {
         version,
         fromVersion,
-        ...(releaseNotes === undefined ? {} : { releaseNotes }),
-        initiatedBy,
         installedAt: new Date(now).toISOString(),
         notifiedAt: null,
       },
@@ -630,64 +548,6 @@ 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}).`,
-      invalidCurrentVersion: 'Die installierte Versionsnummer ist ungültig. Das Update wurde nicht gestartet.',
-      updateBusy: 'Update gesperrt. Beende laufende King-Sitzungen nach Abschluss ihrer Arbeit regulär und warte, bis andere Updates fertig sind. Bleibt die Sperre bestehen, muss ihr Zustand geprüft werden.',
-      leaseUnavailable: 'Die Updatesperre konnte nicht geprüft werden. Das Update wurde nicht gestartet.',
-      privateHomeUnavailable: 'Das private BLUN-Verzeichnis konnte nicht abgesichert werden. Das Update wurde nicht gestartet.',
-      installerUnavailable: 'Der geschützte Installer konnte nicht vorbereitet werden.',
-      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}).`,
-    invalidCurrentVersion: 'The installed version number is invalid. The update has not started.',
-    updateBusy: 'Update blocked. Finish and close running King sessions normally, and wait for other updates to finish. If it remains blocked, the lock state needs to be checked.',
-    leaseUnavailable: 'The update lock could not be checked. The update has not started.',
-    privateHomeUnavailable: 'The private BLUN directory could not be secured. The update has not started.',
-    installerUnavailable: 'The protected installer could not be prepared.',
-    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;
@@ -713,14 +573,7 @@ function createUpdateProgress(output) {
   return update;
 }
 
-function promptUpdateAction({
-  currentVersion,
-  release,
-  input,
-  output,
-  processRef = process,
-  uiLocale = 'en',
-}) {
+function promptUpdateAction({ currentVersion, release, input, output, locale = 'en', processRef = process }) {
   return new Promise((resolve, reject) => {
     let selected = 0;
     let settled = false;
@@ -733,14 +586,13 @@ function promptUpdateAction({
     const dim = '\u001B[2m';
     const underline = '\u001B[4m';
     const reset = '\u001B[0m';
-    const copy = updateCopy(uiLocale);
     const actions = [
       {
         choice: 'install',
-        label: copy.install(release.version),
+        label: updateText(locale, 'install', { command: installCommandText(release.version) }),
       },
-      { choice: 'skip-once', label: copy.skip },
-      { choice: 'skip-version', label: copy.nextRelease },
+      { choice: 'skip-once', label: updateText(locale, 'skipOnce') },
+      { choice: 'skip-version', label: updateText(locale, 'skipVersion') },
     ];
     const signalHandlers = new Map();
 
@@ -750,7 +602,7 @@ function promptUpdateAction({
         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}${copy.enter}${reset}\n`);
+      output.write(`\r\u001B[2K${dim}${updateText(locale, 'confirm')}${reset}\n`);
     };
     const cleanup = () => {
       if (escapeTimer !== undefined) clearTimeout(escapeTimer);
@@ -905,9 +757,9 @@ function promptUpdateAction({
         signalHandlers.set(signal, handler);
         processRef.once(signal, handler);
       }
-      output.write(`\n${copy.available(currentVersion, release.version)}\n`);
+      output.write(`\n${updateText(locale, 'available', { currentVersion, targetVersion: release.version })}\n`);
       if (release.notesUrl) {
-        output.write(`${dim}${copy.notes}:${reset} ${underline}${release.notesUrl}${reset}\n`);
+        output.write(`${dim}${updateText(locale, 'releaseNotes')}${reset} ${underline}${release.notesUrl}${reset}\n`);
       }
       output.write('\n');
       cursorHidden = true;
@@ -1365,28 +1217,17 @@ function noReleaseReason(currentVersion, registryTags, fallbackManifest) {
   return parseSemver(latest) || fallbackManifest ? 'current' : 'unavailable';
 }
 
-function explicitNoTarget(stdout, reason, currentVersion, uiLocale) {
-  const copy = updateCopy(uiLocale);
-  stdout.write(reason === 'current'
-    ? `${copy.current(currentVersion)}\n`
-    : `${copy.invalidTarget(currentVersion)}\n`);
+function explicitNoTarget(stdout, reason, currentVersion, locale) {
+  stdout.write(`${updateText(locale, reason === 'current' ? 'noUpdate' : 'noTarget', { currentVersion })}\n`);
   return { kind: 'current', reason };
 }
 
-function explicitFailure(stderr, reason, exitCode, uiLocale) {
-  const copy = updateCopy(uiLocale);
+function explicitFailure(stderr, reason, exitCode, locale) {
   const hasExitCode = Number.isInteger(exitCode) && exitCode !== 0;
   if (hasExitCode) {
-    stderr.write(`${copy.failed(exitCode)}\n`);
+    stderr.write(`${updateText(locale, 'failedCode', { exitCode })}\n`);
   } else {
-    const messages = new Map([
-      ['invalid_current_version', copy.invalidCurrentVersion],
-      ['update_in_progress', copy.updateBusy],
-      ['lease_unavailable', copy.leaseUnavailable],
-      ['private_home_unavailable', copy.privateHomeUnavailable],
-      ['installer_unavailable', copy.installerUnavailable],
-    ]);
-    stderr.write(`${messages.get(reason) || copy.verificationFailed}\n`);
+    stderr.write(`${updateText(locale, 'verifyFailed')}\n`);
   }
   return {
     kind: 'failed',
@@ -1395,6 +1236,19 @@ function explicitFailure(stderr, reason, exitCode, uiLocale) {
   };
 }
 
+function queueExplicitUpdate(blunDir, release, stdout, stderr, locale) {
+  try {
+    ensurePrivateDirectory(blunDir);
+    writePendingUpdate(blunDir, release.version);
+  } catch {
+    return explicitFailure(stderr, 'private_home_unavailable', undefined, locale);
+  }
+  stdout.write(
+    `${updateText(locale, 'queued', { targetVersion: release.version })}\n`,
+  );
+  return { kind: 'queued', version: release.version };
+}
+
 async function runUpdateFlow(options, explicitUpdate) {
   const {
     currentVersion,
@@ -1405,26 +1259,27 @@ async function runUpdateFlow(options, explicitUpdate) {
     stderr,
     blunDir,
   } = options;
-  const uiLocale = options.uiLocale || 'en';
-  const copy = updateCopy(uiLocale);
+  const locale = resolveUpdateLocale(options);
   if (!explicitUpdate && !isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
     return { kind: 'continue', reason: 'not_interactive' };
   }
   if (!parseSemver(currentVersion)) {
     return explicitUpdate
-      ? explicitFailure(stderr, 'invalid_current_version', undefined, uiLocale)
+      ? explicitFailure(stderr, 'invalid_current_version', undefined, locale)
       : { kind: 'continue', reason: 'invalid_current_version' };
   }
 
+  let pendingVersion = readPendingUpdate(blunDir);
+  if (pendingVersion !== undefined && compareSemver(currentVersion, pendingVersion) >= 0) {
+    clearPendingUpdate(blunDir);
+    pendingVersion = undefined;
+  }
   const now = (options.now || Date.now)();
+  if (!explicitUpdate && pendingVersion === undefined && readSnoozeState(blunDir, now)) {
+    return { kind: 'continue', reason: 'snoozed' };
+  }
 
   const packageRoot = path.resolve(options.packageRoot || path.resolve(__dirname, '..'));
-  if (isInternalPackagePinned(packageRoot)) {
-    if (explicitUpdate) explicitNoTarget(stdout, 'current', currentVersion, uiLocale);
-    return explicitUpdate
-      ? { kind: 'current', reason: 'internal_channel' }
-      : { kind: 'continue', reason: 'internal_channel' };
-  }
   let leaseResult;
   const ownsNoticeLease = options.noticeLease === undefined;
   if (ownsNoticeLease) {
@@ -1432,7 +1287,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       leaseResult = await (options.acquireLease || tryAcquireUpdateLease)({ packageRoot });
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, locale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
   } else {
@@ -1444,7 +1299,7 @@ async function runUpdateFlow(options, explicitUpdate) {
         stderr,
         leaseResult?.reason === 'busy' ? 'update_in_progress' : 'lease_unavailable',
         undefined,
-        uiLocale,
+        locale,
       );
     }
     return leaseResult?.reason === 'busy'
@@ -1455,12 +1310,17 @@ async function runUpdateFlow(options, explicitUpdate) {
   let installerSession;
 
   try {
+    if (!explicitUpdate
+      && pendingVersion === undefined
+      && readSnoozeState(blunDir, (options.now || Date.now)())) {
+      return { kind: 'continue', reason: 'snoozed' };
+    }
     let sources;
     try {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
     } catch {
       return explicitUpdate
-        ? explicitNoTarget(stdout, 'unavailable', currentVersion, uiLocale)
+        ? explicitNoTarget(stdout, 'unavailable', currentVersion, locale)
         : { kind: 'continue', reason: 'unavailable' };
     }
     const registryTags = parseRegistryDocument(sources?.registryDocument);
@@ -1469,51 +1329,47 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (!release) {
       const reason = noReleaseReason(currentVersion, registryTags, fallbackManifest);
       return explicitUpdate
-        ? explicitNoTarget(stdout, reason, currentVersion, uiLocale)
+        ? explicitNoTarget(stdout, reason, currentVersion, locale)
         : { kind: 'continue', reason };
     }
-    if (!explicitUpdate
-      && readSnoozeState(blunDir, release.version, now)) {
-      return { kind: 'continue', reason: 'snoozed' };
-    }
+    const queuedForRelease = pendingVersion === release.version;
     const initialInstallLease = await probeInstallLease(options, packageRoot);
     if (initialInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
+        ? queueExplicitUpdate(blunDir, release, stdout, stderr, locale)
         : { kind: 'update_in_progress' };
     }
     if (initialInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, locale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
-    if (!explicitUpdate
-      && readSkippedVersion(blunDir) === release.version) {
+    if (!explicitUpdate && !queuedForRelease && readSkippedVersion(blunDir) === release.version) {
       return { kind: 'continue', reason: 'skipped_version' };
     }
-    if (explicitUpdate) {
+    if (explicitUpdate || queuedForRelease) {
       try {
         ensurePrivateDirectory(blunDir);
       } catch {
-        return explicitFailure(stderr, 'private_home_unavailable', undefined, uiLocale);
+        return explicitFailure(stderr, 'private_home_unavailable', undefined, locale);
       }
     }
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
+        ? explicitFailure(stderr, 'update_in_progress', undefined, locale)
         : { kind: 'update_in_progress' };
     }
     const prePromptInstallLease = await probeInstallLease(options, packageRoot);
     if (prePromptInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
+        ? queueExplicitUpdate(blunDir, release, stdout, stderr, locale)
         : { kind: 'update_in_progress' };
     }
     if (prePromptInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, locale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!options.installVersion) {
@@ -1523,7 +1379,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       );
       if (!installerSession?.ready) {
         if (explicitUpdate) {
-          return explicitFailure(stderr, 'installer_unavailable', undefined, uiLocale);
+          return explicitFailure(stderr, 'installer_unavailable', undefined, locale);
         }
         return installerSession?.reason === 'failed'
           ? { kind: 'continue', reason: 'installer_unavailable' }
@@ -1531,7 +1387,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
     }
     let action;
-    if (explicitUpdate || options.autoInstall === true) {
+    if (explicitUpdate || queuedForRelease) {
       action = 'install';
     } else {
       try {
@@ -1540,17 +1396,14 @@ async function runUpdateFlow(options, explicitUpdate) {
           release,
           input: stdin,
           output: stdout,
-          uiLocale,
+          locale,
         });
       } catch {
         return { kind: 'continue', reason: 'prompt_failed' };
       }
     }
     if (action !== 'install') {
-      if (installerSession?.ready) {
-        await installerSession.cancel();
-        installerSession = undefined;
-      }
+      if (installerSession?.ready) await installerSession.cancel();
       if (action === 'skip-once') {
         return { kind: 'continue', reason: 'skipped_once' };
       }
@@ -1563,7 +1416,7 @@ async function runUpdateFlow(options, explicitUpdate) {
         return { kind: 'continue', reason: 'skipped_version' };
       }
       try {
-        writeSnoozeState(blunDir, release.version, (options.now || Date.now)());
+        writeSnoozeState(blunDir, (options.now || Date.now)());
       } catch {
         // A failed preference write must not block the existing console.
       }
@@ -1571,18 +1424,18 @@ async function runUpdateFlow(options, explicitUpdate) {
     }
 
     const updateProgress = createUpdateProgress(stdout);
-    updateProgress(1, copy.updateChecked);
-    updateProgress(2, copy.installerReady);
+    updateProgress(1, updateText(locale, 'progressChecked'));
+    updateProgress(2, updateText(locale, 'installerReady'));
 
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
+        ? explicitFailure(stderr, 'update_in_progress', undefined, locale)
         : { kind: 'update_in_progress' };
     }
     let installResult;
-    updateProgress(3, copy.installing);
+    updateProgress(3, updateText(locale, 'installing'));
     try {
       installResult = options.installVersion
         ? await options.installVersion(release.version)
@@ -1595,48 +1448,42 @@ async function runUpdateFlow(options, explicitUpdate) {
       || installResult?.unknownState === true) {
       updateProgress.finish();
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
+        ? explicitFailure(stderr, 'update_in_progress', undefined, locale)
         : { kind: 'update_in_progress' };
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
-      updateProgress(4, copy.installed);
+      updateProgress(4, updateText(locale, 'installVerified'));
       clearPendingUpdate(blunDir);
       try {
         writeCoreInstallSuccess(
           blunDir,
           currentVersion,
           release.version,
-          release.releaseNotes,
-          explicitUpdate ? 'manual' : options.autoInstall === true ? 'startup_auto' : 'startup_prompt',
           (options.now || Date.now)(),
         );
       } catch {
-        stderr.write(`${copy.startupNoticeFailed(release.version)}\n`);
+        stderr.write(
+          `${updateText(locale, 'stateWarning', { targetVersion: release.version })}\n`,
+        );
       }
-      const continuesLastSession = Array.isArray(options.argv)
-        && options.argv.length === 1
-        && options.argv[0] === '-c';
-      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,
-      };
+      stdout.write(
+        `${updateText(locale, 'success', { currentVersion, targetVersion: release.version })}\n`,
+      );
+      if (release.notesUrl) stdout.write(`${updateText(locale, 'releaseNotes')} ${release.notesUrl}\n`);
+      return { kind: 'installed', version: release.version };
     }
 
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {
       updateProgress.finish();
       if (explicitUpdate) {
-        return explicitFailure(stderr, 'install_failed', installResult.code, uiLocale);
+        return explicitFailure(stderr, 'install_failed', installResult.code, locale);
       }
-      stderr.write(`${copy.installFailed(installResult.code)}\n`);
+      stderr.write(`${updateText(locale, 'failedContinue', { exitCode: installResult.code })}\n`);
       return { kind: 'continue', reason: 'install_failed', exitCode: installResult.code };
     }
     updateProgress.finish();
-    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed', undefined, uiLocale);
-    stderr.write(`${copy.verificationRestart}\n`);
+    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed', undefined, locale);
+    stderr.write(`${updateText(locale, 'verifyRestart')}\n`);
     return { kind: 'update_in_progress' };
   } finally {
     if (installerSession?.ready) {
@@ -1652,7 +1499,7 @@ async function runUpdateFlow(options, explicitUpdate) {
   }
 }
 
-async function runExplicitUpdate(options) {
+function runExplicitUpdate(options) {
   return runUpdateFlow(options, true);
 }
 
@@ -1668,7 +1515,6 @@ module.exports = {
   compareSemver,
   createInstallInvocation,
   installPinnedVersion,
-  isInternalPackagePinned,
   preparePinnedInstaller,
   isInteractiveUpdateStart,
   loadReleaseSources,
@@ -1678,10 +1524,11 @@ module.exports = {
   readSkippedVersion,
   readSnoozeState,
   requestTrustedJson,
-  requestTrustedJsonWithRetry,
   resolveEffectiveRelease,
+  resolveUpdateLocale,
   runExplicitUpdate,
   runUpdateNotice,
+  updateText,
   writeSkippedVersion,
   writeSnoozeState,
 };