blun-king-cli 9.1.76 → 9.1.78

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
 -----
@@ -72,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
@@ -199,6 +213,21 @@ sodass auch kurze Schritte wie Rendern und Speichern in der Produktionskette
 sichtbar sind. Aktualisierte Vorschaubilder werden erneuert; Medienpfade und
 Webadressen sind als Terminalverweise anklickbar.
 
+Wiederauffindbarer Verdichtungsverlauf
+--------------------------------------
+
+Bevor eine erfolgreiche Vollverdichtung ältere Nachrichten ersetzt, schreibt
+King den verdrängten Verlauf in ein privates Markdown-Archiv unter
+~/.blun/conversation-history/. Die Verdichtungszusammenfassung enthält den
+genauen history_path, sodass der Agent mit Read Einzelheiten wiederfinden kann,
+die nicht in der Zusammenfassung stehen.
+
+Eingebettete Bild-, Audio- und Videodaten werden im Archiv nicht doppelt
+gespeichert. Der ursprüngliche Sitzungs-Wire bleibt maßgeblich. Kann das Archiv
+nicht geschrieben werden, protokolliert King compaction_history_archive_failed
+und lässt den normalen Verdichtungsweg verfügbar; ein Archivfehler löscht
+niemals den gespeicherten Sitzungsverlauf.
+
 Aktualisieren
 -------------
 

package/README.md

@@ -94,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
@@ -226,6 +240,12 @@ sodass auch kurze Schritte wie Rendern und Speichern in der Produktionskette
 sichtbar sind. Aktualisierte Vorschaubilder werden erneuert; Medienpfade und
 Webadressen sind als Terminalverweise anklickbar.
 
+## Wiederauffindbarer Verdichtungsverlauf
+
+Bevor eine erfolgreiche Vollverdichtung ältere Nachrichten ersetzt, schreibt King den verdrängten Verlauf in ein privates Markdown-Archiv unter `~/.blun/conversation-history/`. Die Verdichtungszusammenfassung enthält den genauen `history_path`, sodass der Agent mit `Read` Einzelheiten wiederfinden kann, die nicht in der Zusammenfassung stehen.
+
+Eingebettete Bild-, Audio- und Videodaten werden im Archiv nicht doppelt gespeichert. Der ursprüngliche Sitzungs-Wire bleibt maßgeblich. Kann das Archiv nicht geschrieben werden, protokolliert King `compaction_history_archive_failed` und lässt den normalen Verdichtungsweg verfügbar; ein Archivfehler löscht niemals den gespeicherten Sitzungsverlauf.
+
 ## Aktualisieren
 
 `blun update`, `king update` und die jeweilige Variante `upgrade` verwenden

package/bin/compaction-history-archive.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const { mkdir, writeFile } = require('node:fs/promises');
+const path = require('node:path');
+
+const COMPACTION_HISTORY_DIR = 'conversation-history';
+const INLINE_MEDIA_NOTICE = '[inline media payload omitted; original remains in session wire]';
+
+async function archiveCompactionHistory(options = {}) {
+  const homedir = requiredString(options.homedir, 'homedir');
+  const messages = Array.isArray(options.messages) ? options.messages : [];
+  const now = finiteNumber(options.now, Date.now());
+  const id = safeFilePart(options.id || randomUUID());
+  const dir = path.join(homedir, COMPACTION_HISTORY_DIR);
+  const timestamp = new Date(now).toISOString().replace(/[:.]/g, '-');
+  const outputPath = path.join(dir, `compaction-${timestamp}-${id}.md`);
+
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  await writeFile(outputPath, serializeCompactionHistory(messages, { now }), {
+    encoding: 'utf8',
+    flag: 'wx',
+    mode: 0o600,
+  });
+  return outputPath;
+}
+
+function serializeCompactionHistory(messages, options = {}) {
+  const now = finiteNumber(options.now, Date.now());
+  const lines = [
+    '# BLUN conversation history archive',
+    '',
+    `Archived at: ${new Date(now).toISOString()}`,
+    `Messages: ${messages.length}`,
+    '',
+    'This file contains the messages displaced by a full context compaction.',
+    'Inline media payloads are omitted here; the original session wire remains authoritative.',
+  ];
+
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = sanitizeMessage(messages[index]);
+    lines.push(
+      '',
+      `## Message ${index + 1}: ${typeof message?.role === 'string' ? message.role : 'unknown'}`,
+      '',
+      '```json',
+      JSON.stringify(message, null, 2),
+      '```',
+    );
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function buildCompactionArchiveNotice(historyPath) {
+  return [
+    '<system-reminder>',
+    'The complete messages displaced by this compaction were archived locally.',
+    `history_path: ${historyPath}`,
+    'next_step: Use Read with history_path to recover exact details that the summary omitted.',
+    '</system-reminder>',
+  ].join('\n');
+}
+
+function sanitizeMessage(message) {
+  if (message === null || typeof message !== 'object') return message;
+  if (!Array.isArray(message.content)) return message;
+  return {
+    ...message,
+    content: message.content.map(sanitizeContentPart),
+  };
+}
+
+function sanitizeContentPart(part) {
+  if (part === null || typeof part !== 'object') return part;
+  if (part.type === 'image_url' && isInlineMediaUrl(part.imageUrl?.url)) {
+    return { type: 'text', text: INLINE_MEDIA_NOTICE };
+  }
+  if (part.type === 'audio_url' && isInlineMediaUrl(part.audioUrl?.url)) {
+    return { type: 'text', text: INLINE_MEDIA_NOTICE };
+  }
+  if (part.type === 'video_url' && isInlineMediaUrl(part.videoUrl?.url)) {
+    return { type: 'text', text: INLINE_MEDIA_NOTICE };
+  }
+  return part;
+}
+
+function isInlineMediaUrl(value) {
+  return typeof value === 'string' && /^data:(?:image|audio|video)\//i.test(value);
+}
+
+function requiredString(value, name) {
+  if (typeof value === 'string' && value.length > 0) return value;
+  throw new TypeError(`${name} must be a non-empty string`);
+}
+
+function safeFilePart(value) {
+  const cleaned = String(value).replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 96);
+  return cleaned || randomUUID();
+}
+
+function finiteNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+module.exports = {
+  COMPACTION_HISTORY_DIR,
+  archiveCompactionHistory,
+  buildCompactionArchiveNotice,
+  serializeCompactionHistory,
+};

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/blun.mjs

