blun-king-cli 9.1.99 → 9.1.101

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.99
+  npm install -g blun-king-cli@9.1.100
 
 Start
 -----
@@ -93,6 +93,8 @@ Große textbasierte Werkzeugergebnisse bleiben nicht mehr vollständig im Modell
 
 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.
+
 Große Dateien werden weiterhin seitenweise gelesen. Erreicht `Read` seine interne Grenze von 1.000 Zeilen und enthält die Datei weitere Zeilen, nennt das Ergebnis jetzt den exakten nächsten `line_offset`. Beispiel: Ein Lesevorgang ab Zeile 2001 wird mit `line_offset=3001` fortgesetzt. Am Dateiende und bei einem bewusst kleineren Leseausschnitt erscheint kein Fortsetzungshinweis. Dadurch zieht der Agent keine Schlüsse aus einem unvollständigen Ausschnitt und liest die Datei nicht erneut ab der ersten Zeile.
 
 Das Telemetrieereignis `tool_result_offloaded` enthält ausschließlich `tool_name`, `output_size_chars`, `output_size_bytes` und `preview_size_chars`. Es enthält weder den Inhalt noch den Speicherpfad. Beispiel: Eine Ausgabe mit 80.000 Zeichen erzeugt eine Vorschau mit 2.000 Zeichen; die Telemetrie zeigt die Größenersparnis, ohne Nutzdaten zu protokollieren.

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.99
+npm install -g blun-king-cli@9.1.100
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -113,6 +113,8 @@ Große textbasierte Werkzeugergebnisse bleiben nicht mehr vollständig im Modell
 
 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.
+
 Große Dateien werden weiterhin seitenweise gelesen. Erreicht `Read` seine interne Grenze von 1.000 Zeilen und enthält die Datei weitere Zeilen, nennt das Ergebnis jetzt den exakten nächsten `line_offset`. Beispiel: Ein Lesevorgang ab Zeile 2001 wird mit `line_offset=3001` fortgesetzt. Am Dateiende und bei einem bewusst kleineren Leseausschnitt erscheint kein Fortsetzungshinweis. Dadurch zieht der Agent keine Schlüsse aus einem unvollständigen Ausschnitt und liest die Datei nicht erneut ab der ersten Zeile.
 
 Das Telemetrieereignis `tool_result_offloaded` enthält ausschließlich `tool_name`, `output_size_chars`, `output_size_bytes` und `preview_size_chars`. Es enthält weder den Inhalt noch den Speicherpfad. Beispiel: Eine Ausgabe mit 80.000 Zeichen erzeugt eine Vorschau mit 2.000 Zeichen; die Telemetrie zeigt die Größenersparnis, ohne Nutzdaten zu protokollieren.

package/bin/grep-output-limit-policy.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+function grepContentRecordLimit(args = {}) {
+  const mode = args.output_mode ?? "files_with_matches";
+  const headLimit = args.head_limit ?? 250;
+  const offset = args.offset ?? 0;
+  if (mode !== "content" || !Number.isSafeInteger(headLimit) || headLimit <= 0) return undefined;
+  if (!Number.isSafeInteger(offset) || offset < 0) return undefined;
+  const limit = offset + headLimit + 1;
+  return Number.isSafeInteger(limit) ? limit : undefined;
+}
+
+function grepPaginationNotice({ headLimit, offset, afterOffsetLength, earlyStopped = false }) {
+  const nextOffset = offset + headLimit;
+  const observedTotal = afterOffsetLength + offset;
+  const total = earlyStopped ? `at least ${String(observedTotal)}` : String(observedTotal);
+  return `Results truncated to ${String(headLimit)} lines (total: ${total}). Use offset=${String(nextOffset)} to see more.`;
+}
+
+function sliceThroughNewlineLimit(buffer, remainingNewlines) {
+  if (!Number.isSafeInteger(remainingNewlines) || remainingNewlines <= 0) {
+    return { accepted: buffer, newlineCount: 0, stopped: false };
+  }
+  let newlineCount = 0;
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (buffer[index] !== 10) continue;
+    newlineCount += 1;
+    if (newlineCount === remainingNewlines) {
+      return { accepted: buffer.subarray(0, index + 1), newlineCount, stopped: true };
+    }
+  }
+  return { accepted: buffer, newlineCount, stopped: false };
+}
+
+module.exports = {
+  grepContentRecordLimit,
+  grepPaginationNotice,
+  sliceThroughNewlineLimit,
+};

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

