blun-king-cli 9.1.75 → 9.1.77

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.69
+  npm install -g blun-king-cli@9.1.77
 
 Start
 -----
@@ -43,6 +43,11 @@ einen aktiven Zug ab, ohne den geschriebenen Entwurf zu löschen. Das gilt auch
 bei Autovervollständigung, Geistervorschlägen, Bash-Eingabe und einer offenen
 Mehrzeileneingabe.
 
+Telegram-Nachrichten, die bei bereits aktivem Kernzug eintreffen, werden ohne
+konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
+FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
+`turn.agent_busy`-Fehler.
+
 Zuverlässiger King-Start
 -----------------------
 Der Windows-Hilfsprozess für private Pfade übernimmt TEMP und TMP aus der
@@ -67,6 +72,20 @@ parallel geprüft und eingelesen. Die Skills werden weiterhin in der
 ursprünglichen, festen Reihenfolge registriert; Priorität und Verhalten bei
 doppelten Namen bleiben unverändert.
 
+Kontextentlastung bei langen Sitzungen
+--------------------------------------
+King bewahrt den vollständigen Verlauf weiterhin im Sitzungs-Wire auf. Erreicht
+der aktive Verlauf 75 Prozent des Modellfensters, ersetzt die Modellprojektion
+ältere große Werkzeugergebnisse durch einen kurzen Platzhalter. Die letzten 20
+Nachrichten bleiben unverändert. Solange der Prefix-Cache warm ist, wird der
+Schnitt höchstens nach jeweils 20 weiteren Nachrichten verschoben. Nach einer
+Stunde ohne Modellantwort darf er sofort nachziehen.
+
+Dabei werden keine gespeicherten Nachrichten geändert oder gelöscht. Fortsetzen,
+Exportieren und die sichtbare Historie behalten die ursprünglichen
+Werkzeugergebnisse. Das Telemetrieereignis `micro_compaction_finished` nennt den
+Auslöser, den Schnitt und die geschätzte Tokenzahl vor und nach der Entlastung.
+
 Zug-Wächter
 -----------
 Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
@@ -175,6 +194,11 @@ Marmor“ oder „Animiere das letzte Bild als ruhige Kamerafahrt von sechs Seku
 genügt. King wählt den passenden Medienweg und kann das asynchrone Ergebnis mit
 GetMedia abrufen.
 
+Ein angenommener Medienauftrag bleibt über Verdichtungen und schnelle
+Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
+verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
+die Medienerzeugung sei nicht verfügbar.
+
 Angehängte Bilder werden weiterhin mit ReadMediaFile gelesen. Bild-, Video- und
 Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. GenerateVideo kann außerdem einen abgeschlossenen Bildauftrag

package/README.md

@@ -62,6 +62,10 @@ blun tools enable context7
 Telegram-Nachrichten werden in Eingangsreihenfolge verarbeitet. Trifft eine
 Nachricht im Leerlauf ein, startet die Warteschlange selbstständig; während
 eines Werkzeuglaufs wird sie am nächsten geschützten Übergabepunkt eingefügt.
+Telegram-Nachrichten, die bei bereits aktivem Kernzug eintreffen, werden ohne
+konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
+FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
+`turn.agent_busy`-Fehler.
 `Strg+C` und `Esc` brechen einen aktiven Zug zuverlässig ab, ohne den bereits
 geschriebenen Entwurf zu löschen. Das gilt auch bei Autovervollständigung,
 Geistervorschlägen, Bash-Eingabe und einer noch offenen Mehrzeileneingabe.
@@ -90,6 +94,20 @@ parallel geprüft und eingelesen. Die Skills werden weiterhin in der
 ursprünglichen, festen Reihenfolge registriert; Priorität und Verhalten bei
 doppelten Namen bleiben unverändert.
 
