blun-king-cli 9.1.119 → 9.1.121

package/LIESMICH.txt

@@ -117,6 +117,10 @@ Ab BLUN King 9.1.118 bleibt der Sitzungszeitstempel im Systemprompt während ein
 
 Ab BLUN King 9.1.119 enthält der bei jedem Modellschritt erneut gesendete Prompt nur noch eine kleine Auswahl häufig benötigter Skills. Alle übrigen registrierten Skills bleiben verfügbar und lassen sich über das Skill-Werkzeug anhand ihres Namens oder Zwecks suchen; der ausgewählte Skill wird anschließend bei Bedarf geladen. Dadurch sinkt die wiederholt übertragene Promptlast, ohne Skills zu löschen oder die vollständige Ansicht unter `/skills` einzuschränken.
 
+Ab BLUN King 9.1.120 lagert die Konsole auch große ältere Assistentenantworten aus dem aktiven Modellkontext in private Sitzungsdateien aus. Der vollständige Gesprächsverlauf bleibt erhalten; im Modellkontext verbleiben eine begrenzte Vorschau und der Dateipfad. Die 20 neuesten Nachrichten sowie Assistentenantworten mit Werkzeugaufrufen bleiben unverändert, damit laufende Arbeit und Aufrufketten vollständig verfügbar sind.
+
+Ab BLUN King 9.1.121 begrenzt die Modellprojektion auch die Gesamtgröße älterer, mittelgroßer Werkzeugergebnisse, die ausschließlich Text enthalten. Überschreiten Werkzeugergebnisse außerhalb der letzten 20 Nachrichten zusammen 12.000 Zeichen, archiviert King so viele der größten geeigneten Ergebnisse wie nötig und behält nur kompakte, lesbare Dateiverweise im Modellkontext. Der nur ergänzte Rohverlauf und die vollständigen Ergebnisse bleiben unverändert. Gemischte Medienergebnisse und die letzten 20 Nachrichten werden nicht angetastet. In einer gemessenen Sitzung von Fredrik wählte dieser Schnitt 12 ältere Ergebnisse aus und verringerte die projizierte alte Werkzeugausgabe um mindestens 63.444 Zeichen, also um etwa 15.861 geschätzte Token.
+
 Verliert ein delegierter Einzelagent oder ein Mitglied eines Agentenschwarms die Provider-Verbindung, erhält es eine leere Provider-Antwort, bricht sein Stream wegen Leerlaufs ab oder meldet der Server HTTP 408/500/502/503/504, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Bei Einzelagenten sowie bei Schwarm-Unterbrechungen außerhalb von HTTP 429 wartet die erste Fortsetzung zwei Sekunden und die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. HTTP 429 behält im Schwarm seine getrennte, längere Überlastungsregel. Authentifizierungs-, Zahlungs- oder Kontingent-, Richtlinien-, Kontext-, Werkzeug- und Codefehler sowie manuelle Abbrüche lösen keine automatische Fortsetzung aus. Jeder Fortsetzungsversuch verwendet die bestehende Agenten-ID, damit bereits abgeschlossene Arbeit nicht wiederholt wird.
 
 Rein lesende Sitzungsdiagnose

package/README.md

@@ -123,6 +123,10 @@ Ab BLUN King 9.1.118 bleibt der Sitzungszeitstempel im Systemprompt während ein
 
 Ab BLUN King 9.1.119 enthält der bei jedem Modellschritt erneut gesendete Prompt nur noch eine kleine Auswahl häufig benötigter Skills. Alle übrigen registrierten Skills bleiben verfügbar und lassen sich über das Skill-Werkzeug anhand ihres Namens oder Zwecks suchen; der ausgewählte Skill wird anschließend bei Bedarf geladen. Dadurch sinkt die wiederholt übertragene Promptlast, ohne Skills zu löschen oder die vollständige Ansicht unter `/skills` einzuschränken.
 
+Ab BLUN King 9.1.120 lagert die Konsole auch große ältere Assistentenantworten aus dem aktiven Modellkontext in private Sitzungsdateien aus. Der vollständige Gesprächsverlauf bleibt erhalten; im Modellkontext verbleiben eine begrenzte Vorschau und der Dateipfad. Die 20 neuesten Nachrichten sowie Assistentenantworten mit Werkzeugaufrufen bleiben unverändert, damit laufende Arbeit und Aufrufketten vollständig verfügbar sind.
+
+Ab BLUN King 9.1.121 begrenzt die Modellprojektion auch die Gesamtgröße älterer, mittelgroßer Werkzeugergebnisse, die ausschließlich Text enthalten. Überschreiten Werkzeugergebnisse außerhalb der letzten 20 Nachrichten zusammen 12.000 Zeichen, archiviert King so viele der größten geeigneten Ergebnisse wie nötig und behält nur kompakte, lesbare Dateiverweise im Modellkontext. Der nur ergänzte Rohverlauf und die vollständigen Ergebnisse bleiben unverändert. Gemischte Medienergebnisse und die letzten 20 Nachrichten werden nicht angetastet. In einer gemessenen Sitzung von Fredrik wählte dieser Schnitt 12 ältere Ergebnisse aus und verringerte die projizierte alte Werkzeugausgabe um mindestens 63.444 Zeichen, also um etwa 15.861 geschätzte Token.
+
 Ab BLUN King 9.1.99 werden auch direkt aufeinanderfolgende reine Textergebnisse als Stapel betrachtet. Enthalten sie zusammen mehr als 12.000 Zeichen, obwohl kein einzelnes Ergebnis diese Grenze überschreitet, speichert King so viele der größten geeigneten Ergebnisse wie nötig in privaten Dateien. In der Modellprojektion verbleiben lesbare Verweise. Der unveränderte Sitzungsrohverlauf bleibt vollständig erhalten. Gemischte Medienergebnisse, einzelne Ergebnisse unter 3.000 Zeichen und Stapel bis einschließlich 12.000 Zeichen bleiben unverändert. Beispiel: Bei zwei Suchergebnissen mit 7.000 und 6.000 Zeichen wird das größere Ergebnis privat gespeichert; Anfang, Ende, ausgelassene Zeichenzahl und `output_path` bleiben für den Agenten sichtbar.
 
 Ab BLUN King 9.1.100 beendet eine begrenzte Grep-Inhaltssuche ripgrep, sobald der Versatz, die angeforderten Zeilen und eine zusätzliche Vorschauzeile vollständig vorliegen. Die Vorschauzeile belegt, ob eine weitere Seite existiert, ohne vorher bis zu 10 MB einzulesen. Unbegrenzte Suchen, Trefferzählungen und nach Änderungszeit sortierte Dateilisten laufen weiterhin vollständig durch.

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