@@ -0,0 +1,37 @@
+'use strict';
+
+const USER_MESSAGE_MAX_CHARS = 200_000;
+const USER_MESSAGE_PREVIEW_LINES = 5;
+const USER_MESSAGE_PREVIEW_LINE_CHARS = 1_000;
+const USER_MESSAGE_OFFLOAD_MARKER = '[User message offloaded]';
+
+function shouldOffloadUserMessage(textChars) {
+  return Number.isSafeInteger(textChars) && textChars > USER_MESSAGE_MAX_CHARS;
+}
+
+function createUserMessagePreview(text) {
+  const lines = String(text).split(/\r?\n/u);
+  const render = (line, index) => `${index}: ${line.slice(0, USER_MESSAGE_PREVIEW_LINE_CHARS)}`;
+  if (lines.length <= USER_MESSAGE_PREVIEW_LINES * 2) {
+    return lines.map((line, index) => render(line, index + 1)).join('\n');
+  }
+  const head = lines.slice(0, USER_MESSAGE_PREVIEW_LINES)
+    .map((line, index) => render(line, index + 1));
+  const tailStart = lines.length - USER_MESSAGE_PREVIEW_LINES;
+  const tail = lines.slice(tailStart)
+    .map((line, index) => render(line, tailStart + index + 1));
+  return [
+    ...head,
+    `... [${lines.length - USER_MESSAGE_PREVIEW_LINES * 2} lines omitted] ...`,
+    ...tail,
+  ].join('\n');
+}
+
+module.exports = {
+  USER_MESSAGE_MAX_CHARS,
+  USER_MESSAGE_OFFLOAD_MARKER,
+  USER_MESSAGE_PREVIEW_LINES,
+  USER_MESSAGE_PREVIEW_LINE_CHARS,
+  createUserMessagePreview,
+  shouldOffloadUserMessage,
+};

package/blun.mjs

@@ -78758,6 +78758,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.replayBuilder.removeLastMessages(removedMessages);
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.reset(this._history);
 			this.agent.emitStatusUpdated();
 			return removedMessages.size;
 		}