+## Kontextentlastung bei langen Sitzungen
+
+King bewahrt den vollständigen Verlauf weiterhin im Sitzungs-Wire auf. Erreicht
+der aktive Verlauf 75 Prozent des Modellfensters, ersetzt die Modellprojektion
+ältere große Werkzeugergebnisse durch einen kurzen Platzhalter. Die letzten 20
+Nachrichten bleiben unverändert. Solange der Prefix-Cache warm ist, wird der
+Schnitt höchstens nach jeweils 20 weiteren Nachrichten verschoben. Nach einer
+Stunde ohne Modellantwort darf er sofort nachziehen.
+
+Dabei werden keine gespeicherten Nachrichten geändert oder gelöscht. Fortsetzen,
+Exportieren und die sichtbare Historie behalten die ursprünglichen
+Werkzeugergebnisse. Das Telemetrieereignis `micro_compaction_finished` nennt den
+Auslöser, den Schnitt und die geschätzte Tokenzahl vor und nach der Entlastung.
+
 ## Zug-Wächter
 
 Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
@@ -203,6 +221,11 @@ Marmor“ oder „Animiere das letzte Bild als ruhige Kamerafahrt von sechs Seku
 genügt. King wählt den passenden Medienweg und kann das asynchrone Ergebnis mit
 `GetMedia` abrufen.
 
+Ein angenommener Medienauftrag bleibt über Verdichtungen und schnelle
+Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
+verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
+die Medienerzeugung sei nicht verfügbar.
+
 Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
 und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag

package/bin/micro-compaction-policy.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+const MICRO_COMPACTION_PRESSURE_RATIO = 0.75;
+const MICRO_COMPACTION_MIN_ADVANCE_MESSAGES = 20;
+
+function selectMicroCompactionCutoff(options = {}) {
+  const historyLength = nonNegativeInteger(options.historyLength);
+  const currentCutoff = nonNegativeInteger(options.currentCutoff);
+  const keepRecentMessages = nonNegativeInteger(options.keepRecentMessages);
+  const nextCutoff = Math.max(0, historyLength - keepRecentMessages);
+  if (nextCutoff <= currentCutoff) return null;
+
+  const maxContextTokens = positiveFinite(options.maxContextTokens);
+  const contextTokens = nonNegativeFinite(options.contextTokens);
+  const contextUsageRatio = maxContextTokens === null
+    ? 1
+    : contextTokens / maxContextTokens;
+  const minContextUsageRatio = nonNegativeFinite(options.minContextUsageRatio);
+  if (contextUsageRatio < minContextUsageRatio) return null;
+
+  const now = finiteOr(options.now, Date.now());
+  const lastAssistantAt = finiteOrNull(options.lastAssistantAt);
+  const cacheAgeMs = lastAssistantAt === null ? null : Math.max(0, now - lastAssistantAt);
+  const cacheMissedThresholdMs = nonNegativeFinite(options.cacheMissedThresholdMs);
+  const cacheMissed = cacheAgeMs !== null && cacheAgeMs >= cacheMissedThresholdMs;
+  const underContextPressure = maxContextTokens !== null
+    && contextUsageRatio >= MICRO_COMPACTION_PRESSURE_RATIO;
+  if (!cacheMissed && !underContextPressure) return null;
+
+  if (
+    !cacheMissed
+    && currentCutoff > 0
+    && nextCutoff - currentCutoff < MICRO_COMPACTION_MIN_ADVANCE_MESSAGES
+  ) {
+    return null;
+  }
+
+  return {
+    cacheAgeMs,
+    contextUsageRatio,
+    cutoff: nextCutoff,
+    trigger: cacheMissed ? 'cache_miss' : 'context_pressure',
+  };
+}
+
+function finiteOr(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function finiteOrNull(value) {
+  if (value === null || value === undefined) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function nonNegativeFinite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : 0;
+}
+
+function nonNegativeInteger(value) {
+  return Math.floor(nonNegativeFinite(value));
+}
+
+function positiveFinite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : null;
+}
+
+module.exports = {
+  MICRO_COMPACTION_MIN_ADVANCE_MESSAGES,
+  MICRO_COMPACTION_PRESSURE_RATIO,
+  selectMicroCompactionCutoff,
+};

package/bin/pending-media-policy.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const TERMINAL_STATUSES = new Set([
+  'blocked',
+  'cancelled',
+  'canceled',
+  'complete',
+  'completed',
+  'expired',
+  'failed',
+  'succeeded',
+]);
+
+function validMediaId(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 200
+    && /^[A-Za-z0-9_-]+$/.test(value);
+}
+
+function terminalStatus(value) {
+  return typeof value === 'string' && TERMINAL_STATUSES.has(value.trim().toLowerCase());
+}
+
+function createPendingMediaTracker() {
+  const pending = new Set();
+
+  return {
+    observeSubmission(job) {
+      if (!validMediaId(job?.id)) return;
+      if (terminalStatus(job?.status)) pending.delete(job.id);
+      else pending.add(job.id);
+    },
+    observeLookup(result) {
+      if (!validMediaId(result?.id)) return;
+      if (result.kind !== 'status' || terminalStatus(result.status)) pending.delete(result.id);
+      else pending.add(result.id);
+    },
+    ids() {
+      return [...pending];
+    },
+  };
+}
+
+module.exports = { createPendingMediaTracker };

package/blun.mjs

@@ -75889,8 +75889,9 @@ var init_full = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/micro.ts
-var DEFAULT_CONFIG, MicroCompaction;
+var selectMicroCompactionCutoff, DEFAULT_CONFIG, MicroCompaction;
 var init_micro = __esmMin((() => {
+	({ selectMicroCompactionCutoff } = createRequire(import.meta.url)("./bin/micro-compaction-policy.cjs"));
 	init_tokens();
 	DEFAULT_CONFIG = {
 		keepRecentMessages: 20,
@@ -75920,9 +75921,67 @@ var init_micro = __esmMin((() => {
 			});
 			this.cutoff = cutoff;
 		}
-		detect() {}
+		detect() {
+			const config = this.config;
+			const { history, lastAssistantAt } = this.agent.context;
+			const maxContextTokens = this.agent.config.modelCapabilities.max_context_tokens;
+			const contextTokens = this.agent.context.tokenCountWithPending;
+			const selection = selectMicroCompactionCutoff({
+				historyLength: history.length,
+				currentCutoff: this.cutoff,
+				keepRecentMessages: config.keepRecentMessages,
+				contextTokens,
+				maxContextTokens,
+				lastAssistantAt,
+				now: Date.now(),
+				cacheMissedThresholdMs: config.cacheMissedThresholdMs,
+				minContextUsageRatio: config.minContextUsageRatio
+			});
+			if (selection === null) return;
+			const previousCutoff = this.cutoff;
+			const effect = this.measureEffect(history, selection.cutoff);
+			const previousEffect = this.measureEffect(history, previousCutoff);
+			if (effect.truncatedToolResultCount <= previousEffect.truncatedToolResultCount) return;
+			this.apply(selection.cutoff);
+			const rawContextTokens = estimateTokensForMessages(history);
+			const tokensBefore = rawContextTokens - previousEffect.truncatedToolResultTokensBefore + previousEffect.truncatedToolResultTokensAfter;
+			const tokensAfter = rawContextTokens - effect.truncatedToolResultTokensBefore + effect.truncatedToolResultTokensAfter;
+			this.agent.telemetry.track("micro_compaction_finished", {
+				trigger: selection.trigger,
+				keep_recent_messages: config.keepRecentMessages,
+				min_content_tokens: config.minContentTokens,
+				cache_missed_threshold_ms: config.cacheMissedThresholdMs,
+				truncated_marker: config.truncatedMarker,
+				min_context_usage_ratio: config.minContextUsageRatio,
+				context_usage_ratio: selection.contextUsageRatio,
+				truncated_tool_result_count: effect.truncatedToolResultCount,
+				truncated_tool_result_tokens_before: effect.truncatedToolResultTokensBefore,
+				truncated_tool_result_tokens_after: effect.truncatedToolResultTokensAfter,
+				tokens_before: tokensBefore,
+				tokens_after: tokensAfter,
+				previous_cutoff: previousCutoff,
+				cutoff: selection.cutoff,
+				message_count: history.length,
+				cache_age_ms: selection.cacheAgeMs,
+				thinking_effort: this.agent.config.thinkingEffort
+			});
+		}
 		compact(messages) {
-			return messages;
+			const config = this.config;
+			const result = [];
+			let i = 0;
+			for (const msg of messages) {
+				if (i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && estimateTokensForContentParts(msg.content) >= config.minContentTokens) result.push({
+					...msg,
+					content: [{
+						type: "text",
+						text: config.truncatedMarker
+					}]
+				});
+				else result.push(msg);
+				i++;
+			}
+			return result;
 		}
 		measureEffect(messages, cutoff) {
 			let markerTokenCount;
@@ -259942,9 +260001,14 @@ function blunToolsForOrigin(tools, origin) {
 	if (origin.kind !== "system_trigger" && origin.kind !== "injection") return tools;
 	return tools.filter((tool) => !BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
 }
-function blunFastConversationTools(tools, input) {
-	if (!BLUN_TELEGRAM_CHANNEL_RE.test(blunExtractText(input))) return [];
-	return tools.filter((tool) => BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
+function blunPendingMediaSystemPrompt(systemPrompt, pendingMediaJobIds) {
+	if (pendingMediaJobIds.length === 0) return systemPrompt;
+	return `${systemPrompt}\n\n## Pending BLUN media\n\nThe following media jobs were already accepted and are still pending: ${pendingMediaJobIds.join(", ")}. Call GetMedia exactly once for each listed id before replying. If a job is still processing, report that status truthfully and wait for a later turn; do not claim that media tools are unavailable.`;
+}
+function blunFastConversationTools(tools, input, pendingMediaJobIds = []) {
+	const telegramTurn = BLUN_TELEGRAM_CHANNEL_RE.test(blunExtractText(input));
+	const mediaPending = pendingMediaJobIds.length > 0;
+	return tools.filter((tool) => telegramTurn && BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name) || mediaPending && tool.name === "GetMedia");
 }
 /**
 * Keep frequently used native tools resident and expose every other tool by
@@ -260281,11 +260345,15 @@ var init_turn = __esmMin((() => {
 				input,
 				origin
 			});
-			const blocked = this.activeTurn !== null;
-			const buffered = !blocked && this.agent.fullCompaction.isCompacting;
+			if (this.activeTurn !== null) return {
+				accepted: false,
+				buffered: false,
+				turnId: null
+			};
+			const buffered = this.agent.fullCompaction.isCompacting;
 			const turnId = this.launch(input, origin);
 			return {
-				accepted: !blocked,
+				accepted: true,
 				buffered,
 				turnId
 			};
@@ -260773,7 +260841,9 @@ var init_turn = __esmMin((() => {
 			const turnHasAttachment = blunTurnHasAttachment(input);
 			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind);
 			const fastConversation = turnThinkingEffort === "off" || turnThinkingEffort === "low";
-			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, fastConversation ? this.agent.fastConversationSystemPrompt : void 0);
+			const pendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
+			const turnSystemPrompt = pendingMediaJobIds.length > 0 ? blunPendingMediaSystemPrompt(fastConversation ? this.agent.fastConversationSystemPrompt : this.agent.effectiveSystemPrompt, pendingMediaJobIds) : fastConversation ? this.agent.fastConversationSystemPrompt : void 0;
+			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, turnSystemPrompt);
 			let previousStepToolOutcome = "initial";
 			let currentStepHadTool = false;
 			let currentStepHadFailure = false;
@@ -260785,7 +260855,7 @@ var init_turn = __esmMin((() => {
 				try {
 					const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
 					const toolSelection = fastConversation ? {
-						tools: [...blunFastConversationTools(eligibleTools, input)],
+						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds)],
 						deferredToolCount: 0
 					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames) : {
 						tools: [],
@@ -260849,8 +260919,9 @@ var init_turn = __esmMin((() => {
 								if (steerEfforts.some((effort) => effort === void 0)) return;
 								const steerInput = pendingSteers.flatMap((steer) => [...steer.input]);
 								const steerThinkingEffort = "low";
-								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, this.agent.fastConversationSystemPrompt);
-								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput)];
+								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
+								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, blunPendingMediaSystemPrompt(this.agent.fastConversationSystemPrompt, steerPendingMediaJobIds));
+								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput, steerPendingMediaJobIds)];
 								const steerHistory = () => blunFastConversationHistory(this.agent.context.history);
 								const buildSteerMessages = () => this.agent.context.project(steerHistory(), { dropOrphanResults: true });
 								const buildSteerMessagesStrict = () => this.agent.context.project(steerHistory(), {
@@ -311242,8 +311313,9 @@ async function assertSuccess(response, operation) {
 	} catch {}
 	throw new Error(`${operation} failed: HTTP ${String(response.status)}${detail ? `: ${detail}` : ""}`);
 }
-var BlunMediaService;
+var createPendingMediaTracker, BlunMediaService;
 var init_blun_media = __esmMin((() => {
+	({ createPendingMediaTracker } = createRequire(import.meta.url)("./bin/pending-media-policy.cjs"));
 	BlunMediaService = class {
 		tokenProvider;
 		apiKey;
@@ -311251,6 +311323,7 @@ var init_blun_media = __esmMin((() => {
 		defaultHeaders;
 		customHeaders;
 		fetchImpl;
+		pendingMedia = createPendingMediaTracker();
 		constructor(options) {
 			this.tokenProvider = options.tokenProvider;
 			this.apiKey = options.apiKey;
@@ -311303,28 +311376,28 @@ var init_blun_media = __esmMin((() => {
 		}
 		async getMedia(id, options) {
 			const response = await this.request(`/media/${encodeURIComponent(id)}`, { method: "GET" }, options);
-			if (response.status === 409) return parseBlockedStatus(response, id);
-			if (response.status === 410) return {
+			if (response.status === 409) return this.trackMediaLookup(parseBlockedStatus(response, id));
+			if (response.status === 410) return this.trackMediaLookup({
 				kind: "status",
 				id,
 				status: "expired"
-			};
+			});
 			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 {
+			if (mimeType === "application/json" || mimeType.endsWith("+json")) return this.trackMediaLookup(parseStatus(await response.json(), id));
+			if (mimeType === "text/plain") return this.trackMediaLookup({
 				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 {
+			return this.trackMediaLookup({
 				kind: "file",
 				id,
 				mimeType,
 				data: new Uint8Array(await response.arrayBuffer())
-			};
+			});
 		}
 		async submit(path, body, options) {
 			const response = await this.request(path, {
@@ -311333,7 +311406,16 @@ var init_blun_media = __esmMin((() => {
 			}, options);
 			if (response.status === 409) throw await blockedSubmissionError(response);
 			await assertSuccess(response, "Media request");
-			return parseJob(await response.json());
+			const job = parseJob(await response.json());
+			this.pendingMedia.observeSubmission(job);
+			return job;
+		}
+		trackMediaLookup(result) {
+			this.pendingMedia.observeLookup(result);
+			return result;
+		}
+		pendingMediaJobIds() {
+			return this.pendingMedia.ids();
 		}
 		async request(path, init, options) {
 			const firstToken = await this.resolveToken(false);

package/package.json

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