blun-king-cli 9.1.23 → 9.1.24

package/bin/blun.js

@@ -313,9 +313,9 @@ function connectRuntimeBroker(endpoint) {
   });
 }
 
-async function connectExistingRuntimeLease() {
+async function connectExistingRuntimeLease(timeoutMs = 3_000) {
   const endpoint = deriveLeaseEndpoint('runtime');
-  const deadline = Date.now() + 3_000;
+  const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const connected = await connectRuntimeBroker(endpoint);
     if (connected.acquired) return connected;
@@ -328,18 +328,17 @@ async function main() {
   const explicitUpdateRequest = process.argv.length === 3
     && /^(?:update|upgrade)$/iu.test(process.argv[2] || '');
   let noticeResult = await acquireNoticeLease();
-  if (!noticeResult.acquired && explicitUpdateRequest) {
-    process.stderr.write('BLUN laeuft noch. Beende die laufenden Konsolen und starte das Update erneut.\n');
-    process.exitCode = 1;
-    return;
-  }
   let runtimeResult;
   try {
     if (explicitUpdateRequest) {
-      if (!await installLeaseIsClear()) {
-        process.stderr.write('BLUN laeuft noch. Beende die laufenden Konsolen und starte das Update erneut.\n');
-        process.exitCode = 1;
-        return;
+      runtimeResult = await connectExistingRuntimeLease(750);
+      if (!runtimeResult.acquired) {
+        runtimeResult = undefined;
+        if (!noticeResult.acquired || !await installLeaseIsClear()) {
+          process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+          process.exitCode = 1;
+          return;
+        }
       }
     } else {
       const installClear = await installLeaseIsClear();
@@ -373,7 +372,7 @@ async function main() {
       mode: filename.startsWith('king') ? 'king' : 'blun',
       noticeLease: noticeResult.lease,
       runtimeLease: runtimeResult?.lease,
-      skipUpdateNotice: runtimeResult?.acquired === true,
+      skipUpdateNotice: runtimeResult?.acquired === true || !noticeResult.acquired,
     });
   } finally {
     await runtimeResult?.lease?.release();

package/bin/king.js

@@ -313,9 +313,9 @@ function connectRuntimeBroker(endpoint) {
   });
 }
 
-async function connectExistingRuntimeLease() {
+async function connectExistingRuntimeLease(timeoutMs = 3_000) {
   const endpoint = deriveLeaseEndpoint('runtime');
-  const deadline = Date.now() + 3_000;
+  const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const connected = await connectRuntimeBroker(endpoint);
     if (connected.acquired) return connected;
@@ -328,18 +328,17 @@ async function main() {
   const explicitUpdateRequest = process.argv.length === 3
     && /^(?:update|upgrade)$/iu.test(process.argv[2] || '');
   let noticeResult = await acquireNoticeLease();
-  if (!noticeResult.acquired && explicitUpdateRequest) {
-    process.stderr.write('BLUN laeuft noch. Beende die laufenden Konsolen und starte das Update erneut.\n');
-    process.exitCode = 1;
-    return;
-  }
   let runtimeResult;
   try {
     if (explicitUpdateRequest) {
-      if (!await installLeaseIsClear()) {
-        process.stderr.write('BLUN laeuft noch. Beende die laufenden Konsolen und starte das Update erneut.\n');
-        process.exitCode = 1;
-        return;
+      runtimeResult = await connectExistingRuntimeLease(750);
+      if (!runtimeResult.acquired) {
+        runtimeResult = undefined;
+        if (!noticeResult.acquired || !await installLeaseIsClear()) {
+          process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+          process.exitCode = 1;
+          return;
+        }
       }
     } else {
       const installClear = await installLeaseIsClear();
@@ -373,7 +372,7 @@ async function main() {
       mode: filename.startsWith('king') ? 'king' : 'blun',
       noticeLease: noticeResult.lease,
       runtimeLease: runtimeResult?.lease,
-      skipUpdateNotice: runtimeResult?.acquired === true,
+      skipUpdateNotice: runtimeResult?.acquired === true || !noticeResult.acquired,
     });
   } finally {
     await runtimeResult?.lease?.release();

package/bin/launcher-runtime.js

@@ -210,7 +210,7 @@ async function runLauncher(options = {}) {
   };
 
   try {
-    if (!runtimeLease) {
+    if (!runtimeLease && !explicitUpdateRequest) {
       const installProbe = await tryAcquireUpdateLease({ packageRoot: PKG, role: 'install' });
       if (!installProbe.acquired) {
         process.stderr.write(explicitUpdateRequest

package/bin/update-notice.js

@@ -24,6 +24,7 @@ const SNOOZE_MS = 7 * 24 * 60 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 2_500;
 const STATE_FILE = 'update-notice.json';
 const UPDATE_SKIP_FILE = 'update-skip-version.json';
+const PENDING_UPDATE_FILE = 'update-pending.json';
 const UPDATE_DIRECTORY = 'updates';
 const UPDATE_KEY_ESCAPE_TIMEOUT_MS = 500;
 const UPDATE_SIGNAL_EXIT_CODES = Object.freeze({
@@ -441,6 +442,59 @@ function writeSkippedVersion(blunDir, skippedVersion) {
   }
 }
 
+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 isInteractiveUpdateStart({ argv, env, stdin, stdout }) {
   const isOrdinaryStartup = Array.isArray(argv)
     && (argv.length === 0
@@ -1145,6 +1199,19 @@ function explicitFailure(stderr, reason, exitCode) {
   };
 }
 
+function queueExplicitUpdate(blunDir, release, stdout, stderr) {
+  try {
+    ensurePrivateDirectory(blunDir);
+    writePendingUpdate(blunDir, release.version);
+  } catch {
+    return explicitFailure(stderr, 'private_home_unavailable');
+  }
+  stdout.write(
+    `Update ${release.version} vorgemerkt. Es wird beim ersten freien Start automatisch installiert.\n`,
+  );
+  return { kind: 'queued', version: release.version };
+}
+
 async function runUpdateFlow(options, explicitUpdate) {
   const {
     currentVersion,
@@ -1164,8 +1231,13 @@ async function runUpdateFlow(options, explicitUpdate) {
       : { 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 && readSnoozeState(blunDir, now)) {
+  if (!explicitUpdate && pendingVersion === undefined && readSnoozeState(blunDir, now)) {
     return { kind: 'continue', reason: 'snoozed' };
   }
 
@@ -1198,20 +1270,11 @@ async function runUpdateFlow(options, explicitUpdate) {
   let installerSession;
 
   try {
-    if (!explicitUpdate && readSnoozeState(blunDir, (options.now || Date.now)())) {
+    if (!explicitUpdate
+      && pendingVersion === undefined
+      && readSnoozeState(blunDir, (options.now || Date.now)())) {
       return { kind: 'continue', reason: 'snoozed' };
     }
-    const initialInstallLease = await probeInstallLease(options, packageRoot);
-    if (initialInstallLease === 'busy') {
-      return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
-        : { kind: 'update_in_progress' };
-    }
-    if (initialInstallLease !== 'clear') {
-      return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
-        : { kind: 'continue', reason: 'lease_unavailable' };
-    }
     let sources;
     try {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
@@ -1229,10 +1292,22 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitNoTarget(stdout, reason)
         : { kind: 'continue', reason };
     }
-    if (!explicitUpdate && readSkippedVersion(blunDir) === release.version) {
+    const queuedForRelease = pendingVersion === release.version;
+    const initialInstallLease = await probeInstallLease(options, packageRoot);
+    if (initialInstallLease === 'busy') {
+      return explicitUpdate
+        ? queueExplicitUpdate(blunDir, release, stdout, stderr)
+        : { kind: 'update_in_progress' };
+    }
+    if (initialInstallLease !== 'clear') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
+    }
+    if (!explicitUpdate && !queuedForRelease && readSkippedVersion(blunDir) === release.version) {
       return { kind: 'continue', reason: 'skipped_version' };
     }
-    if (explicitUpdate) {
+    if (explicitUpdate || queuedForRelease) {
       try {
         ensurePrivateDirectory(blunDir);
       } catch {
@@ -1249,7 +1324,7 @@ async function runUpdateFlow(options, explicitUpdate) {
     const prePromptInstallLease = await probeInstallLease(options, packageRoot);
     if (prePromptInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? queueExplicitUpdate(blunDir, release, stdout, stderr)
         : { kind: 'update_in_progress' };
     }
     if (prePromptInstallLease !== 'clear') {
@@ -1272,7 +1347,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
     }
     let action;
-    if (explicitUpdate) {
+    if (explicitUpdate || queuedForRelease) {
       action = 'install';
     } else {
       try {
@@ -1337,6 +1412,7 @@ async function runUpdateFlow(options, explicitUpdate) {
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
       updateProgress(4, 'Installation geprüft');
+      clearPendingUpdate(blunDir);
       stdout.write('Update erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n');
       return { kind: 'installed', version: release.version };
     }

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:ceb20a9e0d1997d41a1341bbfc3961f3f60de3ed6867c9cff4ee45bc88198aab
+// BLUN_BUILD_INPUT_SHA256:420510ac14726514cc4725577c2fe8d0fd038c1471bdbda1c15ace32f3ceaba0
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -261328,6 +261328,10 @@ var init_blun_media$1 = __esmMin((() => {
 						isError: terminalError
 					};
 				}
+				if (result.kind === "text") return {
+					output: result.text,
+					isError: false
+				};
 				const url = `data:${result.mimeType};base64,${Buffer.from(result.data).toString("base64")}`;
 				const mediaPart = contentPartFor(result.mimeType, url);
 				if (mediaPart === void 0) return {
@@ -309372,6 +309376,12 @@ var init_blun_media = __esmMin((() => {
 			await assertSuccess(response, "Media lookup");
 			const mimeType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
 			if (mimeType === "application/json" || mimeType.endsWith("+json")) return parseStatus(await response.json(), id);
+			if (mimeType === "text/plain") return {
+				kind: "text",
+				id,
+				mimeType,
+				text: await response.text()
+			};
 			if (!mimeType.startsWith("image/") && !mimeType.startsWith("audio/") && !mimeType.startsWith("video/")) throw new Error(`Media lookup returned unsupported content type ${mimeType || "(missing)"}`);
 			return {
 				kind: "file",
@@ -340476,6 +340486,18 @@ const PERSONAL_MEMORY_MEMORY_CREATE_METHOD = "POST";
 const PERSONAL_MEMORY_RECALL_METHOD = "POST";
 const PERSONAL_MEMORY_EXPLICIT_KEY = "explicit_user_memory";
 const PERSONAL_MEMORY_EXPLICIT_CATEGORY = "user_explicit";
+const SAFE_BROKER_ERROR_CODES = new Set([
+	"AUTHENTICATION_REQUIRED",
+	"EXPLICIT_CONSENT_REQUIRED",
+	"INTERNAL_ERROR",
+	"INTERACTIVE_CONFIRMATION_REQUIRED",
+	"INSUFFICIENT_SCOPE",
+	"INVALID_PAYLOAD",
+	"MEMORY_NOT_FOUND",
+	"MEMORY_WRITE_DISABLED",
+	"SECRET_REJECTED",
+	"UNAVAILABLE"
+]);
 var PersonalMemoryBrokerError = class extends Error {
 	code;
 	status;
@@ -340513,9 +340535,118 @@ function explicitPersonalMemoryBody(content) {
 		kategorie: PERSONAL_MEMORY_EXPLICIT_CATEGORY
 	};
 }
+var PersonalMemoryBrokerClient = class {
+	options;
+	baseUrl;
+	fetchImpl;
+	idempotencyKey;
+	timeoutMs;
+	constructor(options) {
+		this.options = options;
+		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.idempotencyKey = options.idempotencyKey ?? randomUUID;
+		this.timeoutMs = options.timeoutMs ?? 1e4;
+	}
+	async getSettings() {
+		const parsed = parsePersonalMemorySettings(await this.request("GET", PERSONAL_MEMORY_SETTINGS_PATH));
+		if (parsed === void 0) throw new PersonalMemoryBrokerError("INVALID_PAYLOAD");
+		return parsed;
+	}
+	async updateSettings(patch) {
+		await this.request("PUT", PERSONAL_MEMORY_SETTINGS_PATH, patch);
+	}
+	async request(method, path, body) {
+		if (!isAllowedBrokerRequest(method, path)) throw new PersonalMemoryBrokerError("INVALID_PAYLOAD");
+		const idempotencyKey = method === "GET" ? void 0 : this.idempotencyKey();
+		const firstToken = await this.accessToken();
+		let response = await this.fetchWithToken(method, path, firstToken, body, idempotencyKey);
+		if (response.status === 401) {
+			const refreshed = await this.accessToken({ force: true });
+			response = await this.fetchWithToken(method, path, refreshed, body, idempotencyKey);
+		}
+		if (!response.ok) throw await brokerHttpError(response);
+		if (response.status === 204) return null;
+		const text = await response.text();
+		if (text.trim().length === 0) return null;
+		try {
+			return JSON.parse(text);
+		} catch {
+			throw new PersonalMemoryBrokerError("INVALID_PAYLOAD");
+		}
+	}
+	async accessToken(options) {
+		try {
+			const token = await this.options.tokenProvider.getAccessToken(options);
+			if (token.trim().length === 0) throw new Error("empty token");
+			return token;
+		} catch {
+			throw new PersonalMemoryBrokerError("AUTHENTICATION_REQUIRED");
+		}
+	}
+	async fetchWithToken(method, path, accessToken, body, idempotencyKey) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, this.timeoutMs);
+		timer.unref?.();
+		const headers = new Headers();
+		headers.set("Accept", "application/json");
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		if (body !== void 0) headers.set("Content-Type", "application/json");
+		if (idempotencyKey !== void 0) headers.set("Idempotency-Key", idempotencyKey);
+		try {
+			return await this.fetchImpl(`${this.baseUrl}${path}`, {
+				method,
+				headers,
+				body: body === void 0 ? void 0 : JSON.stringify(body),
+				signal: controller.signal
+			});
+		} catch {
+			throw new PersonalMemoryBrokerError("UNAVAILABLE");
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+};
+async function brokerHttpError(response) {
+	const status = response.status;
+	const responseCode = await safeBrokerResponseCode(response);
+	if (responseCode !== void 0) return new PersonalMemoryBrokerError(responseCode, status);
+	if (status === 401) return new PersonalMemoryBrokerError("AUTHENTICATION_REQUIRED", status);
+	if (status === 403) return new PersonalMemoryBrokerError("INSUFFICIENT_SCOPE", status);
+	return new PersonalMemoryBrokerError("UNAVAILABLE", status);
+}
+async function safeBrokerResponseCode(response) {
+	try {
+		const payload = await response.json();
+		if (!isRecord$11(payload)) return void 0;
+		const nested = isRecord$11(payload["error"]) ? payload["error"]["code"] : void 0;
+		const candidate = payload["code"] ?? payload["error_code"] ?? nested;
+		return typeof candidate === "string" && SAFE_BROKER_ERROR_CODES.has(candidate) ? candidate : void 0;
+	} catch {
+		return;
+	}
+}
 function isRecord$11(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isAllowedBrokerRequest(method, path) {
+	let url;
+	try {
+		url = new URL(path, "https://personal-memory.invalid");
+	} catch {
+		return false;
+	}
+	if (url.origin !== "https://personal-memory.invalid") return false;
+	if (url.search.length > 0 || url.hash.length > 0) return false;
+	const pathname = url.pathname;
+	if (pathname === PERSONAL_MEMORY_SETTINGS_PATH) return method === "GET" || method === "PUT";
+	if (pathname === PERSONAL_MEMORY_MEMORIES_PATH) return method === "GET" || method === "POST";
+	if (/^\/v1\/me\/memories\/[0-9a-f-]{36}$/i.test(pathname)) return false;
+	if (pathname === PERSONAL_MEMORY_RECALL_PATH) return method === PERSONAL_MEMORY_RECALL_METHOD;
+	return false;
+}
 //#endregion
 //#region src/personal-memory/explicit-remember.ts
 /** The sole Phase-1 write path: invoked by an explicit host command, never by the model. */
@@ -340539,7 +340670,17 @@ async function rememberExplicitPersonalMemory(options) {
 //#region src/personal-memory/runtime.ts
 init_src$3();
 function createPersonalMemoryBrokerClient(harness) {
-	throw new PersonalMemoryBrokerError("UNAVAILABLE");
+	const provider = loadRuntimeConfigSafe(harness.configPath).config.providers[DEFAULT_OAUTH_PROVIDER_NAME];
+	const runtime = resolveBlunCodeRuntimeAuth({
+		configuredBaseUrl: provider?.baseUrl,
+		configuredOAuthRef: provider?.oauth
+	});
+	const brokerBaseUrl = runtime.oauthRef.oauthHost ?? BLUN_FLOW_CONFIG.oauthHost;
+	if (brokerBaseUrl.trim().length === 0) throw new PersonalMemoryBrokerError("UNAVAILABLE");
+	return new PersonalMemoryBrokerClient({
+		baseUrl: brokerBaseUrl,
+		tokenProvider: harness.auth.resolveOAuthTokenProvider(DEFAULT_OAUTH_PROVIDER_NAME, runtime.oauthRef)
+	});
 }
 //#endregion
 //#region src/cli/sub/personal-memory.ts
@@ -399120,42 +399261,42 @@ registerUiCatalogFragment({
 registerUiCatalogFragment({
 	en: {
 		"startupPersonalMemory.title": "Personal memory",
-		"startupPersonalMemory.details": "When personal memory is enabled, BLUN automatically extracts useful information from your chats and can use it in future conversations. This stays off until you enable it.",
+		"startupPersonalMemory.details": "When personal memory is enabled, BLUN can save information only when you explicitly ask it to remember something and can use saved information in later conversations. Your chats are not evaluated automatically. This stays off until you enable it.",
 		"startupPersonalMemory.enable": "Enable memory",
 		"startupPersonalMemory.decline": "Do not enable",
 		"startupPersonalMemory.persistenceFailed": "Memory settings could not be saved. Personal memory remains off."
 	},
 	de: {
 		"startupPersonalMemory.title": "Persönliches Gedächtnis",
-		"startupPersonalMemory.details": "Wenn das persönliche Gedächtnis aktiviert ist, übernimmt BLUN automatisch nützliche Informationen aus deinen Chats und kann sie in späteren Gesprächen verwenden. Die Funktion bleibt deaktiviert, bis du sie einschaltest.",
+		"startupPersonalMemory.details": "Wenn das persönliche Gedächtnis aktiviert ist, kann BLUN Informationen nur dann speichern, wenn du ausdrücklich darum bittest, sich etwas zu merken. Gespeicherte Informationen können in späteren Gesprächen verwendet werden. Deine Chats werden nicht automatisch ausgewertet. Die Funktion bleibt deaktiviert, bis du sie einschaltest.",
 		"startupPersonalMemory.enable": "Gedächtnis aktivieren",
 		"startupPersonalMemory.decline": "Nicht aktivieren",
 		"startupPersonalMemory.persistenceFailed": "Die Gedächtniseinstellungen konnten nicht gespeichert werden. Das persönliche Gedächtnis bleibt deaktiviert."
 	},
 	es: {
 		"startupPersonalMemory.title": "Memoria personal",
-		"startupPersonalMemory.details": "Cuando activas la memoria personal, BLUN extrae automáticamente información útil de tus chats y puede utilizarla en conversaciones futuras. La función permanece desactivada hasta que la actives.",
+		"startupPersonalMemory.details": "Cuando la memoria personal está activada, BLUN solo puede guardar información si le pides expresamente que recuerde algo y puede utilizar la información guardada en conversaciones posteriores. Tus chats no se analizan automáticamente. Esta función permanece desactivada hasta que la actives.",
 		"startupPersonalMemory.enable": "Activar la memoria",
 		"startupPersonalMemory.decline": "No activar",
 		"startupPersonalMemory.persistenceFailed": "No se pudo guardar la configuración de la memoria. La memoria personal permanece desactivada."
 	},
 	fr: {
 		"startupPersonalMemory.title": "Mémoire personnelle",
-		"startupPersonalMemory.details": "Lorsque vous activez la mémoire personnelle, BLUN extrait automatiquement les informations utiles de vos conversations et peut les réutiliser ultérieurement. La fonction reste désactivée tant que vous ne l’activez pas.",
+		"startupPersonalMemory.details": "Lorsque la mémoire personnelle est activée, BLUN ne peut enregistrer des informations que si vous lui demandez explicitement de retenir quelque chose. Il peut ensuite utiliser les informations enregistrées dans de futures conversations. Vos discussions ne sont pas analysées automatiquement. Cette fonction reste désactivée tant que vous ne l’activez pas.",
 		"startupPersonalMemory.enable": "Activer la mémoire",
 		"startupPersonalMemory.decline": "Ne pas activer",
 		"startupPersonalMemory.persistenceFailed": "Les réglages de la mémoire n’ont pas pu être enregistrés. La mémoire personnelle reste désactivée."
 	},
 	sv: {
 		"startupPersonalMemory.title": "Personligt minne",
-		"startupPersonalMemory.details": "När du aktiverar det personliga minnet hämtar BLUN automatiskt användbar information från dina chattar och kan använda den i framtida samtal. Funktionen är avstängd tills du aktiverar den.",
+		"startupPersonalMemory.details": "När det personliga minnet är aktiverat kan BLUN bara spara information om du uttryckligen ber BLUN att komma ihåg något. Sparad information kan sedan användas i framtida samtal. Dina chattar analyseras inte automatiskt. Funktionen är avstängd tills du aktiverar den.",
 		"startupPersonalMemory.enable": "Aktivera minnet",
 		"startupPersonalMemory.decline": "Aktivera inte",
 		"startupPersonalMemory.persistenceFailed": "Minnesinställningarna kunde inte sparas. Det personliga minnet förblir avstängt."
 	},
 	cs: {
 		"startupPersonalMemory.title": "Osobní paměť",
-		"startupPersonalMemory.details": "Když zapnete osobní paměť, BLUN automaticky získává užitečné informace z vašich chatů a může je použít v budoucích konverzacích. Funkce zůstává vypnutá, dokud ji nezapnete.",
+		"startupPersonalMemory.details": "Když je osobní paměť zapnutá, BLUN může uložit informace pouze tehdy, když ho výslovně požádáte, aby si něco zapamatoval. Uložené informace pak může použít v budoucích konverzacích. Vaše chaty se automaticky nevyhodnocují. Funkce zůstává vypnutá, dokud ji nezapnete.",
 		"startupPersonalMemory.enable": "Zapnout paměť",
 		"startupPersonalMemory.decline": "Nezapínat",
 		"startupPersonalMemory.persistenceFailed": "Nastavení paměti se nepodařilo uložit. Osobní paměť zůstává vypnutá."
@@ -509168,11 +509309,9 @@ var BlunTUI = class {
 	editorKeyboard;
 	scrollbackController;
 	personalMemoryController;
-	accountMemory;
-	accountMemoryEnabledForSession = false;
-	pendingAccountMemoryExtractions = /* @__PURE__ */ new Set();
 	managedQuotaWarningController;
 	managedQuotaWarningPersistence = Promise.resolve();
+	footerMounted = false;
 	/** Timer that auto-clears the one-shot "moved to background" footer hint. */
 	detachHintClearTimer;
 	telegramChannel;
@@ -509188,7 +509327,6 @@ var BlunTUI = class {
 	}
 	constructor(harness, startupInput) {
 		this.harness = harness;
-		this.accountMemory = createAccountMemoryClient(harness.auth);
 		const initialAppState = createInitialAppState(startupInput);
 		setCurrentUiLocale(initialAppState.uiLocale);
 		const invalidAppearance = initialAppState.appearance !== void 0 && !validateAppearance(currentTheme.palette, initialAppState.appearance).valid;
@@ -509439,6 +509577,13 @@ var BlunTUI = class {
 			}), "warning");
 		} catch {}
 	}
+	async refreshProviderModelsBeforeSession() {
+		if ((await this.harness.getConfig()).models?.["blun/king"] === void 0) {
+			await this.refreshProviderModelsInBackground();
+			return;
+		}
+		this.refreshProviderModelsInBackground();
+	}
 	async finishStartup(shouldReplayHistory) {
 		while (!this.aborted) {
 			await this.flushStartupNotice();
@@ -509540,7 +509685,7 @@ var BlunTUI = class {
 			return false;
 		}
 		if (this.startupWorkspaceSelectionPending) return false;
-		this.refreshProviderModelsInBackground();
+		await this.refreshProviderModelsBeforeSession();
 		const { startup } = this.options;
 		const { workDir } = this.state.appState;
 		let session;
@@ -509647,7 +509792,6 @@ var BlunTUI = class {
 		this.channelQueueDeadline?.dispose();
 		await this.telegramChannel?.stop();
 		this.telegramChannel = void 0;
-		await Promise.allSettled(this.pendingAccountMemoryExtractions);
 		this.streamingUI.discardPending();
 		this.tasksBrowserController.close();
 		this.btwPanelController.clear();
@@ -509753,9 +509897,11 @@ var BlunTUI = class {
 		}
 	}
 	mountFooter() {
+		if (this.footerMounted) return;
 		const footerWrap = new GutterContainer(1, 1);
 		footerWrap.addChild(this.state.footer);
 		this.state.ui.addChild(footerWrap);
+		this.footerMounted = true;
 	}
 	handlePlanToggle(next) {
 		handlePlanCommand(this, next ? "on" : "off");
@@ -510155,9 +510301,7 @@ var BlunTUI = class {
 			type: "text",
 			text: modelInput
 		}, imagePart] : modelInput;
-		session.promptAccepted(promptInput).then((result) => {
-			if (result.accepted) this.extractAccountMemory(displayText);
-		}).catch((error) => {
+		session.promptAccepted(promptInput).catch((error) => {
 			this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
 		});
 		this.updateQueueDisplay();
@@ -510368,9 +510512,7 @@ var BlunTUI = class {
 			model: BLUN_KING_MODEL_ALIAS,
 			modelFallbackAllowed: false
 		});
-		session.promptAccepted(sdkInput).then((result) => {
-			if (result.accepted) this.extractAccountMemory(input);
-		}).catch((error) => {
+		session.promptAccepted(sdkInput).catch((error) => {
 			finishPersonalMemoryRememberIntentTurn(session.id);
 			const message = formatErrorMessage$2(error);
 			this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: message }));
@@ -510420,9 +510562,7 @@ var BlunTUI = class {
 			content: part
 		});
 		const text = input.join("\n\n");
-		session.steer(text).then(() => {
-			this.extractAccountMemory(text);
-		}).catch((error) => {
+		session.steer(text).catch((error) => {
 			const message = formatErrorMessage$2(error);
 			this.showError(uiText("blunTui.steer.failed", { error: message }));
 		});
@@ -510512,51 +510652,8 @@ var BlunTUI = class {
 		this.authFlow.refreshManagedQuotaWindows();
 	}
 	async refreshPersonalMemory(promptIfNeverAsked = false) {
-		const session = this.session;
-		if (session === void 0) return;
-		this.accountMemoryEnabledForSession = false;
-		try {
-			let consentStatus = await this.accountMemory.getConsentStatus();
-			if (consentStatus === "never_asked" && promptIfNeverAsked) {
-				const consent = await ensureStartupPersonalMemoryConsent({
-					host: this,
-					consentStatus,
-					copy: startupPersonalMemoryConsentCopy(),
-					updateSettings: async (patch) => {
-						await this.accountMemory.setConsent(patch.memory_enabled === true);
-					}
-				});
-				if (consent === "persistence-failed") this.showStatus(startupPersonalMemoryConsentCopy().persistenceFailed, "warning");
-				consentStatus = consent === "enabled" || consent === "disabled" ? consent : "never_asked";
-			}
-			this.accountMemoryEnabledForSession = consentStatus === "enabled";
-		} catch (error) {
-			this.reportAccountMemoryIssue("Account memory consent unavailable", error);
-		}
-		await this.applyAccountMemoryContext(session);
-	}
-	async applyAccountMemoryContext(session) {
-		try {
-			const context = this.accountMemoryEnabledForSession ? await this.accountMemory.loadSystemContext() : void 0;
-			await session.setAccountMemoryContext(context);
-		} catch (error) {
-			try {
-				await session.setAccountMemoryContext(void 0);
-			} catch {}
-			this.reportAccountMemoryIssue("Account memory unavailable", error);
-		}
-	}
-	extractAccountMemory(text) {
-		if (!this.accountMemoryEnabledForSession || text.trim().length === 0) return;
-		let pending;
-		pending = this.accountMemory.extract(text).catch((error) => {
-			this.reportAccountMemoryIssue("Account memory update failed", error);
-		}).finally(() => {
-			this.pendingAccountMemoryExtractions.delete(pending);
-		});
-		this.pendingAccountMemoryExtractions.add(pending);
+		await this.personalMemoryController.refresh({ promptIfNeverAsked });
 	}
-	reportAccountMemoryIssue(_label, _error) {}
 	patchLivePane(patch) {
 		if (!hasPatchChanges(this.state.livePane, patch)) return;
 		Object.assign(this.state.livePane, patch);
@@ -510607,7 +510704,7 @@ var BlunTUI = class {
 		this.registerSessionHandlers(session);
 		this.syncAdditionalDirs(session);
 		await this.authFlow.applyManagedAccountContextToSession();
-		await this.applyAccountMemoryContext(session);
+		await this.personalMemoryController.refresh();
 	}
 	async syncRuntimeState(session = this.requireSession()) {
 		const [status, goalResult] = await Promise.all([session.getStatus(), session.getGoal()]);
@@ -510816,7 +510913,7 @@ var BlunTUI = class {
 		this.session = session;
 		this.harness.setTelemetryContext({ sessionId: session.id });
 		this.registerSessionHandlers(session);
-		await this.applyAccountMemoryContext(session);
+		await this.personalMemoryController.refresh();
 		await this.syncRuntimeState(session);
 		this.updateTerminalTitle();
 		try {

package/package.json

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

package/telegram-plugin/dist/bridge.mjs

@@ -67752,6 +67752,14 @@ function pidAlive(pid) {
 		return false;
 	}
 }
+/** True while the TUI process named by the lease still exists. */
+function isTuiLeaseOwnerAlive() {
+	try {
+		return pidAlive(parseInt(readFileSync(tuiPidFile(), "utf8"), 10));
+	} catch {
+		return false;
+	}
+}
 function isTuiLeaseFresh(maxAgeMs = TUI_LEASE_MAX_AGE_MS, now = Date.now()) {
 	try {
 		const file = tuiPidFile();
@@ -67763,7 +67771,7 @@ function isTuiLeaseFresh(maxAgeMs = TUI_LEASE_MAX_AGE_MS, now = Date.now()) {
 }
 /** Per-message routing decision of the single poller. */
 function deliveryTarget() {
-	return isTuiLeaseFresh() ? "tui" : "headless";
+	return isTuiLeaseOwnerAlive() ? "tui" : "headless";
 }
 function deliverToTuiQueue(envelope) {
 	appendJsonl(tuiInboundQueueFile(), envelope);
@@ -67775,7 +67783,7 @@ function deliverToTuiQueue(envelope) {
 */
 function rotateStaleTuiQueue() {
 	try {
-		if (!isTuiLeaseFresh() && existsSync(tuiInboundQueueFile())) rmSync(tuiInboundQueueFile());
+		if (!isTuiLeaseOwnerAlive() && existsSync(tuiInboundQueueFile())) rmSync(tuiInboundQueueFile());
 	} catch {}
 }
 //#endregion