@@ -0,0 +1,51 @@
+'use strict';
+
+const ASSISTANT_MESSAGE_MAX_CHARS = 4_000;
+const ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES = 20;
+const ASSISTANT_MESSAGE_PREVIEW_LINES = 5;
+const ASSISTANT_MESSAGE_PREVIEW_LINE_CHARS = 1_000;
+const ASSISTANT_MESSAGE_OFFLOAD_MARKER = '[Assistant message offloaded]';
+
+function shouldOffloadHistoricalAssistantMessage(options = {}) {
+  const historyIndex = Number(options.historyIndex);
+  const historyLength = Number(options.historyLength);
+  const textChars = Number(options.textChars);
+  if (
+    !Number.isSafeInteger(historyIndex)
+    || !Number.isSafeInteger(historyLength)
+    || !Number.isSafeInteger(textChars)
+    || historyIndex < 0
+    || historyLength < 0
+    || historyIndex >= historyLength
+  ) return false;
+  const cutoff = Math.max(0, historyLength - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
+  return historyIndex < cutoff && textChars > ASSISTANT_MESSAGE_MAX_CHARS;
+}
+
+function createAssistantMessagePreview(text) {
+  const lines = String(text).split(/\r?\n/u);
+  const render = (line, index) => `${index}: ${line.slice(0, ASSISTANT_MESSAGE_PREVIEW_LINE_CHARS)}`;
+  if (lines.length <= ASSISTANT_MESSAGE_PREVIEW_LINES * 2) {
+    return lines.map((line, index) => render(line, index + 1)).join('\n');
+  }
+  const head = lines.slice(0, ASSISTANT_MESSAGE_PREVIEW_LINES)
+    .map((line, index) => render(line, index + 1));
+  const tailStart = lines.length - ASSISTANT_MESSAGE_PREVIEW_LINES;
+  const tail = lines.slice(tailStart)
+    .map((line, index) => render(line, tailStart + index + 1));
+  return [
+    ...head,
+    `... [${lines.length - ASSISTANT_MESSAGE_PREVIEW_LINES * 2} lines omitted] ...`,
+    ...tail,
+  ].join('\n');
+}
+
+module.exports = {
+  ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES,
+  ASSISTANT_MESSAGE_MAX_CHARS,
+  ASSISTANT_MESSAGE_OFFLOAD_MARKER,
+  ASSISTANT_MESSAGE_PREVIEW_LINES,
+  ASSISTANT_MESSAGE_PREVIEW_LINE_CHARS,
+  createAssistantMessagePreview,
+  shouldOffloadHistoricalAssistantMessage,
+};

package/bin/tool-result-offload-policy.cjs

@@ -6,6 +6,10 @@ const TOOL_RESULT_OFFLOAD_MARKER = '[Tool result offloaded]';
 const TOOL_RESULT_BATCH_MAX_CHARS = TOOL_RESULT_MAX_CHARS;
 const TOOL_RESULT_BATCH_MIN_ITEM_CHARS = 3_000;
 const TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS = 2_500;
+const TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES = 20;
+const TOOL_RESULT_HISTORICAL_MAX_CHARS = TOOL_RESULT_BATCH_MAX_CHARS;
+const TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS = 600;
+const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 600;
 
 function shouldOffloadToolResult(textLength) {
   return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
@@ -62,15 +66,50 @@ function selectToolResultBatchOffloads(textLengths) {
     : [];
 }
 
+function selectHistoricalToolResultOffloads(textLengths) {
+  if (!Array.isArray(textLengths) || textLengths.length === 0) return [];
+
+  const normalized = textLengths.map((length) => (
+    Number.isFinite(length) && length > 0 ? Math.floor(length) : 0
+  ));
+  const totalChars = normalized.reduce((total, length) => total + length, 0);
+  if (totalChars <= TOOL_RESULT_HISTORICAL_MAX_CHARS) return [];
+
+  let projectedChars = totalChars;
+  const selected = [];
+  const candidates = normalized
+    .map((length, index) => ({ index, length }))
+    .filter(({ length }) => (
+      length >= TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS
+      && length > TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS
+    ))
+    .sort((left, right) => right.length - left.length || left.index - right.index);
+
+  for (const candidate of candidates) {
+    if (projectedChars <= TOOL_RESULT_HISTORICAL_MAX_CHARS) break;
+    projectedChars -= candidate.length - TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS;
+    selected.push(candidate.index);
+  }
+
+  return projectedChars <= TOOL_RESULT_HISTORICAL_MAX_CHARS
+    ? selected.sort((left, right) => left - right)
+    : [];
+}
+
 module.exports = {
   TOOL_RESULT_BATCH_MAX_CHARS,
   TOOL_RESULT_BATCH_MIN_ITEM_CHARS,
   TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS,
+  TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES,
+  TOOL_RESULT_HISTORICAL_MAX_CHARS,
+  TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
+  TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
   TOOL_RESULT_MAX_CHARS,
   TOOL_RESULT_PREVIEW_CHARS,
   TOOL_RESULT_OFFLOAD_MARKER,
   createToolResultPreview,
   isPersistedToolResultReference,
+  selectHistoricalToolResultOffloads,
   selectToolResultBatchOffloads,
   shouldOffloadToolResult,
 };

package/blun.mjs

@@ -78799,6 +78799,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
 			this.agent.userMessageOffload.reset(this._history);
+			this.agent.assistantMessageOffload.reset(this._history);
 			this.agent.emitStatusUpdated();
 			return removedMessages.size;
 		}
@@ -78814,6 +78815,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.clear();
 			this.agent.userMessageOffload.clear();
+			this.agent.assistantMessageOffload.clear();
 			this.agent.injection.onContextClear();
 			this.agent.emitStatusUpdated();
 		}
