blun-king-cli 9.1.416 → 9.1.418

package/LIESMICH.txt

@@ -67,6 +67,22 @@ 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.
+
+Ab BLUN King 9.1.418 übernimmt der Identitätsgraph die von Telegram bestätigte
+Unterscheidung zwischen Menschen und Bots. Bereits vorhandene
+Telegram-Kontakte, die mangels dieses Merkmals als Menschen angelegt wurden,
+werden bei der nächsten eindeutig als Bot bestätigten Nachricht einmalig als
+Agent korrigiert. Alle Rollen, Zuständigkeiten, Beziehungsnotizen und sonstigen
+Felder bleiben unverändert. Ein Agent wird niemals zu einer Person
+zurückgestuft; Namen oder Benutzernamen dienen nicht als Beweis.
+
 Zuverlässiger King-Start
 -----------------------
 Bei einer ausdrücklich als wiederholbar gekennzeichneten Serverüberlastung

package/README.md

@@ -82,6 +82,22 @@ 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.
+
+Ab BLUN King 9.1.418 übernimmt der Identitätsgraph die von Telegram bestätigte
+Unterscheidung zwischen Menschen und Bots. Bereits vorhandene
+Telegram-Kontakte, die mangels dieses Merkmals als Menschen angelegt wurden,
+werden bei der nächsten eindeutig als Bot bestätigten Nachricht einmalig als
+Agent korrigiert. Alle Rollen, Zuständigkeiten, Beziehungsnotizen und sonstigen
+Felder bleiben unverändert. Ein Agent wird niemals zu einer Person
+zurückgestuft; Namen oder Benutzernamen dienen nicht als Beweis.
+
 `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/identity-context-policy.cjs

@@ -93,6 +93,51 @@ function createJsonOnce(root, segments, value) {
   }
 }
 
+function updateJsonAtomically(root, segments, update) {
+  const target = path.resolve(root, ...segments);
+  if (!isInside(root, target)) return false;
+  let handle;
+  let temp = '';
+  try {
+    const stat = fs.lstatSync(target);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_FILE_BYTES) return false;
+    const original = fs.readFileSync(target, 'utf8');
+    const current = JSON.parse(original);
+    if (!current || typeof current !== 'object' || Array.isArray(current)) return false;
+    const next = update(current);
+    if (!next || typeof next !== 'object' || Array.isArray(next)) return false;
+    const serialized = `${JSON.stringify(next, null, 2)}\n`;
+    if (Buffer.byteLength(serialized, 'utf8') > MAX_FILE_BYTES) return false;
+
+    const parent = path.dirname(target);
+    const realParent = fs.realpathSync(parent);
+    if (!isInside(root, realParent)) return false;
+    temp = path.join(parent, `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
+    handle = fs.openSync(temp, 'wx', 0o600);
+    fs.writeFileSync(handle, serialized, 'utf8');
+    fs.fsyncSync(handle);
+    fs.closeSync(handle);
+    handle = undefined;
+
+    const currentStat = fs.lstatSync(target);
+    if (!currentStat.isFile() || currentStat.isSymbolicLink() || fs.readFileSync(target, 'utf8') !== original) return false;
+    fs.renameSync(temp, target);
+    temp = '';
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+    if (temp) {
+      try { fs.rmSync(temp, { force: true }); } catch {}
+    }
+  }
+}
+
+function isExplicitTelegramBot(meta) {
+  return meta?.is_bot === true || String(meta?.is_bot ?? '').toLowerCase() === 'true';
+}
+
 function cleanText(value, maxChars = 240) {
   if (typeof value !== 'string') return '';
   return value.replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim().slice(0, maxChars);
@@ -485,19 +530,31 @@ function recordChannelIdentity(envelope, env = process.env) {
   const firstSeenAt = trustedTimestamp(meta.ts);
   const receivedAt = trustedTimestamp(meta.received_at) || firstSeenAt;
   const created = [];
-  if (createJsonOnce(root, ['actors', `${actorId}.json`], {
+  const updated = [];
+  const actorSegments = ['actors', `${actorId}.json`];
+  const actorCreated = createJsonOnce(root, actorSegments, {
     version: 1,
     actor_id: actorId,
     provider: 'telegram',
     provider_subject_id: subjectId,
     display_name: displayName,
-    kind: meta.is_bot === true || String(meta.is_bot ?? '').toLowerCase() === 'true' ? 'agent' : 'person',
+    kind: isExplicitTelegramBot(meta) ? 'agent' : 'person',
     role: '',
     responsibilities: [],
     traits: [],
     aliases: [],
     ...(firstSeenAt ? { first_seen_at: firstSeenAt } : {}),
-  })) created.push('actor');
+  });
+  if (actorCreated) created.push('actor');
+  else if (isExplicitTelegramBot(meta) && updateJsonAtomically(root, actorSegments, (actor) => (
+    actor.version === 1
+      && actor.actor_id === actorId
+      && actor.provider === 'telegram'
+      && actor.provider_subject_id === subjectId
+      && actor.kind === 'person'
+      ? { ...actor, kind: 'agent' }
+      : undefined
+  ))) updated.push('actor_kind');
   if (createJsonOnce(root, ['agents', agentId, 'relationships', `${actorId}.json`], {
     version: 1,
     actor_id: actorId,
@@ -621,6 +678,7 @@ function recordChannelIdentity(envelope, env = process.env) {
     actor_id: actorId,
     ...(groupId ? { group_id: groupId } : {}),
     created,
+    updated,
     ...(learning ? { learning } : {}),
     ...(journal ? { journal } : {}),
     model_context: modelContext,

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

@@ -514830,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) {
@@ -514970,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.416",
+  "version": "9.1.418",
   "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;
@@ -4696,6 +4702,7 @@ async function handleInbound(event) {
 		...msgId !== void 0 ? { message_id: String(msgId) } : {},
 		addressed: String(addressed),
 		user: ctx.from?.username ?? String(ctx.from?.id),
+		is_bot: String(ctx.from?.is_bot === true),
 		user_id: String(ctx.from?.id),
 		ts: (/* @__PURE__ */ new Date((ctx.date ?? 0) * 1e3)).toISOString(),
 		...imagePath !== void 0 ? { image_path: imagePath } : {},