blun-king-cli 9.1.415 → 9.1.417

package/LIESMICH.txt

@@ -59,6 +59,22 @@ konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
 FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
 `turn.agent_busy`-Fehler.
 
+Ab BLUN King 9.1.416 bleiben alle Ergebnisse des jüngsten Werkzeugaufrufs bis
+zur nächsten Assistentenantwort vollständig im Modellkontext. Das gilt auch für
+große parallele Read-, Grep- und Bash-Aufrufe sowie für nachträglich
+eingespielte Telegram- oder Steuerungsnachrichten. Offloader, historische
+Bereinigung und Mikrokompaktierung verwenden dafür dieselbe semantische Grenze.
+Erst nach der nachweislichen Auswertung darf ein Ergebnis archiviert oder
+gekürzt werden.
+
+Ab BLUN King 9.1.417 schneiden automatische Telegram-Rückfallantworten Texte
+nicht mehr bei 4.096 Zeichen ab. Längere Antworten werden in
+aufeinanderfolgenden Nachrichten vollständig zugestellt; dabei bleiben jedes
+Zeichen und jedes Unicode-Surrogatpaar erhalten. Im Ausgangsprotokoll stehen
+sämtliche zurückgegebenen Nachrichten-IDs zusammen mit dem vollständigen Text.
+Schlägt ein Teil fehl, endet die Zustellung an dieser Stelle, statt die Antwort
+fälschlich als vollständig zu melden.
+
 Zuverlässiger King-Start
 -----------------------
 Bei einer ausdrücklich als wiederholbar gekennzeichneten Serverüberlastung

package/README.md

@@ -73,6 +73,23 @@ 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.
+
+Ab BLUN King 9.1.416 bleiben alle Ergebnisse des jüngsten Werkzeugaufrufs bis
+zur nächsten Assistentenantwort vollständig im Modellkontext. Das gilt auch für
+große parallele Read-, Grep- und Bash-Aufrufe sowie für nachträglich
+eingespielte Telegram- oder Steuerungsnachrichten. Offloader, historische
+Bereinigung und Mikrokompaktierung verwenden dafür dieselbe semantische Grenze.
+Erst nach der nachweislichen Auswertung darf ein Ergebnis archiviert oder
+gekürzt werden.
+
+Ab BLUN King 9.1.417 schneiden automatische Telegram-Rückfallantworten Texte
+nicht mehr bei 4.096 Zeichen ab. Längere Antworten werden in
+aufeinanderfolgenden Nachrichten vollständig zugestellt; dabei bleiben jedes
+Zeichen und jedes Unicode-Surrogatpaar erhalten. Im Ausgangsprotokoll stehen
+sämtliche zurückgegebenen Nachrichten-IDs zusammen mit dem vollständigen Text.
+Schlägt ein Teil fehl, endet die Zustellung an dieser Stelle, statt die Antwort
+fälschlich als vollständig zu melden.
+
 `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.

package/bin/telegram-text-chunk-policy.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const TELEGRAM_TEXT_LIMIT = 4096;
+
+function preferredCut(text, start, hardEnd) {
+  const minimum = start + Math.floor((hardEnd - start) / 2);
+  const boundaries = [
+    ['\n\n', 2],
+    ['\n', 1],
+    [' ', 1],
+  ];
+  for (const [boundary, width] of boundaries) {
+    const index = text.lastIndexOf(boundary, hardEnd - 1);
+    if (index >= minimum) return index + width;
+  }
+  return hardEnd;
+}
+
+function preserveSurrogatePair(text, start, end) {
+  if (end <= start || end >= text.length) return end;
+  const before = text.charCodeAt(end - 1);
+  const after = text.charCodeAt(end);
+  const splitsPair = before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
+  return splitsPair && end - 1 > start ? end - 1 : end;
+}
+
+function splitTelegramText(value, limit = TELEGRAM_TEXT_LIMIT) {
+  const text = typeof value === 'string' ? value : String(value ?? '');
+  if (text.length === 0) return [];
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new TypeError('Telegram text chunk limit must be a positive safe integer');
+  }
+
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const hardEnd = Math.min(text.length, start + limit);
+    let end = hardEnd < text.length ? preferredCut(text, start, hardEnd) : hardEnd;
+    end = preserveSurrogatePair(text, start, end);
+    if (end <= start) end = hardEnd;
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+
+async function sendTelegramTextChunks(value, sendChunk, limit = TELEGRAM_TEXT_LIMIT) {
+  if (typeof sendChunk !== 'function') {
+    throw new TypeError('Telegram chunk sender must be a function');
+  }
+  const chunks = splitTelegramText(value, limit);
+  const results = [];
+  for (let index = 0; index < chunks.length; index += 1) {
+    results.push(await sendChunk(chunks[index], index, chunks.length));
+  }
+  return { chunks, results };
+}
+
+module.exports = {
+  TELEGRAM_TEXT_LIMIT,
+  sendTelegramTextChunks,
+  splitTelegramText,
+};

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

@@ -43,6 +43,32 @@ function isPersistedToolResultReference(content) {
   });
 }
 
+function freshToolResultIds(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return new Set();
+
+  let assistantIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role !== 'assistant') continue;
+    assistantIndex = index;
+    break;
+  }
+  if (assistantIndex < 0 || !Array.isArray(messages[assistantIndex].toolCalls)) return new Set();
+
+  const requestedIds = new Set(messages[assistantIndex].toolCalls
+    .map((call) => call?.id ?? call?.toolCallId)
+    .filter((id) => typeof id === 'string' && id.length > 0));
+  if (requestedIds.size === 0) return new Set();
+
+  const resultIds = new Set();
+  for (let index = assistantIndex + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.role === 'tool' && requestedIds.has(message.toolCallId)) {
+      resultIds.add(message.toolCallId);
+    }
+  }
+  return resultIds;
+}
+
 function compactPersistedToolResultReference(content) {
   if (!isPersistedToolResultReference(content)) return content;
 
@@ -84,11 +110,13 @@ function compactHistoricalSuccessfulToolResults(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
 
   const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
+  const freshIds = freshToolResultIds(messages);
   let changed = false;
   const projected = messages.map((message, index) => {
     if (
       index >= recentStart
       || message?.role !== 'tool'
+      || freshIds.has(message.toolCallId)
       || message.isError === true
       || !Array.isArray(message.content)
       || isPersistedToolResultReference(message.content)
@@ -268,6 +296,7 @@ module.exports = {
   compactPersistedToolResultReference,
   createToolResultPreview,
   dedupeRepeatedSuccessfulToolResults,
+  freshToolResultIds,
   isPersistedToolResultReference,
   selectHistoricalToolResultOffloads,
   selectToolResultBatchOffloads,

package/blun.mjs

@@ -75994,10 +75994,10 @@ var init_full = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/micro.ts
-var selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, projectHistoricalUnaddressedTelegramMessages, dedupeRepeatedUserMessages, projectRepeatedAssistantResponses, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, projectLoopEventForRecord, projectUsageModelForRecord, projectUsageForRecord, resolveCompletedStepUuid, resolveStepEventUuid, restoreUsageFromRecord, restoreUsageModelFromRecord, DEFAULT_CONFIG, MicroCompaction;
+var selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, freshToolResultIds, projectHistoricalUnaddressedTelegramMessages, dedupeRepeatedUserMessages, projectRepeatedAssistantResponses, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, projectLoopEventForRecord, projectUsageModelForRecord, projectUsageForRecord, resolveCompletedStepUuid, resolveStepEventUuid, restoreUsageFromRecord, restoreUsageModelFromRecord, DEFAULT_CONFIG, MicroCompaction;
 var init_micro = __esmMin((() => {
 	({ selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS } = createRequire(import.meta.url)("./bin/micro-compaction-policy.cjs"));
-	({ isPersistedToolResultReference } = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs"));
+	({ isPersistedToolResultReference, freshToolResultIds } = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs"));
 	({ projectHistoricalUnaddressedTelegramMessages } = createRequire(import.meta.url)("./bin/telegram-context-projection-policy.cjs"));
 	({ dedupeRepeatedUserMessages } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ projectRepeatedAssistantResponses } = createRequire(import.meta.url)("./bin/repeated-assistant-response-policy.cjs"));
@@ -76093,11 +76093,12 @@ var init_micro = __esmMin((() => {
 			const config = this.config;
 			const historicalArgumentCutoff = Math.max(this.cutoff, messages.length - config.keepRecentMessages);
 			const completedToolCallIds = new Set(messages.filter((message) => message?.role === "tool" && message.toolCallId !== void 0).map((message) => message.toolCallId));
+			const protectedToolResultIds = freshToolResultIds(messages);
 			const serializedArgumentsMarker = JSON.stringify({ _blun_compacted: config.truncatedArgumentsMarker });
 			const result = [];
 			let i = 0;
 			for (const msg of messages) {
-				if (i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && !isPersistedToolResultReference(msg.content) && estimateTokensForContentParts(msg.content) >= config.minContentTokens) result.push({
+				if (i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && !protectedToolResultIds.has(msg.toolCallId) && !isPersistedToolResultReference(msg.content) && estimateTokensForContentParts(msg.content) >= config.minContentTokens) result.push({
 					...msg,
 					content: [{
 						type: "text",
@@ -76139,10 +76140,11 @@ var init_micro = __esmMin((() => {
 			let truncatedToolArgumentTokensBefore = 0;
 			let truncatedToolArgumentTokensAfter = 0;
 			const completedToolCallIds = new Set(messages.filter((message) => message?.role === "tool" && message.toolCallId !== void 0).map((message) => message.toolCallId));
+			const protectedToolResultIds = freshToolResultIds(messages);
 			const serializedArgumentsMarker = JSON.stringify({ _blun_compacted: this.config.truncatedArgumentsMarker });
 			for (let i = 0; i < messages.length && i < cutoff; i++) {
 				const message = messages[i];
-				if (message?.role === "tool" && message.toolCallId !== void 0 && !isPersistedToolResultReference(message.content)) {
+				if (message?.role === "tool" && message.toolCallId !== void 0 && !protectedToolResultIds.has(message.toolCallId) && !isPersistedToolResultReference(message.content)) {
 					const contentTokens = estimateTokensForContentParts(message.content);
 					if (contentTokens >= this.config.minContentTokens) {
 						markerTokenCount ??= estimateTokensForContentParts([{
@@ -260827,6 +260829,7 @@ var init_tool_result_budget = __esmMin((() => {
 	compactPersistedToolResultReference = toolResultOffloadPolicy.compactPersistedToolResultReference;
 	compactHistoricalSuccessfulToolResults = toolResultOffloadPolicy.compactHistoricalSuccessfulToolResults;
 	dedupeRepeatedSuccessfulToolResults = toolResultOffloadPolicy.dedupeRepeatedSuccessfulToolResults;
+	freshToolResultIds = toolResultOffloadPolicy.freshToolResultIds;
 	selectToolResultBatchOffloads = toolResultOffloadPolicy.selectToolResultBatchOffloads;
 	selectHistoricalToolResultOffloads = toolResultOffloadPolicy.selectHistoricalToolResultOffloads;
 }));
@@ -260840,13 +260843,7 @@ var ToolResultBatchOffload = class {
 	}
 	async detect() {
 		const history = this.agent.context.history;
-		const tail = [];
-		for (let index = history.length - 1; index >= 0; index -= 1) {
-			const message = history[index];
-			if (message?.role !== "tool") break;
-			tail.unshift(message);
-		}
-		const tailIds = new Set(tail.map((message) => message.toolCallId).filter((id) => id !== void 0));
+		const tailIds = freshToolResultIds(history);
 		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 = [{
@@ -514833,6 +514830,7 @@ var createMediaAutoRetrievalController, parseAcceptedMediaJob, validateCompleted
 ({ createMediaAutoRetrievalController, parseAcceptedMediaJob } = createRequire(import.meta.url)("./bin/media-auto-retrieval-policy.cjs"));
 ({ validateCompletedMedia } = createRequire(import.meta.url)("./bin/media-result-policy.cjs"));
 var { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = createRequire(import.meta.url)("./bin/telegram-private-conversation-policy.cjs");
+var { sendTelegramTextChunks } = createRequire(import.meta.url)("./bin/telegram-text-chunk-policy.cjs");
 const TELEGRAM_TEXT_LIMIT = 4096;
 const TELEGRAM_ATTACHMENT_LIMIT = 50 * 1024 * 1024;
 function mediaTelegramTarget(filePath) {
@@ -514973,25 +514971,29 @@ async function sendReplyFallback(chatId, text, contextOnly = false) {
 	}
 	const token = botToken();
 	if (token === void 0) return false;
-	const body = privateSafeText.length > TELEGRAM_TEXT_LIMIT ? `${privateSafeText.slice(0, TELEGRAM_TEXT_LIMIT - 1)}…` : privateSafeText;
+	const messageIds = [];
 	try {
-		const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				chat_id: chatId,
-				text: body
-			})
-		})).json();
-		if (payload.ok !== true) return false;
+		await sendTelegramTextChunks(privateSafeText, async (body) => {
+			const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					chat_id: chatId,
+					text: body
+				})
+			})).json();
+			if (payload.ok !== true) throw new Error("Telegram fallback chunk delivery failed");
+			if (payload.result?.message_id !== void 0) messageIds.push(payload.result.message_id);
+			return payload;
+		}, TELEGRAM_TEXT_LIMIT);
 		try {
 			appendFileSync(outboxPath(), `${JSON.stringify({
 				ts: (/* @__PURE__ */ new Date()).toISOString(),
 				direction: "out",
 				kind: "reply-fallback",
 				chat_id: String(chatId),
-				message_ids: payload.result?.message_id !== void 0 ? [payload.result.message_id] : [],
-				text: body
+				message_ids: messageIds,
+				text: privateSafeText
 			})}\n`);
 		} catch {}
 		return true;

package/package.json

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

package/telegram-plugin/bin/telegram-text-chunk-policy.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const TELEGRAM_TEXT_LIMIT = 4096;
+
+function preferredCut(text, start, hardEnd) {
+  const minimum = start + Math.floor((hardEnd - start) / 2);
+  const boundaries = [
+    ['\n\n', 2],
+    ['\n', 1],
+    [' ', 1],
+  ];
+  for (const [boundary, width] of boundaries) {
+    const index = text.lastIndexOf(boundary, hardEnd - 1);
+    if (index >= minimum) return index + width;
+  }
+  return hardEnd;
+}
+
+function preserveSurrogatePair(text, start, end) {
+  if (end <= start || end >= text.length) return end;
+  const before = text.charCodeAt(end - 1);
+  const after = text.charCodeAt(end);
+  const splitsPair = before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
+  return splitsPair && end - 1 > start ? end - 1 : end;
+}
+
+function splitTelegramText(value, limit = TELEGRAM_TEXT_LIMIT) {
+  const text = typeof value === 'string' ? value : String(value ?? '');
+  if (text.length === 0) return [];
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new TypeError('Telegram text chunk limit must be a positive safe integer');
+  }
+
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const hardEnd = Math.min(text.length, start + limit);
+    let end = hardEnd < text.length ? preferredCut(text, start, hardEnd) : hardEnd;
+    end = preserveSurrogatePair(text, start, end);
+    if (end <= start) end = hardEnd;
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+
+async function sendTelegramTextChunks(value, sendChunk, limit = TELEGRAM_TEXT_LIMIT) {
+  if (typeof sendChunk !== 'function') {
+    throw new TypeError('Telegram chunk sender must be a function');
+  }
+  const chunks = splitTelegramText(value, limit);
+  const results = [];
+  for (let index = 0; index < chunks.length; index += 1) {
+    results.push(await sendChunk(chunks[index], index, chunks.length));
+  }
+  return { chunks, results };
+}
+
+module.exports = {
+  TELEGRAM_TEXT_LIMIT,
+  sendTelegramTextChunks,
+  splitTelegramText,
+};

package/telegram-plugin/dist/bridge.mjs

@@ -10,10 +10,12 @@ import remoteStatusPolicy from "../../bin/telegram-remote-status-policy.cjs";
 import consoleStatusPolicy from "../../bin/telegram-console-status-policy.cjs";
 import telegramApprovalRelay from "../../bin/telegram-approval-relay.cjs";
 import privateConversationPolicy from "../bin/telegram-private-conversation-policy.cjs";
+import telegramTextChunkPolicy from "../bin/telegram-text-chunk-policy.cjs";
 const { buildTelegramRemoteStatus, resolveTelegramQueueSnapshot, resolveTelegramRemoteVersion } = remoteStatusPolicy;
 const { parseTelegramConsoleStatus } = consoleStatusPolicy;
 const { buildTelegramApprovalCard, isAuthorizedTelegramApprovalCallback, listPendingTelegramApprovals, markTelegramApprovalSent, parseTelegramApprovalCallback, resolveTelegramApprovalTarget, wasTelegramApprovalSent, writeTelegramApprovalResponse } = telegramApprovalRelay;
 const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
+const { sendTelegramTextChunks } = telegramTextChunkPolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -4223,25 +4225,29 @@ async function sendReplyFallback(chatId, rawText) {
 		return true;
 	}
 	const text = scrubSecrets(privateSafeText);
-	const body = text.length > TELEGRAM_TEXT_LIMIT ? `${text.slice(0, TELEGRAM_TEXT_LIMIT - 1)}…` : text;
+	const messageIds = [];
 	try {
-		const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				chat_id: chatId,
-				text: body
-			})
-		})).json();
-		if (payload.ok !== true) return false;
+		await sendTelegramTextChunks(text, async (body) => {
+			const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					chat_id: chatId,
+					text: body
+				})
+			})).json();
+			if (payload.ok !== true) throw new Error("Telegram fallback chunk delivery failed");
+			if (payload.result?.message_id !== void 0) messageIds.push(payload.result.message_id);
+			return payload;
+		}, TELEGRAM_TEXT_LIMIT);
 		try {
 			appendFileSync(outboxLog(), `${JSON.stringify({
 				ts: (/* @__PURE__ */ new Date()).toISOString(),
 				direction: "out",
 				kind: "reply-fallback",
 				chat_id: String(chatId),
-				message_ids: payload.result?.message_id !== void 0 ? [payload.result.message_id] : [],
-				text: body
+				message_ids: messageIds,
+				text
 			})}\n`);
 		} catch {}
 		return true;