@@ -75237,8 +75237,9 @@ function extractCompactionSummary(response) {
 	if (summary.trim().length === 0) throw new APIEmptyResponseError("The compaction response did not contain a non-empty summary.");
 	return summary;
 }
-var DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS, COMPACTION_THINKING_EFFORT, COMPACTION_SUMMARY_RESERVE_RATIO, MAX_HIERARCHICAL_COMPACTION_PASSES, HIERARCHICAL_COMPACTION_PREFIX, CompactionTruncatedError, CompactionStallError, COMPACTION_STALL_MEASUREMENT_MULTIPLIER, REBUILT_AFTER_COMPACTION_INJECTION_VARIANTS, FullCompaction, MAX_COMPACTION_OVERFLOW_SHRINK_ATTEMPTS, COMPACTION_OVERFLOW_SHRINK_RATIOS;
+var archiveCompactionHistory, buildCompactionArchiveNotice, DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS, COMPACTION_THINKING_EFFORT, COMPACTION_SUMMARY_RESERVE_RATIO, MAX_HIERARCHICAL_COMPACTION_PASSES, HIERARCHICAL_COMPACTION_PREFIX, CompactionTruncatedError, CompactionStallError, COMPACTION_STALL_MEASUREMENT_MULTIPLIER, REBUILT_AFTER_COMPACTION_INJECTION_VARIANTS, FullCompaction, MAX_COMPACTION_OVERFLOW_SHRINK_ATTEMPTS, COMPACTION_OVERFLOW_SHRINK_RATIOS;
 var init_full = __esmMin((() => {
+	({ archiveCompactionHistory, buildCompactionArchiveNotice } = createRequire(import.meta.url)("./bin/compaction-history-archive.cjs"));
 	init_errors$8();
 	init_src$4();
 	init_errors$4();
@@ -75773,7 +75774,24 @@ var init_full = __esmMin((() => {
 					return;
 				}
 				const rawSummary = this.postProcessSummary(summary ?? "");
-				const contextSummary = buildCompactionSummaryText(rawSummary);
+				let contextSummary = buildCompactionSummaryText(rawSummary);
+				let historyPath;
+				try {
+					historyPath = await archiveCompactionHistory({
+						homedir: this.agent.blunHomeDir,
+						messages: originalHistory
+					});
+					contextSummary = `${contextSummary}\n\n${buildCompactionArchiveNotice(historyPath)}`;
+					this.agent.telemetry.track("compaction_history_archived", {
+						history_path: historyPath,
+						message_count: originalHistory.length
+					});
+				} catch (error) {
+					this.agent.telemetry.track("compaction_history_archive_failed", {
+						message_count: originalHistory.length,
+						error_type: error instanceof Error ? error.name : "Unknown"
+					});
+				}
 				const result = this.agent.context.applyCompaction({
 					summary: rawSummary,
 					contextSummary,
@@ -75889,8 +75907,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 +75939,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;

package/package.json

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