@@ -78772,6 +78773,7 @@ var init_context$2 = __esmMin((() => {
 			this._lastAssistantAt = null;
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.clear();
+			this.agent.userMessageOffload.clear();
 			this.agent.injection.onContextClear();
 			this.agent.emitStatusUpdated();
 		}
@@ -78811,6 +78813,7 @@ var init_context$2 = __esmMin((() => {
 			this.deferredMessages = [];
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.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",
@@ -78890,6 +78893,7 @@ var init_context$2 = __esmMin((() => {
 			this.tokenCountCoveredMessageCount = this._history.length;
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.reset(this._history);
 			this.agent.injection.onContextCompacted();
 			this.agent.emitStatusUpdated();
 			return result;
@@ -78912,7 +78916,7 @@ var init_context$2 = __esmMin((() => {
 		}
 		project(messages, options) {
 			const anomalies = [];
-			const result = project(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(messages)), {
+			const result = project(this.agent.userMessageOffload.compact(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(messages))), {
 				...options,
 				onAnomaly: (anomaly) => {
 					anomalies.push(anomaly);
@@ -234835,6 +234839,9 @@ function restoreAgentRecord(agent, input) {
 		case "tool_result_batch_offload.apply":
 			agent.toolResultBatchOffload.apply(input.replacements);
 			return;
+		case "user_message_offload.apply":
+			agent.userMessageOffload.apply(input.replacement);
+			return;
 		case "plan_mode.enter":
 			agent.planMode.restoreEnter(input);
 			return;
@@ -257665,10 +257672,17 @@ async function runRipgrepOnce(kaos, rgArgs, signal, options = {}) {
 	let stderrText = "";
 	let bufferTruncated = false;
 	let stderrTruncated = false;
+	let earlyStopped = false;
 	try {
-		const isTerminating = () => timedOut || aborted || killed;
+		const isTerminating = () => timedOut || aborted || killed || earlyStopped;
 		const [stdoutResult, stderrResult, code] = await Promise.all([
-			readStreamWithCap(proc.stdout, MAX_OUTPUT_BYTES$1, isTerminating),
+			readStreamWithCap(proc.stdout, MAX_OUTPUT_BYTES$1, isTerminating, {
+				stopAfterDelimiterCount: options.stdoutRecordLimit,
+				onStop: () => {
+					earlyStopped = true;
+					void killProc();
+				}
+			}),
 			readStreamWithCap(proc.stderr, MAX_OUTPUT_BYTES$1, isTerminating),
 			proc.wait()
 		]);
@@ -257704,7 +257718,8 @@ async function runRipgrepOnce(kaos, rgArgs, signal, options = {}) {
 		stderrText,
 		bufferTruncated,
 		stderrTruncated,
-		timedOut
+		timedOut,
+		earlyStopped
 	};
 }
 function shouldRetryRipgrepEagain(result) {
@@ -257713,23 +257728,37 @@ function shouldRetryRipgrepEagain(result) {
 function isEagainRipgrepError(stderr) {
 	return stderr.includes("os error 11") || stderr.includes("Resource temporarily unavailable");
 }
-async function readStreamWithCap(stream, maxBytes, suppressPrematureClose) {
+async function readStreamWithCap(stream, maxBytes, suppressPrematureClose, options = {}) {
 	const chunks = [];
 	let total = 0;
 	let truncated = false;
+	let delimiterCount = 0;
 	try {
 		for await (const chunk of stream) {
 			const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
 			if (truncated) continue;
-			if (total + buf.length > maxBytes) {
+			let accepted = buf;
+			let stoppedAtRecordLimit = false;
+			const delimiterLimit = options.stopAfterDelimiterCount;
+			if (Number.isSafeInteger(delimiterLimit) && delimiterLimit > 0) {
+				const slice = sliceThroughNewlineLimit(buf, delimiterLimit - delimiterCount);
+				accepted = slice.accepted;
+				delimiterCount += slice.newlineCount;
+				stoppedAtRecordLimit = slice.stopped;
+			}
+			if (total + accepted.length > maxBytes) {
 				const remaining = maxBytes - total;
-				if (remaining > 0) chunks.push(buf.subarray(0, remaining));
+				if (remaining > 0) chunks.push(accepted.subarray(0, remaining));
 				total = maxBytes;
 				truncated = true;
 				continue;
 			}
-			chunks.push(buf);
-			total += buf.length;
+			chunks.push(accepted);
+			total += accepted.length;
+			if (stoppedAtRecordLimit) {
+				options.onStop?.();
+				break;
+			}
 		}
 	} catch (error) {
 		if (!isPrematureCloseError(error) || suppressPrematureClose?.() !== true) throw error;
@@ -258358,7 +258387,7 @@ function countPayloadFromLegacyLine(line) {
 	const idx = line.lastIndexOf(":");
 	return idx > 0 ? line.slice(idx + 1) : void 0;
 }
-var GrepInputSchema, RG_MAX_COLUMNS, DEFAULT_HEAD_LIMIT, MTIME_STAT_CONCURRENCY, CONTENT_LINE_RE, GrepTool, GrepAbortedError;
+var GrepInputSchema, RG_MAX_COLUMNS, DEFAULT_HEAD_LIMIT, MTIME_STAT_CONCURRENCY, CONTENT_LINE_RE, GrepTool, GrepAbortedError, grepContentRecordLimit, grepPaginationNotice, sliceThroughNewlineLimit;
 var init_grep = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -258373,6 +258402,7 @@ var init_grep = __esmMin((() => {
 	init_result_builder();
 	init_run_rg();
 	init_grep$1();
+	({ grepContentRecordLimit, grepPaginationNotice, sliceThroughNewlineLimit } = createRequire(import.meta.url)("./bin/grep-output-limit-policy.cjs"));
 	GrepInputSchema = object({
 		pattern: string().describe("Regular expression to search for."),
 		path: string().optional().describe("File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents."),
@@ -258473,15 +258503,21 @@ var init_grep = __esmMin((() => {
 					output: rgUnavailableMessage(error)
 				};
 			}
-			let runResult = await runRipgrepOnce(this.kaos, buildRgArgs(rgPath, args, searchPaths), signal, { abortedMessage: "Grep aborted" });
+			let runResult = await runRipgrepOnce(this.kaos, buildRgArgs(rgPath, args, searchPaths), signal, {
+				abortedMessage: "Grep aborted",
+				stdoutRecordLimit: grepContentRecordLimit(args)
+			});
 			if (runResult.kind === "tool-error") return runResult.result;
 			if (shouldRetryRipgrepEagain(runResult)) {
-				runResult = await runRipgrepOnce(this.kaos, buildRgArgs(rgPath, args, searchPaths, true), signal, { abortedMessage: "Grep aborted" });
+				runResult = await runRipgrepOnce(this.kaos, buildRgArgs(rgPath, args, searchPaths, true), signal, {
+					abortedMessage: "Grep aborted",
+					stdoutRecordLimit: grepContentRecordLimit(args)
+				});
 				if (runResult.kind === "tool-error") return runResult.result;
 			}
-			const { exitCode, stderrText, bufferTruncated, stderrTruncated, timedOut } = runResult;
+			const { exitCode, stderrText, bufferTruncated, stderrTruncated, timedOut, earlyStopped } = runResult;
 			let { stdoutText } = runResult;
-			if (exitCode !== 0 && exitCode !== 1 && !timedOut) return {
+			if (exitCode !== 0 && exitCode !== 1 && !timedOut && !earlyStopped) return {
 				isError: true,
 				output: formatRipgrepError(exitCode, stderrText, stderrTruncated)
 			};
@@ -258522,9 +258558,12 @@ var init_grep = __esmMin((() => {
 			}
 			if (mode === "count_matches" && orderedLines.length > 0) headerLines.push(formatCountSummary(orderedLines, filteredSensitive.size > 0));
 			if (paginationTruncated) {
-				const total = afterOffset.length + offset;
-				const nextOffset = offset + headLimit;
-				const paginationNotice = `Results truncated to ${String(headLimit)} lines (total: ${String(total)}). Use offset=${String(nextOffset)} to see more.`;
+				const paginationNotice = grepPaginationNotice({
+					headLimit,
+					offset,
+					afterOffsetLength: afterOffset.length,
+					earlyStopped
+				});
 				if (mode === "count_matches") headerLines.push(paginationNotice);
 				else messages.push(paginationNotice);
 			}
@@ -260205,6 +260244,121 @@ var ToolResultBatchOffload = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/turn/user-message-offload.ts
+function persistableUserMessageText(message) {
+	if (message?.role !== "user" || message.origin?.kind !== "user") return;
+	const textParts = message.content.filter((part) => part.type === "text");
+	if (textParts.length === 0) return;
+	return textParts.map((part) => part.text).join("\n");
+}
+function userMessageOffloadHash(message, text) {
+	return createHash("sha256").update(JSON.stringify({
+		origin: message.origin,
+		text
+	})).digest("hex");
+}
+async function saveUserMessage(homedir, text) {
+	try {
+		const dir = join$4(homedir, "conversation-history");
+		await mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const outputPath = join$4(dir, `user-message-${randomUUID()}.txt`);
+		await writeFile(outputPath, text, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		return outputPath;
+	} catch {
+		return;
+	}
+}
+function renderPersistedUserMessage(text, outputPath) {
+	return [
+		USER_MESSAGE_OFFLOAD_MARKER,
+		`Message text exceeded ${String(USER_MESSAGE_MAX_CHARS)} characters; the complete original remains in conversation history.`,
+		`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]",
+		createUserMessagePreview(text)
+	].join("\n");
+}
+var USER_MESSAGE_MAX_CHARS, USER_MESSAGE_OFFLOAD_MARKER, shouldOffloadUserMessage, createUserMessagePreview;
+var init_user_message_offload = __esmMin((() => {
+	const policy = createRequire(import.meta.url)("./bin/user-message-offload-policy.cjs");
+	USER_MESSAGE_MAX_CHARS = policy.USER_MESSAGE_MAX_CHARS;
+	USER_MESSAGE_OFFLOAD_MARKER = policy.USER_MESSAGE_OFFLOAD_MARKER;
+	shouldOffloadUserMessage = policy.shouldOffloadUserMessage;
+	createUserMessagePreview = policy.createUserMessagePreview;
+}));
+var UserMessageOffload = class {
+	agent;
+	replacements = /* @__PURE__ */ new Map();
+	constructor(agent) {
+		this.agent = agent;
+	}
+	async detect() {
+		const message = this.agent.context.history.at(-1);
+		const text = persistableUserMessageText(message);
+		if (text === void 0 || !shouldOffloadUserMessage(text.length)) return 0;
+		const messageHash = userMessageOffloadHash(message, text);
+		if (this.replacements.has(messageHash) || this.agent.homedir === void 0) return 0;
+		const outputPath = await saveUserMessage(this.agent.homedir, text);
+		if (outputPath === void 0) return 0;
+		const replacementText = renderPersistedUserMessage(text, outputPath);
+		const content = [{
+			type: "text",
+			text: replacementText
+		}, ...message.content.filter((part) => part.type !== "text")];
+		this.apply({
+			messageHash,
+			content,
+			outputPath
+		});
+		this.agent.telemetry.track("user_message_offloaded", {
+			chars_before: text.length,
+			chars_after: replacementText.length,
+			chars_saved: text.length - replacementText.length,
+			media_part_count: content.length - 1
+		});
+		return 1;
+	}
+	apply(replacement) {
+		this.replacements.set(replacement.messageHash, replacement);
+		this.agent.records.logRecord({
+			type: "user_message_offload.apply",
+			replacement
+		});
+	}
+	compact(messages) {
+		if (this.replacements.size === 0) return messages;
+		return messages.map((message) => {
+			const text = persistableUserMessageText(message);
+			if (text === void 0) return message;
+			const replacement = this.replacements.get(userMessageOffloadHash(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 = persistableUserMessageText(message);
+			return text === void 0 ? void 0 : userMessageOffloadHash(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;
@@ -260540,6 +260694,7 @@ var init_turn = __esmMin((() => {
 	init_canonical_args();
 	init_tool_dedup();
 	init_tool_result_budget();
+	init_user_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;
@@ -261174,6 +261329,7 @@ var init_turn = __esmMin((() => {
 							beforeStep: async ({ signal: stepSignal, stepNumber }) => {
 								await this.agent.records.flush();
 								this.agent.microCompaction.detect();
+								await this.agent.userMessageOffload.detect();
 								await this.agent.injection.inject();
 								stepSignal.throwIfAborted();
 								deduper.beginStep();
@@ -263982,6 +264138,7 @@ var init_agent = __esmMin((() => {
 			this.fullCompaction = new FullCompaction(this, options.compactionStrategy);
 			this.microCompaction = new MicroCompaction(this, options.microCompaction);
 			this.toolResultBatchOffload = new ToolResultBatchOffload(this);
+			this.userMessageOffload = new UserMessageOffload(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.99",
+  "version": "9.1.101",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {