blun-king-cli 9.1.585 → 9.1.587

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 9.1.587 - 2026-09-10
+
+- Preserve the active tool catalog across buffered instructions and the following work step. Required tools remain available; retained optional schemas are reselected when the existing schema budget is exceeded.
+- Restore earlier automatic context compaction and allow another automatic compaction in the same turn after a successful shrinking summary. Smaller model limits and failure limits remain in force.
+- After a thinking-only timeout, use the existing single recovery attempt with thinking disabled so the model can answer or call a tool. Subsequent ordinary steps retain the chosen thinking setting; cancellation, approval checks and timeout bounds remain in force.
+- Set BLUN_STABLE_STEER_TOOLS=0 or BLUN_EARLY_COMPACTION=0 before starting King to restore the previous behavior for the respective feature. No existing sessions or configuration files are rewritten by this update.
+
+## 9.1.586 - 2026-09-09
+
+- Fix Telegram receiver startup on Windows when an old bridge PID has been reused by an unrelated process. Preserve uncertain process ownership and never stop that unrelated process.
+- Keep context compaction, model settings, conversation history, and existing Telegram delivery behavior unchanged.
+
+
 ## 9.1.585 - 2026-09-08
 
 - Managed WebSearch validates result envelopes and source rows even when optional search status metadata is absent.

package/bin/context-performance-policy.cjs

@@ -3,8 +3,12 @@
 const DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS = 256_000;
 const DEFAULT_COMPACTION_BLOCK_MAX_TOKENS = 288_000;
 
