blun-king-cli 9.1.169 → 9.1.170

package/bin/assistant-message-offload-policy.cjs

@@ -12,6 +12,7 @@ const SYNTHETIC_TOOL_ARGUMENT_MARKER = JSON.stringify({
   _blun_compacted: '[Old tool call arguments cleared]',
 });
 const TELEGRAM_REPLY_TOOL_RE = /^mcp__[^\s]*telegram[^\s]*__reply$/iu;
+const SYNTHETIC_TOOL_ARGUMENT_SUMMARY_MARKER = '[Historical tool arguments unavailable]';
 
 function shouldOffloadHistoricalAssistantMessage(options = {}) {
   const historyIndex = Number(options.historyIndex);
@@ -109,16 +110,37 @@ function compactHistoricalPostTelegramReplyNarration(messages) {
 function removeSyntheticToolArgumentFailures(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
 
-  const syntheticCallIds = new Set(messages.flatMap((message) => (
+  let summaryChanged = false;
+  const scrubbedMessages = messages.map((message) => {
+    if (message?.origin?.kind !== 'compaction_summary' || !Array.isArray(message.content)) {
+      return message;
+    }
+    let contentChanged = false;
+    const content = message.content.map((part) => {
+      if (part?.type !== 'text' || typeof part.text !== 'string' || !part.text.includes('_blun_compacted')) {
+        return part;
+      }
+      const text = part.text.split(/\r?\n/u).map((line) => (
+        line.includes('_blun_compacted') ? SYNTHETIC_TOOL_ARGUMENT_SUMMARY_MARKER : line
+      )).join('\n');
+      contentChanged = true;
+      return { ...part, text };
+    });
+    if (!contentChanged) return message;
+    summaryChanged = true;
+    return { ...message, content };
+  });
+
+  const syntheticCallIds = new Set(scrubbedMessages.flatMap((message) => (
     message?.role === 'assistant' && Array.isArray(message.toolCalls)
       ? message.toolCalls
         .filter((call) => call?.arguments === SYNTHETIC_TOOL_ARGUMENT_MARKER)
         .map((call) => call?.id)
       : []
   )).filter((id) => typeof id === 'string' && id.length > 0));
-  if (syntheticCallIds.size === 0) return messages;
+  if (syntheticCallIds.size === 0) return summaryChanged ? scrubbedMessages : messages;
 
-  return messages.flatMap((message) => {
+  return scrubbedMessages.flatMap((message) => {
     if (message?.role === 'tool' && syntheticCallIds.has(message.toolCallId)) return [];
     if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) return [message];
 

package/bin/launcher-runtime.js

@@ -29,13 +29,18 @@ const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-
 const {
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
+  RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
   activateRuntime,
   handoffRuntime,
   prepareRunningUpdate,
   readActiveRuntime,
-  resumeArgsForHandoff,
 } = require('./running-update.cjs');
+const {
+  RUNNING_UPDATE_MODES,
+  normalizeRunningUpdateMode,
+  readRunningUpdateMode,
+} = require('./running-update-preference.cjs');
 const {
   ensurePrivateDirectory,
   securePrivateFile,
@@ -224,32 +229,70 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
   let handoffSessionId;
+  let handoffMode;
   let updateStarted = false;
+  let runtimeReady = false;
+  let runningUpdateMode = readRunningUpdateMode(env.BLUN_HOME);
+  const automaticMode = () => runningUpdateMode === RUNNING_UPDATE_MODES.RESUME
+    || runningUpdateMode === RUNNING_UPDATE_MODES.NEW;
+  const announcePrepared = (child) => {
+    if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
+    child.send({
+      type: RUNNING_UPDATE_PREPARED_MESSAGE,
+      version: preparedTarget.version,
+      mode: runningUpdateMode,
+    });
+  };
   const startPreparation = (child) => {
-    if (updateStarted || options.runningUpdate === false) return;
+    if (updateStarted || options.runningUpdate === false || !automaticMode()) return;
     updateStarted = true;
     const sharedHome = env.BLUN_SHARED_HOME;
-    if (typeof sharedHome !== 'string' || sharedHome.length === 0) return;
+    if (typeof sharedHome !== 'string' || sharedHome.length === 0) {
+      updateStarted = false;
+      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;
+      if (target === null) {
+        updateStarted = false;
+        return;
+      }
       preparedTarget = target;
-      child.send({ type: RUNNING_UPDATE_PREPARED_MESSAGE, version: target.version });
+      announcePrepared(child);
     }).catch((error) => {
+      updateStarted = false;
       options.onRunningUpdateError?.(error);
     });
   };
   const core = spawnProtectedCore(args, env, cwd, {
     packageRoot,
     onMessage(message, child) {
-      if (message?.type === RUNTIME_READY_MESSAGE) startPreparation(child);
+      if (message?.type === RUNTIME_READY_MESSAGE) {
+        runtimeReady = true;
+        startPreparation(child);
+      }
+      if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
+        runningUpdateMode = normalizeRunningUpdateMode(message.mode);
+        handoffSessionId = undefined;
+        handoffMode = undefined;
+        if (automaticMode()) {
+          if (preparedTarget !== undefined) announcePrepared(child);
+          else if (runtimeReady) {
+            updateStarted = false;
+            startPreparation(child);
+          }
+        }
+      }
       if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
         && typeof message.sessionId === 'string'
-        && message.sessionId.length > 0) {
+        && message.sessionId.length > 0
+        && message.mode === runningUpdateMode
+        && automaticMode()) {
         handoffSessionId = message.sessionId;
+        handoffMode = runningUpdateMode;
       }
     },
   });
@@ -259,11 +302,13 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   if (result.error) throw result.error;
   if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
     && preparedTarget !== undefined
-    && handoffSessionId !== undefined) {
+    && handoffSessionId !== undefined
+    && handoffMode !== undefined) {
     const handoff = await handoffRuntime({
       target: preparedTarget,
       previous: { packageRoot, version: readPackageVersion() },
       sessionId: handoffSessionId,
+      mode: handoffMode,
       args,
       probeTarget: options.probeRunningUpdate || (() => true),
       stopOld: async () => {},

package/bin/recurring-cron-history-policy.cjs

@@ -2,6 +2,7 @@
 
 const RECURRING_CRON_CONTEXT_MAX_MESSAGES = 24;
 const RECURRING_CRON_CONTEXT_MAX_CHARS = 48_000;
+const TRUNCATED_CONTEXT_MARKER = '\n[...context truncated...]';
 
 function recurringCronJobId(message) {
   if (message?.role !== 'user') return null;
@@ -43,6 +44,28 @@ function isRecurringCronSegment(segment) {
   return recurringCronJobId(segment[0]) !== null;
 }
 
+function projectSegmentInstruction(segment, maxChars) {
+  const message = segment[0];
+  if (message?.role !== 'user' || !Array.isArray(message.content) || maxChars <= 0) return null;
+  let remaining = maxChars;
+  const content = [];
+  for (const part of message.content) {
+    if (part?.type !== 'text' || typeof part.text !== 'string' || remaining <= 0) continue;
+    if (part.text.length <= remaining) {
+      content.push(part);
+      remaining -= part.text.length;
+      continue;
+    }
+    const marker = remaining > TRUNCATED_CONTEXT_MARKER.length
+      ? TRUNCATED_CONTEXT_MARKER
+      : '';
+    const text = `${part.text.slice(0, remaining - marker.length)}${marker}`;
+    if (text.length > 0) content.push({ ...part, text });
+    remaining = 0;
+  }
+  return content.length === 0 ? null : { ...message, content };
+}
+
 function projectRecurringCronHistory(history, jobId) {
   if (!Array.isArray(history) || history.length === 0) return history;
   const normalizedJobId = String(jobId || '').trim();
@@ -75,7 +98,16 @@ function projectRecurringCronHistory(history, jobId) {
     if (
       nextMessages > RECURRING_CRON_CONTEXT_MAX_MESSAGES
       || nextChars > RECURRING_CRON_CONTEXT_MAX_CHARS
-    ) break;
+    ) {
+      if (selected.length === 0 && selectedMessages < RECURRING_CRON_CONTEXT_MAX_MESSAGES) {
+        const instruction = projectSegmentInstruction(
+          segment,
+          RECURRING_CRON_CONTEXT_MAX_CHARS - selectedChars,
+        );
+        if (instruction !== null) selected.unshift([instruction]);
+      }
+      break;
+    }
     selected.unshift(segment);
     selectedMessages = nextMessages;
     selectedChars = nextChars;

package/bin/running-update-preference.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+
+const { ensurePrivateDirectory, securePrivateFile, writePrivateFile } = require('./private-paths');
+
+const RUNNING_UPDATE_PREFERENCE_FILE = 'running-update.json';
+const RUNNING_UPDATE_MODES = Object.freeze({
+  MANUAL: 'manual',
+  RESUME: 'resume',
+  NEW: 'new',
+  OFF: 'off',
+});
+const DEFAULT_RUNNING_UPDATE_MODE = RUNNING_UPDATE_MODES.RESUME;
+const VALID_MODES = new Set(Object.values(RUNNING_UPDATE_MODES));
+
+function preferencePath(profileHome) {
+  return path.join(path.resolve(profileHome), RUNNING_UPDATE_PREFERENCE_FILE);
+}
+
+function normalizeRunningUpdateMode(value) {
+  return typeof value === 'string' && VALID_MODES.has(value)
+    ? value
+    : DEFAULT_RUNNING_UPDATE_MODE;
+}
+
+function readRunningUpdateMode(profileHome) {
+  try {
+    const filePath = preferencePath(profileHome);
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024) {
+      return DEFAULT_RUNNING_UPDATE_MODE;
+    }
+    const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return normalizeRunningUpdateMode(record?.mode);
+  } catch {
+    return DEFAULT_RUNNING_UPDATE_MODE;
+  }
+}
+
+function writeRunningUpdateMode(profileHome, mode) {
+  if (!VALID_MODES.has(mode)) throw new Error('RUNNING_UPDATE_MODE_INVALID');
+  const home = path.resolve(profileHome);
+  const filePath = preferencePath(home);
+  const temporaryPath = path.join(home, `.${RUNNING_UPDATE_PREFERENCE_FILE}.${process.pid}.${randomUUID()}.tmp`);
+  ensurePrivateDirectory(home);
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({ mode })}\n`);
+    fs.renameSync(temporaryPath, filePath);
+    securePrivateFile(filePath);
+  } catch (error) {
+    fs.rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+  return mode;
+}
+
+module.exports = {
+  DEFAULT_RUNNING_UPDATE_MODE,
+  RUNNING_UPDATE_MODES,
+  RUNNING_UPDATE_PREFERENCE_FILE,
+  normalizeRunningUpdateMode,
+  preferencePath,
+  readRunningUpdateMode,
+  writeRunningUpdateMode,
+};

package/bin/running-update.cjs

@@ -16,6 +16,7 @@ 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 RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
 const RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
 const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
 
@@ -77,8 +78,13 @@ function resumeArgsForHandoff(args, sessionId) {
   return [...filtered, '--resume', sessionId];
 }
 
+function handoffArgsForMode(args, mode, sessionId) {
+  const withoutSession = resumeArgsForHandoff(args, sessionId).slice(0, -2);
+  return mode === 'new' ? withoutSession : [...withoutSession, '--resume', sessionId];
+}
+
 async function handoffRuntime(options) {
-  const handoffArgs = resumeArgsForHandoff(options.args, options.sessionId);
+  const handoffArgs = handoffArgsForMode(options.args, options.mode || 'resume', options.sessionId);
   if (!await options.probeTarget(options.target)) {
     return { kind: 'probe-failed', runtime: options.previous };
   }
@@ -374,11 +380,13 @@ module.exports = {
   ACTIVE_RUNTIME_FILE,
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
+  RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_READY_MESSAGE,
   activateRuntime,
   activeRuntimePath,
   defaultProbeRuntime,
+  handoffArgsForMode,
   handoffRuntime,
   isSafeRuntimeBoundary,
   prepareRunningUpdate,

package/bin/turn-tool-performance-policy.cjs

@@ -13,6 +13,14 @@ const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
     'recent', 'update', 'updates',
   ]),
   Object.freeze(['history', 'log', 'logs', 'protokoll', 'transcript', 'verlauf']),
+  Object.freeze([
+    'fact', 'facts', 'fakt', 'fakten', 'memory', 'memories', 'merk', 'merken', 'note', 'notes',
+    'persist', 'persistent', 'profile', 'remember', 'save', 'speichern', 'store',
+  ]),
+]);
+const TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS = new Set([
+  'fact', 'facts', 'fakt', 'fakten', 'memory', 'memories', 'merk', 'merken', 'note', 'notes',
+  'persist', 'persistent', 'profile', 'remember', 'save', 'speichern', 'store',
 ]);
 const CORE_TOOL_NAMES = Object.freeze([
   'Bash',
@@ -89,8 +97,8 @@ function searchRelatedDeferredTools(tools, query) {
   const searchTokens = tokens
     .filter((token) => !token.startsWith('+'))
     .filter((token) => !TOOL_SEARCH_INTENT_WORDS.has(token));
-  if (searchTokens.length < 2) return [];
-  const minimumMatchedTokens = Math.max(2, Math.ceil(searchTokens.length * 0.75));
+  if (searchTokens.length < 2 && !TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS.has(searchTokens[0])) return [];
+  const minimumMatchedTokens = searchTokens.length === 1 ? 1 : Math.max(2, Math.ceil(searchTokens.length * 0.75));
 
   return tools.map((tool) => {
     const name = String(tool?.name || '').toLowerCase();

package/blun.mjs

@@ -340604,6 +340604,110 @@ registerUiCatalogFragment({
 		"auth.warning.oauthCleanupFailed": "Klíč API je aktivní, ale předchozí přihlašovací údaje OAuth nebyly zcela odstraněny."
 	}
 });
+registerUiCatalogFragment({
+	en: {
+		"command.update.description": "Configure updates",
+		"command.premortem.description": "Stress-test a plan before execution",
+		"premortem.usage": "Usage: /premortem <plan or decision>",
+		"update.title": "Update behavior",
+		"update.hint": "↑↓ navigate · Enter select · Esc cancel",
+		"update.manual.label": "Manual updates",
+		"update.manual.description": "Only update when you run the update command.",
+		"update.resume.label": "Automatic: resume session",
+		"update.resume.description": "When idle, install the update and resume the current session.",
+		"update.new.label": "Automatic: new session",
+		"update.new.description": "When idle, install the update and start a new session.",
+		"update.off.label": "Automatic updates off",
+		"update.off.description": "Do not check for or install updates automatically.",
+		"update.saved": "Update behavior saved: {mode}",
+		"update.saveFailed": "Could not save update behavior: {error}"
+	},
+	de: {
+		"command.update.description": "Updates konfigurieren",
+		"command.premortem.description": "Einen Plan vor der Umsetzung auf Schwachstellen prüfen",
+		"premortem.usage": "Verwendung: /premortem <Plan oder Entscheidung>",
+		"update.title": "Update-Verhalten",
+		"update.hint": "↑↓ navigieren · Enter auswählen · Esc abbrechen",
+		"update.manual.label": "Updates von Hand",
+		"update.manual.description": "Nur aktualisieren, wenn du den Update-Befehl startest.",
+		"update.resume.label": "Automatisch: Sitzung fortsetzen",
+		"update.resume.description": "Im Leerlauf das Update installieren und die laufende Sitzung fortsetzen.",
+		"update.new.label": "Automatisch: neue Sitzung",
+		"update.new.description": "Im Leerlauf das Update installieren und eine neue Sitzung starten.",
+		"update.off.label": "Automatische Updates aus",
+		"update.off.description": "Nicht automatisch nach Updates suchen oder sie installieren.",
+		"update.saved": "Update-Verhalten gespeichert: {mode}",
+		"update.saveFailed": "Update-Verhalten konnte nicht gespeichert werden: {error}"
+	},
+	es: {
+		"command.update.description": "Configurar actualizaciones",
+		"command.premortem.description": "Someter un plan a una prueba de estrés antes de ejecutarlo",
+		"premortem.usage": "Uso: /premortem <plan o decisión>",
+		"update.title": "Comportamiento de las actualizaciones",
+		"update.hint": "↑↓ navegar · Enter seleccionar · Esc cancelar",
+		"update.manual.label": "Actualizaciones manuales",
+		"update.manual.description": "Actualizar solo cuando ejecutes el comando de actualización.",
+		"update.resume.label": "Automático: reanudar sesión",
+		"update.resume.description": "Cuando esté inactivo, instalar la actualización y reanudar la sesión actual.",
+		"update.new.label": "Automático: nueva sesión",
+		"update.new.description": "Cuando esté inactivo, instalar la actualización e iniciar una sesión nueva.",
+		"update.off.label": "Actualizaciones automáticas desactivadas",
+		"update.off.description": "No buscar ni instalar actualizaciones automáticamente.",
+		"update.saved": "Comportamiento de las actualizaciones guardado: {mode}",
+		"update.saveFailed": "No se pudo guardar el comportamiento de las actualizaciones: {error}"
+	},
+	fr: {
+		"command.update.description": "Configurer les mises à jour",
+		"command.premortem.description": "Mettre un plan à l’épreuve avant son exécution",
+		"premortem.usage": "Utilisation : /premortem <plan ou décision>",
+		"update.title": "Comportement des mises à jour",
+		"update.hint": "↑↓ naviguer · Entrée sélectionner · Échap annuler",
+		"update.manual.label": "Mises à jour manuelles",
+		"update.manual.description": "Mettre à jour uniquement lorsque vous exécutez la commande de mise à jour.",
+		"update.resume.label": "Automatique : reprendre la session",
+		"update.resume.description": "En cas d’inactivité, installer la mise à jour et reprendre la session en cours.",
+		"update.new.label": "Automatique : nouvelle session",
+		"update.new.description": "En cas d’inactivité, installer la mise à jour et démarrer une nouvelle session.",
+		"update.off.label": "Mises à jour automatiques désactivées",
+		"update.off.description": "Ne pas rechercher ni installer automatiquement les mises à jour.",
+		"update.saved": "Comportement des mises à jour enregistré : {mode}",
+		"update.saveFailed": "Impossible d’enregistrer le comportement des mises à jour : {error}"
+	},
+	sv: {
+		"command.update.description": "Konfigurera uppdateringar",
+		"command.premortem.description": "Stresstesta en plan före genomförandet",
+		"premortem.usage": "Användning: /premortem <plan eller beslut>",
+		"update.title": "Uppdateringsbeteende",
+		"update.hint": "↑↓ navigera · Enter välj · Esc avbryt",
+		"update.manual.label": "Manuella uppdateringar",
+		"update.manual.description": "Uppdatera endast när du kör uppdateringskommandot.",
+		"update.resume.label": "Automatiskt: återuppta sessionen",
+		"update.resume.description": "Installera uppdateringen vid inaktivitet och återuppta den aktuella sessionen.",
+		"update.new.label": "Automatiskt: ny session",
+		"update.new.description": "Installera uppdateringen vid inaktivitet och starta en ny session.",
+		"update.off.label": "Automatiska uppdateringar av",
+		"update.off.description": "Sök inte efter och installera inte uppdateringar automatiskt.",
+		"update.saved": "Uppdateringsbeteende sparat: {mode}",
+		"update.saveFailed": "Det gick inte att spara uppdateringsbeteendet: {error}"
+	},
+	cs: {
+		"command.update.description": "Nastavit aktualizace",
+		"command.premortem.description": "Prověřit plán před provedením zátěžovým testem",
+		"premortem.usage": "Použití: /premortem <plán nebo rozhodnutí>",
+		"update.title": "Chování aktualizací",
+		"update.hint": "↑↓ navigace · Enter vybrat · Esc zrušit",
+		"update.manual.label": "Ruční aktualizace",
+		"update.manual.description": "Aktualizovat pouze po spuštění příkazu pro aktualizaci.",
+		"update.resume.label": "Automaticky: pokračovat v relaci",
+		"update.resume.description": "Při nečinnosti nainstalovat aktualizaci a pokračovat v aktuální relaci.",
+		"update.new.label": "Automaticky: nová relace",
+		"update.new.description": "Při nečinnosti nainstalovat aktualizaci a spustit novou relaci.",
+		"update.off.label": "Automatické aktualizace vypnuty",
+		"update.off.description": "Nevyhledávat ani neinstalovat aktualizace automaticky.",
+		"update.saved": "Chování aktualizací uloženo: {mode}",
+		"update.saveFailed": "Chování aktualizací se nepodařilo uložit: {error}"
+	}
+});
 //#endregion
 //#region src/tui/i18n/catalogs/common.ts
 registerUiCatalogFragment({
@@ -402579,6 +402683,20 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 		priority: 100,
 		availability: "always"
 	},
+	{
+		name: "update",
+		aliases: [],
+		descriptionKey: "command.update.description",
+		priority: 100,
+		availability: "always"
+	},
+	{
+		name: "premortem",
+		aliases: [],
+		descriptionKey: "command.premortem.description",
+		priority: 95,
+		availability: "idle-only"
+	},
 	{
 		name: "output-style",
 		aliases: ["style"],
@@ -494677,6 +494795,63 @@ async function executeSlashCommand(host, input) {
 			return;
 	}
 }
+async function handleUpdateCommand(host) {
+	const profileHome = process.env["BLUN_HOME"];
+	if (typeof profileHome !== "string" || profileHome.length === 0) {
+		host.showError(uiText("update.saveFailed", { error: "BLUN_HOME" }));
+		return;
+	}
+	const currentMode = readRunningUpdateMode(profileHome);
+	const selectedMode = await new Promise((resolve) => {
+		host.mountEditorReplacement(new ChoicePickerComponent({
+			title: uiText("update.title"),
+			hint: uiText("update.hint"),
+			currentValue: currentMode,
+			options: Object.values(RUNNING_UPDATE_MODES).map((mode) => ({
+				value: mode,
+				label: uiText(`update.${mode}.label`),
+				description: uiText(`update.${mode}.description`)
+			})),
+			onSelect: resolve,
+			onCancel: () => resolve(void 0)
+		}));
+	});
+	host.restoreEditor();
+	if (selectedMode === void 0) return;
+	try {
+		writeRunningUpdateMode(profileHome, selectedMode);
+	} catch (error) {
+		host.showError(uiText("update.saveFailed", { error: formatErrorMessage$2(error) }));
+		return;
+	}
+	host.runningUpdatePreparedVersion = void 0;
+	host.runningUpdatePreparedMode = void 0;
+	host.runningUpdateHandoffStarted = false;
+	if (process.connected) try {
+		process.send({ type: RUNNING_UPDATE_MODE_MESSAGE, mode: selectedMode });
+	} catch {}
+	host.showStatus(uiText("update.saved", { mode: uiText(`update.${selectedMode}.label`) }), "success");
+}
+function buildPremortemPrompt(plan) {
+	return `<premortem-mode>
+Assume this plan failed six months from now. Identify the most plausible failure modes, their early warning signs, concrete preventive measures, and explicit stop or decision points. Rank findings by impact and likelihood. Separate evidence from assumptions. End with the three actions that reduce the most risk.
+
+Plan or decision:
+${plan}
+</premortem-mode>`;
+}
+async function handlePremortemCommand(host, args) {
+	const plan = args.trim();
+	if (plan.length === 0) {
+		host.showError(uiText("premortem.usage"));
+		return;
+	}
+	if (host.state.appState.model.trim().length === 0 || host.session === void 0) {
+		host.showError(uiText("goal.error.modelNotSet"));
+		return;
+	}
+	host.sendMessage(host.requireSession(), plan, { parts: buildPremortemPrompt(plan) });
+}
 async function handleBuiltInSlashCommand(host, name, args) {
 	switch (name) {
 		case "exit":
@@ -494740,6 +494915,12 @@ async function handleBuiltInSlashCommand(host, name, args) {
 		case "settings":
 			showSettingsSelector(host);
 			return;
+		case "update":
+			await handleUpdateCommand(host);
+			return;
+		case "premortem":
+			await handlePremortemCommand(host, args);
+			return;
 		case "usage":
 			await showUsage(host);
 			return;
@@ -509383,6 +509564,9 @@ var LoopChatIndicatorComponent = class {
 		this.state = state;
 		this.syncTimer(state.loop);
 	}
+	setRefreshHandler(onRefresh) {
+		this.onRefresh = onRefresh;
+	}
 	render(width) {
 		const indicator = formatLoopChatIndicator(this.state.loop, currentTheme.palette);
 		return indicator === null ? [] : [truncateToWidth(indicator, width, "…")];
@@ -514605,10 +514789,16 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 const {
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
 	RUNNING_UPDATE_HANDOFF_MESSAGE,
+	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_READY_MESSAGE,
 	isSafeRuntimeBoundary
 } = __require("./bin/running-update.cjs");
+const {
+	RUNNING_UPDATE_MODES,
+	readRunningUpdateMode,
+	writeRunningUpdateMode
+} = __require("./bin/running-update-preference.cjs");
 function notifyRunningRuntimeReady(tui) {
 	if (!process.connected) return;
 	const sessionId = tui.getCurrentSessionId();
@@ -514621,7 +514811,7 @@ function notifyRunningRuntimeReady(tui) {
 	} catch {}
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
+	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
 	if (!isSafeRuntimeBoundary({
 		isShuttingDown: tui.isShuttingDown,
 		streamingPhase: tui.state.appState.streamingPhase,
@@ -514638,7 +514828,8 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 		process.send({
 			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
 			sessionId,
-			version: tui.runningUpdatePreparedVersion
+			version: tui.runningUpdatePreparedVersion,
+			mode: tui.runningUpdatePreparedMode
 		});
 	} catch {
 		tui.runningUpdateHandoffStarted = false;
@@ -514649,8 +514840,9 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
-		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string") return;
+		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string" || message.mode !== RUNNING_UPDATE_MODES.RESUME && message.mode !== RUNNING_UPDATE_MODES.NEW) return;
 		tui.runningUpdatePreparedVersion = message.version;
+		tui.runningUpdatePreparedMode = message.mode;
 		requestRunningUpdateAtSafeBoundary(tui);
 	};
 	process.on("message", handler);
@@ -514741,6 +514933,7 @@ var BlunTUI = class {
 	startupWorkspaceSelectionPending = false;
 	startupGoalPromptedSessionId;
 	runningUpdatePreparedVersion;
+	runningUpdatePreparedMode;
 	runningUpdateHandoffStarted = false;
 	runningUpdateMessageDispose;
 	startupPhaseMs = {};
@@ -514810,6 +515003,9 @@ var BlunTUI = class {
 		this.startupNotice = invalidAppearance ? combineStartupNotice(startupInput.startupNotice, new TuiConfigParseError(DEFAULT_TUI_CONFIG).message) : startupInput.startupNotice;
 		this.onStartupNoticeShown = startupInput.onStartupNoticeShown;
 		this.state = createTUIState(tuiOptions);
+		this.state.loopIndicator.setRefreshHandler(() => {
+			void this.refreshLoopState();
+		});
 		this.appearanceBasePalette = currentTheme.palette;
 		this.resolvedAutoTheme = currentTheme.palette === lightColors ? "light" : "dark";
 		currentTheme.setPalette(applyAppearanceToPalette(currentTheme.palette, initialAppState.appearance));

package/package.json

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