@@ -78854,6 +78856,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
 			this.agent.userMessageOffload.reset(this._history);
+			this.agent.assistantMessageOffload.reset(this._history);
 			this.agent.emitStatusUpdated();
 			if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) throw new BlunError(ErrorCodes.REQUEST_INVALID, formatUndoUnavailableMessage(count, removedUserCount, stoppedAtBoundary), { details: {
 				reason: "undo_limit",
@@ -78934,6 +78937,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.reset(this._history);
 			this.agent.userMessageOffload.reset(this._history);
+			this.agent.assistantMessageOffload.reset(this._history);
 			this.agent.injection.onContextCompacted();
 			this.agent.emitStatusUpdated();
 			return result;
@@ -78956,7 +78960,7 @@ var init_context$2 = __esmMin((() => {
 		}
 		project(messages, options) {
 			const anomalies = [];
-			const result = project(this.agent.userMessageOffload.compact(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(dedupeRepeatedInjections(messages)))), {
+			const result = project(this.agent.assistantMessageOffload.compact(this.agent.userMessageOffload.compact(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(dedupeRepeatedInjections(messages))))), {
 				...options,
 				onAnomaly: (anomaly) => {
 					anomalies.push(anomaly);
@@ -234883,6 +234887,9 @@ function restoreAgentRecord(agent, input) {
 		case "user_message_offload.apply":
 			agent.userMessageOffload.apply(input.replacement);
 			return;
+		case "assistant_message_offload.apply":
+			agent.assistantMessageOffload.apply(input.replacement);
+			return;
 		case "plan_mode.enter":
 			agent.planMode.restoreEnter(input);
 			return;
@@ -260322,10 +260329,53 @@ function renderReadSourceReference(toolName, toolCallId, text, outputPath) {
 	lines.push("", "[preview: head and tail]", createToolResultPreview(text));
 	return lines.join("\n");
 }
+async function persistHistoricalToolResultForModel(options, knownText) {
+	const text = knownText ?? persistableToolResultText(options.result.output);
+	if (text === void 0 || options.result.truncated === true) return options.result;
+	const readSourcePath = reusableReadSourcePath(options);
+	let outputPath = readSourcePath;
+	let storageMode = "original_file";
+	if (outputPath === void 0) {
+		if (options.homedir === void 0) return options.result;
+		outputPath = await saveToolResult({
+			homedir: options.homedir,
+			toolName: options.toolName,
+			toolCallId: options.toolCallId
+		}, text);
+		storageMode = "private_archive";
+	}
+	if (outputPath === void 0) return options.result;
+	options.telemetry?.track("tool_result_historical_offloaded", {
+		...buildToolResultOffloadTelemetry({
+			toolName: options.toolName,
+			text,
+			previewChars: 0
+		}),
+		storage_mode: storageMode
+	});
+	return {
+		...options.result,
+		output: renderHistoricalToolResultReference(options.toolName, options.toolCallId, text, outputPath, storageMode),
+		...(options.result.isError === true ? { isError: true } : {})
+	};
+}
+function renderHistoricalToolResultReference(toolName, toolCallId, text, outputPath, storageMode) {
+	return [
+		TOOL_RESULT_OFFLOAD_MARKER,
+		"An older tool result was archived to keep the active context fast.",
+		`storage_mode: ${storageMode}`,
+		`tool_name: ${toolName}`,
+		`tool_call_id: ${toolCallId}`,
+		`output_size_chars: ${String(text.length)}`,
+		`output_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
+		`output_path: ${outputPath}`,
+		"next_step: Use Read with output_path if the full result is needed again."
+	].join("\n");
+}
 function safeToolResultFileStem(toolName, toolCallId) {
 	return `${toolName}-${toolCallId}`.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "tool-result";
 }
-var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_OFFLOAD_MARKER, shouldOffloadToolResult, createToolResultPreview, selectToolResultBatchOffloads, buildToolResultOffloadTelemetry;
+var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
 var init_tool_result_budget = __esmMin((() => {
 	init_dist$6();
 	const toolResultOffloadPolicy = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs");
@@ -260333,9 +260383,11 @@ var init_tool_result_budget = __esmMin((() => {
 	TOOL_RESULT_MAX_CHARS = toolResultOffloadPolicy.TOOL_RESULT_MAX_CHARS;
 	TOOL_RESULT_PREVIEW_CHARS = toolResultOffloadPolicy.TOOL_RESULT_PREVIEW_CHARS;
 	TOOL_RESULT_OFFLOAD_MARKER = toolResultOffloadPolicy.TOOL_RESULT_OFFLOAD_MARKER;
+	TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES = toolResultOffloadPolicy.TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES;
 	shouldOffloadToolResult = toolResultOffloadPolicy.shouldOffloadToolResult;
 	createToolResultPreview = toolResultOffloadPolicy.createToolResultPreview;
 	selectToolResultBatchOffloads = toolResultOffloadPolicy.selectToolResultBatchOffloads;
+	selectHistoricalToolResultOffloads = toolResultOffloadPolicy.selectHistoricalToolResultOffloads;
 }));
 //#endregion
 //#region ../../packages/agent-core/src/agent/turn/tool-result-batch-offload.ts
@@ -260353,7 +260405,20 @@ var ToolResultBatchOffload = class {
 			if (message?.role !== "tool") break;
 			tail.unshift(message);
 		}
-		const candidates = tail.map((message) => {
+		const tailIds = new Set(tail.map((message) => message.toolCallId).filter((id) => id !== void 0));
+		const recentStart = Math.max(0, history.length - TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES);
+		const historical = history.slice(0, recentStart).filter((message) => message?.role === "tool" && !tailIds.has(message.toolCallId));
+		const candidateBatches = [{
+			messages: tail,
+			historical: false,
+			select: selectToolResultBatchOffloads
+		}, {
+			messages: historical,
+			historical: true,
+			select: selectHistoricalToolResultOffloads
+		}].map((batch) => ({
+			...batch,
+			candidates: batch.messages.map((message) => {
 			if (message.toolCallId === void 0 || this.replacements.has(message.toolCallId) || isPersistedToolResultReference(message.content)) return;
 			const text = persistableToolResultText(message.content);
 			if (text === void 0) return;
@@ -260364,15 +260429,19 @@ var ToolResultBatchOffload = class {
 				toolName: toolCall?.name ?? "Tool",
 				toolArgs: this.toolArgsFor(toolCall)
 			};
-		}).filter((candidate) => candidate !== void 0);
-		const selected = selectToolResultBatchOffloads(candidates.map((candidate) => candidate.text.length));
-		if (selected.length === 0) return 0;
+			}).filter((candidate) => candidate !== void 0)
+		}));
+		const selectedCandidates = candidateBatches.flatMap((batch) => batch.select(batch.candidates.map((candidate) => candidate.text.length)).map((index) => {
+			const candidate = batch.candidates[index];
+			return candidate === void 0 ? void 0 : { ...candidate, historical: batch.historical };
+		}).filter((candidate) => candidate !== void 0));
+		if (selectedCandidates.length === 0) return 0;
 		const replacements = [];
 		let charsBefore = 0;
 		let charsAfter = 0;
-		for (const index of selected) {
-			const candidate = candidates[index];
-			if (candidate === void 0) continue;
+		let historicalResultCount = 0;
+		let tailResultCount = 0;
+		for (const candidate of selectedCandidates) {
 			const original = {
 				output: candidate.message.content,
 				isError: candidate.message.isError
@@ -260386,7 +260455,7 @@ var ToolResultBatchOffload = class {
 				telemetry: this.agent.telemetry
 			};
 			const readSourcePath = reusableReadSourcePath(resultOptions);
-			const persisted = readSourcePath === void 0 ? await persistToolResultForModel(resultOptions, candidate.text) : referenceReadSourceForModel(resultOptions, candidate.text, readSourcePath);
+			const persisted = candidate.historical ? await persistHistoricalToolResultForModel(resultOptions, candidate.text) : readSourcePath === void 0 ? await persistToolResultForModel(resultOptions, candidate.text) : referenceReadSourceForModel(resultOptions, candidate.text, readSourcePath);
 			if (persisted === original || typeof persisted.output !== "string" || persisted.output.length >= candidate.text.length) continue;
 			const content = [{
 				type: "text",
@@ -260398,11 +260467,15 @@ var ToolResultBatchOffload = class {
 			});
 			charsBefore += candidate.text.length;
 			charsAfter += persisted.output.length;
+			if (candidate.historical) historicalResultCount += 1;
+			else tailResultCount += 1;
 		}
 		if (replacements.length === 0) return 0;
 		this.apply(replacements);
 		this.agent.telemetry.track("tool_result_batch_offloaded", {
 			result_count: replacements.length,
+			historical_result_count: historicalResultCount,
+			tail_result_count: tailResultCount,
 			chars_before: charsBefore,
 			chars_after: charsAfter,
 			chars_saved: charsBefore - charsAfter
@@ -260584,6 +260657,129 @@ var UserMessageOffload = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/turn/assistant-message-offload.ts
+function persistableAssistantMessageText(message) {
+	if (message?.role !== "assistant" || message.toolCalls.length > 0) return;
+	const textParts = message.content.filter((part) => part.type === "text");
+	if (textParts.length === 0) return;
+	return textParts.map((part) => part.text).join("\n");
+}
+function assistantMessageOffloadHash(message, text) {
+	return createHash("sha256").update(JSON.stringify({ text })).digest("hex");
+}
+async function saveAssistantMessage(homedir, text) {
+	try {
+		const dir = join$4(homedir, "conversation-history");
+		await mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const outputPath = join$4(dir, `assistant-message-${randomUUID()}.txt`);
+		await writeFile(outputPath, text, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		return outputPath;
+	} catch {
+		return;
+	}
+}
+function renderPersistedAssistantMessage(text, outputPath) {
+	return [
+		ASSISTANT_MESSAGE_OFFLOAD_MARKER,
+		"The complete original was archived to keep the active context fast and remains available on disk.",
+		`message_size_chars: ${String(text.length)}`,
+		`message_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
+		`output_path: ${outputPath}`,
+		"next_step: Use Read with output_path to inspect the complete message in pages.",
+		"",
+		"[preview: head and tail]",
+		createAssistantMessagePreview(text)
+	].join("\n");
+}
+var ASSISTANT_MESSAGE_MAX_CHARS, ASSISTANT_MESSAGE_OFFLOAD_MARKER, shouldOffloadHistoricalAssistantMessage, createAssistantMessagePreview;
+var init_assistant_message_offload = __esmMin((() => {
+	const policy = createRequire(import.meta.url)("./bin/assistant-message-offload-policy.cjs");
+	ASSISTANT_MESSAGE_MAX_CHARS = policy.ASSISTANT_MESSAGE_MAX_CHARS;
+	ASSISTANT_MESSAGE_OFFLOAD_MARKER = policy.ASSISTANT_MESSAGE_OFFLOAD_MARKER;
+	shouldOffloadHistoricalAssistantMessage = policy.shouldOffloadHistoricalAssistantMessage;
+	createAssistantMessagePreview = policy.createAssistantMessagePreview;
+}));
+var AssistantMessageOffload = class {
+	agent;
+	replacements = /* @__PURE__ */ new Map();
+	constructor(agent) {
+		this.agent = agent;
+	}
+	async detect() {
+		const history = this.agent.context.history;
+		if (this.agent.homedir === void 0) return 0;
+		let offloaded = 0;
+		for (let historyIndex = 0; historyIndex < history.length; historyIndex++) {
+			const message = history[historyIndex];
+			const text = persistableAssistantMessageText(message);
+			if (text === void 0 || !shouldOffloadHistoricalAssistantMessage({
+				historyIndex,
+				historyLength: history.length,
+				textChars: text.length
+			})) continue;
+			const messageHash = assistantMessageOffloadHash(message, text);
+			if (this.replacements.has(messageHash)) continue;
+			const outputPath = await saveAssistantMessage(this.agent.homedir, text);
+			if (outputPath === void 0) continue;
+			const replacementText = renderPersistedAssistantMessage(text, outputPath);
+			const content = [{
+				type: "text",
+				text: replacementText
+			}, ...message.content.filter((part) => part.type !== "text")];
+			this.apply({
+				messageHash,
+				content,
+				outputPath
+			});
+			this.agent.telemetry.track("assistant_message_offloaded", {
+				chars_before: text.length,
+				chars_after: replacementText.length,
+				chars_saved: text.length - replacementText.length,
+				non_text_part_count: content.length - 1,
+				reason: "historical_oversize"
+			});
+			offloaded++;
+		}
+		return offloaded;
+	}
+	apply(replacement) {
+		this.replacements.set(replacement.messageHash, replacement);
+		this.agent.records.logRecord({
+			type: "assistant_message_offload.apply",
+			replacement
+		});
+	}
+	compact(messages) {
+		if (this.replacements.size === 0) return messages;
+		return messages.map((message) => {
+			const text = persistableAssistantMessageText(message);
+			if (text === void 0) return message;
+			const replacement = this.replacements.get(assistantMessageOffloadHash(message, text));
+			return replacement === void 0 ? message : {
+				...message,
+				content: replacement.content
+			};
+		});
+	}
+	reset(history = this.agent.context?.history ?? []) {
+		const activeHashes = new Set(history.map((message) => {
+			const text = persistableAssistantMessageText(message);
+			return text === void 0 ? void 0 : assistantMessageOffloadHash(message, text);
+		}).filter((hash) => hash !== void 0));
+		for (const messageHash of this.replacements.keys()) if (!activeHashes.has(messageHash)) this.replacements.delete(messageHash);
+	}
+	clear() {
+		this.replacements.clear();
+	}
+};
+//#endregion
 //#region ../../packages/agent-core/src/agent/turn/index.ts
 function blunExtractText(content) {
 	if (typeof content === "string") return content;
@@ -260920,6 +261116,7 @@ var init_turn = __esmMin((() => {
 	init_tool_dedup();
 	init_tool_result_budget();
 	init_user_message_offload();
+	init_assistant_message_offload();
 	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	BLUN_LEAN_TOOL_NAMES = new Set(BLUN_CORE_TOOL_NAMES);
 	BLUN_ATTACHMENT_MARKER_RE = /\b(?:attachment_file_id|telegram-anhang|telegram attachment)\b/i;
@@ -261555,6 +261752,7 @@ var init_turn = __esmMin((() => {
 								await this.agent.records.flush();
 								this.agent.microCompaction.detect();
 								await this.agent.userMessageOffload.detect();
+								await this.agent.assistantMessageOffload.detect();
 								await this.agent.injection.inject();
 								stepSignal.throwIfAborted();
 								deduper.beginStep();
@@ -264332,6 +264530,7 @@ var init_agent = __esmMin((() => {
 		fullCompaction;
 		microCompaction;
 		toolResultBatchOffload;
+		assistantMessageOffload;
 		context;
 		config;
 		turn;
@@ -264392,6 +264591,7 @@ var init_agent = __esmMin((() => {
 			this.microCompaction = new MicroCompaction(this, options.microCompaction);
 			this.toolResultBatchOffload = new ToolResultBatchOffload(this);
 			this.userMessageOffload = new UserMessageOffload(this);
+			this.assistantMessageOffload = new AssistantMessageOffload(this);
 			this.context = new ContextMemory(this);
 			this.config = new ConfigState(this);
 			this.turn = new TurnFlow(this);

package/package.json

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