-function capCompactionThreshold(threshold, _phase) {
+function capCompactionThreshold(threshold, phase) {
   if (threshold === undefined) return undefined;
+  if (process.env.BLUN_EARLY_COMPACTION !== "0") {
+    if (phase === "trigger") return Math.min(threshold, DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS);
+    if (phase === "block") return Math.min(threshold, DEFAULT_COMPACTION_BLOCK_MAX_TOKENS);
+  }
   return threshold;
 }
 

package/bin/thinking-only-guard.cjs

@@ -65,6 +65,7 @@ function forceAnswerParams(params) {
   };
   return {
     ...params,
+    thinkingOnlyRecovery: true,
     messages: [...params.messages, forceAnswerMessage],
     boundaryMessageSuffix: [...(params.boundaryMessageSuffix ?? []), forceAnswerMessage],
   };

package/blun.mjs

@@ -75058,7 +75058,8 @@ var init_kosong_llm = __esmMin((() => {
 					this.notifyMediaDropped(dropped);
 				});
 				completionBudget = this.describeRequest(outgoingMessages, tools, params.completionBudgetRetry).details;
-				result = await this.generate(completionBudget.provider, this.systemPrompt, tools, outgoingMessages, callbacks, options);
+				const requestProvider = params.thinkingOnlyRecovery === true ? completionBudget.provider.withThinking("off") : completionBudget.provider;
+				result = await this.generate(requestProvider, this.systemPrompt, tools, outgoingMessages, callbacks, options);
 			} catch (error) {
 				if (error instanceof APIEmptyResponseError) throw error.withMetadata({ maxCompletionTokens: completionBudget === void 0 ? null : completionBudget.maxCompletionTokens ?? null });
 				if (error instanceof APIPaymentRequiredError) {
@@ -75843,6 +75844,8 @@ var init_full = __esmMin((() => {
 		}
 		markCompleted() {
 			this.agent.records.logRecord({ type: "full_compaction.complete" });
+			const completedTransaction = this.compacting?.transaction;
+			if (process.env.BLUN_EARLY_COMPACTION !== "0" && completedTransaction?.state === "summarized" && completedTransaction.tokensAfter < completedTransaction.tokensBefore) this.compactionCountInTurn = 0;
 			this.closeTransaction("success");
 			this.compacting = null;
 			this.sessionCompactionState = resetCompactionFailures();
@@ -263255,6 +263258,52 @@ function blunSelectTurnTools(tools, maxContextTokens, loadedToolNames, requiredT
 		deferredToolCount: deferred.length
 	};
 }
+function blunSelectStableSteerTools(selectedTools, eligibleTools, loadedToolNames, requiredToolNames, maxContextTokens, log) {
+	const selectedNames = new Set(selectedTools.map((tool) => tool.name));
+	const additions = [];
+	for (const tool of eligibleTools) {
+		if (!requiredToolNames.has(tool.name) || selectedNames.has(tool.name)) continue;
+		additions.push(tool);
+		selectedNames.add(tool.name);
+	}
+	const proposed = [...selectedTools, ...additions];
+	let deferred = eligibleTools.filter((tool) => !selectedNames.has(tool.name));
+	const recoveryLoader = deferred.length > 0 && !selectedNames.has("ToolSearch") ? createDeferredToolLoader(selectedTools, deferred, loadedToolNames) : void 0;
+	if (recoveryLoader) proposed.push(recoveryLoader);
+	const schemaBudgetTokens = toolSchemaBudgetTokens(maxContextTokens);
+	const proposedSchemaTokens = estimateTokensForTools(proposed);
+	// A full-catalog alias must never shrink the eligible catalog itself.
+	const budgetFallback = proposedSchemaTokens > schemaBudgetTokens && selectedTools !== eligibleTools;
+	if (budgetFallback) {
+		const selection = blunSelectTurnTools(eligibleTools, maxContextTokens, loadedToolNames, requiredToolNames);
+		selectedTools.length = 0;
+		for (const tool of selection.tools) if (tool.name !== "ToolSearch") selectedTools.push(tool);
+		const retainedNames = new Set(selectedTools.map((tool) => tool.name));
+		deferred = eligibleTools.filter((tool) => !retainedNames.has(tool.name));
+		// Rebind discovery to the shared array, including former residents.
+		if (deferred.length > 0) selectedTools.push(createDeferredToolLoader(selectedTools, deferred, loadedToolNames));
+	} else {
+		for (const tool of additions) selectedTools.push(tool);
+		if (recoveryLoader) selectedTools.push(recoveryLoader);
+	}
+	const schemaTokenEstimate = estimateTokensForTools(selectedTools);
+	const schemaBudgetExceeded = schemaTokenEstimate > schemaBudgetTokens;
+	if (budgetFallback || schemaBudgetExceeded) log?.info("stable steer budget fallback", {
+		budgetFallback,
+		proposedSchemaTokens,
+		schemaTokenEstimate,
+		schemaBudgetTokens,
+		schemaBudgetExceeded
+	});
+	return {
+		tools: selectedTools,
+		deferredToolCount: deferred.length,
+		budgetFallback,
+		schemaTokenEstimate,
+		schemaBudgetTokens,
+		schemaBudgetExceeded
+	};
+}
 function blunToolSuppressionReason(turnNeedsTools, eligibleTools, deferredToolCount, fastConversation) {
 	if (fastConversation) return "fast_conversation";
 	if (!turnNeedsTools) return "greeting_optimization";
@@ -264496,7 +264545,7 @@ var init_turn = __esmMin((() => {
 								const steerRequiredToolNames = mediaToolNamesForTurnText(steerText);
 								for (const name of rankedToolNamesForTurnText(eligibleTools, steerText)) steerRequiredToolNames.add(name);
 								if (steerEfforts.some((effort) => effort === void 0)) {
-									const prioritizedSelection = blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, steerRequiredToolNames);
+									const prioritizedSelection = process.env.BLUN_STABLE_STEER_TOOLS !== "0" ? blunSelectStableSteerTools(selectedTools, eligibleTools, this.loadedToolNames, steerRequiredToolNames, this.agent.config.modelCapabilities?.max_context_tokens, this.agent.log) : blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, steerRequiredToolNames);
 									this.agent.context.appendSystemReminder(ACTIVE_STEER_PRIORITY_REMINDER, {
 										kind: "injection",
 										variant: "active_steer_priority"
@@ -422277,7 +422326,41 @@ function resolveTelegramMcpEntry() {
 	];
 	for (const candidate of candidates) if (candidate !== void 0 && existsSync(candidate)) return resolveKnownTelegramMcp(candidate, { explicitOverride: candidate === process.env["BLUN_TELEGRAM_MCP_SERVER"] });
 }
+import { fstatSync as __blunTelegramPidFstatSync } from "node:fs";
+"use strict";
+const PROCESS_START_LOOKUP_TIMEOUT_MS = 1500;
+const PID_CLAIM_TIME_TOLERANCE_MS = 1000;
+function readNonBridgeProcessStartedAt(pid) {
+    if (process.platform !== 'win32' || !Number.isSafeInteger(pid) || pid <= 1)
+        return undefined;
+    try {
+        const output = execFileSync('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-Command',
+            `$ErrorActionPreference='Stop'; $p=Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; ` +
+                // A recognizable bridge is preserved even after a wall-clock correction.
+                `if($null -ne $p -and -not [string]::IsNullOrWhiteSpace($p.CommandLine) -and $p.CommandLine -notmatch 'bridge\\.mjs'){` +
+                `([DateTimeOffset]$p.CreationDate.ToUniversalTime()).ToUnixTimeMilliseconds()}`,
+        ], {
+            encoding: 'utf8',
+            windowsHide: true,
+            timeout: PROCESS_START_LOOKUP_TIMEOUT_MS,
+            maxBuffer: 4096,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (!/^\d+$/.test(output))
+            return undefined;
+        const startedAt = Number(output);
+        return Number.isSafeInteger(startedAt) && startedAt > 0 ? startedAt : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+
 var TelegramChannelController = class {
+bridgeClaimUncertain = false;
+readProcessStartedAt;
+
 	host;
 	dir;
 	heartbeatTimer;
@@ -422343,7 +422426,9 @@ var TelegramChannelController = class {
 				return false;
 			}
 		});
-	}
+	
+this.readProcessStartedAt = options.readProcessStartedAt ?? readNonBridgeProcessStartedAt;
+}
 	get leaseFile() {
 		return join(this.dir, "tui.pid");
 	}
@@ -422466,11 +422551,68 @@ var TelegramChannelController = class {
 		this.handoffTimer.unref();
 	}
 	liveBridgePid() {
-		try {
-			const pid = parseInt(readFileSync(this.botPidFile, "utf8"), 10);
-			if (Number.isInteger(pid) && pid > 1 && this.isProcessAlive(pid)) return pid;
-		} catch {}
-	}
+        if (this.bridgeClaimUncertain)
+            return null;
+        let pid;
+        let claim;
+        let stats;
+        try {
+            const fd = openSync(this.botPidFile, 'r');
+            try {
+                claim = readFileSync(fd, 'utf8');
+                stats = __blunTelegramPidFstatSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            pid = parseInt(claim, 10);
+            if (!Number.isInteger(pid) || pid <= 1)
+                return null;
+            if (!this.isProcessAlive(pid))
+                return undefined;
+        }
+        catch (error) {
+            // Only an absent claim proves that reading it did not hide an owner.
+            return error.code === 'ENOENT' ? undefined : null;
+        }
+        try {
+            const startedAt = this.readProcessStartedAt(pid);
+            if (startedAt !== undefined && Number.isFinite(startedAt)
+                && startedAt > stats.mtimeMs + PID_CLAIM_TIME_TOLERANCE_MS
+                && this.ownsChannel() && this.retireReusedBridgePid(claim, stats))
+                return undefined;
+        }
+        catch {
+            // A failed identity or archive lookup must not launch a second poller.
+        }
+        return pid;
+    }
+retireReusedBridgePid(claim, original) {
+        const matches = (file) => {
+            const current = lstatSync(file);
+            return current.isFile() && current.dev === original.dev && current.ino === original.ino
+                && current.size === original.size && current.mtimeMs === original.mtimeMs
+                && readFileSync(file, 'utf8') === claim;
+        };
+        if (!matches(this.botPidFile))
+            return false;
+        const retired = join(this.dir, `bot.pid.stale-${randomUUID()}`);
+        renameSync(this.botPidFile, retired);
+        try {
+            if (matches(retired))
+                return true;
+        }
+        catch {
+            // Restore the name if the moved claim cannot be verified.
+        }
+        this.bridgeClaimUncertain = true;
+        // Do not overwrite a newer claim if another writer won the rename window.
+        try {
+            linkSync(retired, this.botPidFile);
+        }
+        catch { /* A current claim wins. */ }
+        return false;
+    }
 	releaseOwnership() {
 		try {
 			if (this.readOwner()?.ownerId === this.ownerId) rmSync(this.ownerFile);

package/package.json

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