blun-king-cli 9.1.397 → 9.1.398

package/LIESMICH.txt

@@ -392,6 +392,20 @@ eingestuft ist. Fehlt dieser Beleg, bleibt das Ziel aktiv und King erhält eine
 konkrete Nachbesserung statt einer falschen Fertigmeldung. Ziele ohne ausdrücklich
 gesetzte Abschlussbedingung behalten ihr bisheriges Verhalten.
 
+Keine doppelte Telegram-Antwort ohne neue Nachricht
+---------------------------------------------------
+
+Ab BLUN King 9.1.398 prüft jeder Text-Ausgangspfad vor dem Senden die jüngste
+erfolgreiche Telegram-Antwort und den jüngsten Eingang desselben Chats. Solange
+danach keine neue Nutzernachricht eingetroffen ist, wird eine wortgleiche oder
+nahezu gleiche Wiederholung nicht erneut gesendet. Das gilt gleichermaßen für
+den Telegram-Werkzeugpfad und beide automatischen Rückfallpfade.
+
+Nach einer neuen Nutzernachricht ist dieselbe Antwort wieder zulässig. Andere
+Ergebnisse und Datei-Anhänge bleiben unverändert. Die Prüfung liest nur begrenzte
+Endbereiche der Ein- und Ausgangsprotokolle und fällt bei fehlendem Beleg offen
+zurück, damit Telegram nicht wegen einer beschädigten Protokollzeile blockiert.
+
 Angehängte Bilder werden weiterhin mit ReadMediaFile gelesen. Bild-, Video- und
 Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. GenerateVideo kann außerdem einen abgeschlossenen Bildauftrag

package/README.md

@@ -401,6 +401,19 @@ eingestuft ist. Fehlt dieser Beleg, bleibt das Ziel aktiv und King erhält eine
 konkrete Nachbesserung statt einer falschen Fertigmeldung. Ziele ohne ausdrücklich
 gesetzte Abschlussbedingung behalten ihr bisheriges Verhalten.
 
+## Keine doppelte Telegram-Antwort ohne neue Nachricht
+
+Ab BLUN King 9.1.398 prüft jeder Text-Ausgangspfad vor dem Senden die jüngste
+erfolgreiche Telegram-Antwort und den jüngsten Eingang desselben Chats. Solange
+danach keine neue Nutzernachricht eingetroffen ist, wird eine wortgleiche oder
+nahezu gleiche Wiederholung nicht erneut gesendet. Das gilt gleichermaßen für
+den Telegram-Werkzeugpfad und beide automatischen Rückfallpfade.
+
+Nach einer neuen Nutzernachricht ist dieselbe Antwort wieder zulässig. Andere
+Ergebnisse und Datei-Anhänge bleiben unverändert. Die Prüfung liest nur begrenzte
+Endbereiche der Ein- und Ausgangsprotokolle und fällt bei fehlendem Beleg offen
+zurück, damit Telegram nicht wegen einer beschädigten Protokollzeile blockiert.
+
 Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
 und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag

package/bin/telegram-private-conversation-policy.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { closeSync, openSync, readSync, statSync } = require('node:fs');
+
 const PRIVATE_CHAT_ID = /^[1-9]\d*$/u;
 const WORK_PERMISSION_QUESTION = /^(?:kann|darf|soll) ich\b.{0,100}\b(?:arbeit(?:en)?|weiterarbeiten|weitermachen|fortfahren|weiterbauen|umbau|bau)\b/u;
 const TRAILING_WORK_PERMISSION_QUESTION = /(?:^|\r?\n\s*\r?\n)(?:kann|darf|soll)\s+ich\b[^\r\n]{0,160}\b(?:arbeit(?:en)?|weiterarbeiten|weitermachen|fortfahren|weiterbauen|umbau|bau)\b[^\r\n]*$/iu;
@@ -10,6 +12,12 @@ const MEDIA_PROGRESS_MARKER = /\b(?:bildgenerierung|bildjob|generateimage|getmed
 const MEDIA_PENDING_STATE = /\b(?:auftrag wurde angenommen|job wurde angenommen|job angenommen|aufruf wurde abgesetzt|angestossen|angestoßen|processing|verarbeitung)\b/u;
 const MEDIA_NO_RESULT = /\b(?:kein neues bild|noch kein bild|kein bild liefern|nichts angekommen|nichts neues gelandet|nicht verfuegbar|nicht verfügbar|getmedia fehlt)\b/u;
 
+const DUPLICATE_LOG_TAIL_BYTES = 512 * 1024;
+const DUPLICATE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const NEAR_DUPLICATE_MIN_CHARS = 120;
+const NEAR_DUPLICATE_SIMILARITY = 0.88;
+const SUCCESSFUL_REPLY_KINDS = new Set(['reply', 'reply-fallback']);
+
 function normalize(text) {
   return String(text ?? '')
     .normalize('NFKC')
@@ -19,6 +27,133 @@ function normalize(text) {
     .trim();
 }
 
+function readJsonlTail(file, maxBytes = DUPLICATE_LOG_TAIL_BYTES) {
+  try {
+    const size = statSync(file).size;
+    if (size <= 0) return [];
+    const start = Math.max(0, size - maxBytes);
+    const length = size - start;
+    const buffer = Buffer.allocUnsafe(length);
+    const descriptor = openSync(file, 'r');
+    let bytesRead = 0;
+    try {
+      while (bytesRead < length) {
+        const count = readSync(descriptor, buffer, bytesRead, length - bytesRead, start + bytesRead);
+        if (count === 0) break;
+        bytesRead += count;
+      }
+    } finally {
+      closeSync(descriptor);
+    }
+    let raw = buffer.subarray(0, bytesRead).toString('utf8');
+    if (start > 0) {
+      const firstNewline = raw.indexOf('\n');
+      raw = firstNewline < 0 ? '' : raw.slice(firstNewline + 1);
+    }
+    return raw.split(/\r?\n/u).flatMap((line) => {
+      if (line.trim().length === 0) return [];
+      try {
+        const entry = JSON.parse(line);
+        return typeof entry === 'object' && entry !== null ? [entry] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+function normalizedTokens(text) {
+  return normalize(text).match(/[\p{L}\p{N}_]+/gu) ?? [];
+}
+
+function tokenBigrams(tokens) {
+  const bigrams = [];
+  for (let index = 0; index + 1 < tokens.length; index += 1) {
+    bigrams.push(`${tokens[index]}\u0000${tokens[index + 1]}`);
+  }
+  return bigrams;
+}
+
+function diceSimilarity(leftItems, rightItems) {
+  const left = new Set(leftItems);
+  const right = new Set(rightItems);
+  if (left.size === 0 || right.size === 0) return 0;
+  let intersection = 0;
+  for (const item of left) {
+    if (right.has(item)) intersection += 1;
+  }
+  return (2 * intersection) / (left.size + right.size);
+}
+
+function outboundReplySimilarity(left, right) {
+  const leftNormalized = normalize(left);
+  const rightNormalized = normalize(right);
+  if (leftNormalized.length === 0 || rightNormalized.length === 0) return 0;
+  if (leftNormalized === rightNormalized) return 1;
+  if (leftNormalized.length < NEAR_DUPLICATE_MIN_CHARS || rightNormalized.length < NEAR_DUPLICATE_MIN_CHARS) return 0;
+  const leftTokens = normalizedTokens(leftNormalized);
+  const rightTokens = normalizedTokens(rightNormalized);
+  if (leftTokens.length < 12 || rightTokens.length < 12) return 0;
+  const tokenScore = diceSimilarity(leftTokens, rightTokens);
+  const bigramScore = diceSimilarity(tokenBigrams(leftTokens), tokenBigrams(rightTokens));
+  return (tokenScore + bigramScore) / 2;
+}
+
+function entryTime(entry) {
+  const raw = entry?.ts ?? entry?.meta?.timestamp;
+  const value = Date.parse(String(raw ?? ''));
+  return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
+
+function entryChatId(entry) {
+  return String(entry?.chat_id ?? entry?.meta?.chat_id ?? '');
+}
+
+function findDuplicateReplyWithoutNewInbound({
+  chatId,
+  inboundFile,
+  now = Date.now(),
+  outboxFile,
+  text,
+}) {
+  const wantedChat = String(chatId ?? '').trim();
+  const candidate = String(text ?? '').trim();
+  if (wantedChat.length === 0 || candidate.length === 0) return null;
+
+  const outbound = readJsonlTail(outboxFile).filter((entry) => (
+    SUCCESSFUL_REPLY_KINDS.has(entry.kind)
+    && entryChatId(entry) === wantedChat
+    && typeof entry.text === 'string'
+  ));
+  if (outbound.length === 0) return null;
+  const latestOutboundAt = Math.max(...outbound.map(entryTime));
+  if (!Number.isFinite(latestOutboundAt)) return null;
+
+  const inboundTimes = readJsonlTail(inboundFile)
+    .filter((entry) => entryChatId(entry) === wantedChat)
+    .map(entryTime)
+    .filter(Number.isFinite);
+  if (inboundTimes.length === 0) return null;
+  if (Math.max(...inboundTimes) > latestOutboundAt) return null;
+
+  const cutoff = Number(now) - DUPLICATE_MAX_AGE_MS;
+  for (let index = outbound.length - 1; index >= 0; index -= 1) {
+    const previous = outbound[index];
+    const previousAt = entryTime(previous);
+    if (previousAt < cutoff || previousAt > Number(now)) continue;
+    const similarity = outboundReplySimilarity(previous.text, candidate);
+    if (similarity < NEAR_DUPLICATE_SIMILARITY) continue;
+    return {
+      kind: previous.kind,
+      similarity,
+      ts: previous.ts,
+    };
+  }
+  return null;
+}
+
 function sanitizePrivateConversationReply(chatId, text) {
   const value = String(text ?? '');
   if (!PRIVATE_CHAT_ID.test(String(chatId ?? '').trim())) return value;
@@ -38,6 +173,12 @@ function isPrivateInternalStatusReply(chatId, text) {
 }
 
 module.exports = {
+  DUPLICATE_LOG_TAIL_BYTES,
+  DUPLICATE_MAX_AGE_MS,
+  NEAR_DUPLICATE_MIN_CHARS,
+  NEAR_DUPLICATE_SIMILARITY,
+  findDuplicateReplyWithoutNewInbound,
   isPrivateInternalStatusReply,
+  outboundReplySimilarity,
   sanitizePrivateConversationReply,
 };

package/blun.mjs

@@ -514729,7 +514729,7 @@ var retryTelegramMediaDelivery, retryableTelegramMediaFailure;
 var createMediaAutoRetrievalController, parseAcceptedMediaJob, validateCompletedMedia;
 ({ createMediaAutoRetrievalController, parseAcceptedMediaJob } = createRequire(import.meta.url)("./bin/media-auto-retrieval-policy.cjs"));
 ({ validateCompletedMedia } = createRequire(import.meta.url)("./bin/media-result-policy.cjs"));
-var { isPrivateInternalStatusReply, sanitizePrivateConversationReply } = createRequire(import.meta.url)("./bin/telegram-private-conversation-policy.cjs");
+var { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = createRequire(import.meta.url)("./bin/telegram-private-conversation-policy.cjs");
 const TELEGRAM_TEXT_LIMIT = 4096;
 const TELEGRAM_ATTACHMENT_LIMIT = 50 * 1024 * 1024;
 function mediaTelegramTarget(filePath) {
@@ -514838,6 +514838,23 @@ async function sendReplyFallback(chatId, text, contextOnly = false) {
 		} catch {}
 		return true;
 	}
+	if (findDuplicateReplyWithoutNewInbound({
+		chatId,
+		inboundFile: join$4(channelDir(), "inbox.jsonl"),
+		outboxFile: outboxPath(),
+		text
+	}) !== null) {
+		try {
+			appendFileSync(outboxPath(), `${JSON.stringify({
+				ts: (/* @__PURE__ */ new Date()).toISOString(),
+				direction: "out",
+				kind: "reply-fallback-suppressed-duplicate-without-new-inbound",
+				chat_id: String(chatId),
+				text
+			})}\n`);
+		} catch {}
+		return true;
+	}
 	const privateSafeText = sanitizePrivateConversationReply(chatId, text);
 	if (isGroupChat(chatId) && isGroupSuppressed(text, contextOnly)) {
 		try {

package/package.json

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

package/telegram-plugin/bin/telegram-private-conversation-policy.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { closeSync, openSync, readSync, statSync } = require('node:fs');
+
 const PRIVATE_CHAT_ID = /^[1-9]\d*$/u;
 const WORK_PERMISSION_QUESTION = /^(?:kann|darf|soll) ich\b.{0,100}\b(?:arbeit(?:en)?|weiterarbeiten|weitermachen|fortfahren|weiterbauen|umbau|bau)\b/u;
 const TRAILING_WORK_PERMISSION_QUESTION = /(?:^|\r?\n\s*\r?\n)(?:kann|darf|soll)\s+ich\b[^\r\n]{0,160}\b(?:arbeit(?:en)?|weiterarbeiten|weitermachen|fortfahren|weiterbauen|umbau|bau)\b[^\r\n]*$/iu;
@@ -10,6 +12,12 @@ const MEDIA_PROGRESS_MARKER = /\b(?:bildgenerierung|bildjob|generateimage|getmed
 const MEDIA_PENDING_STATE = /\b(?:auftrag wurde angenommen|job wurde angenommen|job angenommen|aufruf wurde abgesetzt|angestossen|angestoßen|processing|verarbeitung)\b/u;
 const MEDIA_NO_RESULT = /\b(?:kein neues bild|noch kein bild|kein bild liefern|nichts angekommen|nichts neues gelandet|nicht verfuegbar|nicht verfügbar|getmedia fehlt)\b/u;
 
+const DUPLICATE_LOG_TAIL_BYTES = 512 * 1024;
+const DUPLICATE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const NEAR_DUPLICATE_MIN_CHARS = 120;
+const NEAR_DUPLICATE_SIMILARITY = 0.88;
+const SUCCESSFUL_REPLY_KINDS = new Set(['reply', 'reply-fallback']);
+
 function normalize(text) {
   return String(text ?? '')
     .normalize('NFKC')
@@ -19,6 +27,133 @@ function normalize(text) {
     .trim();
 }
 
+function readJsonlTail(file, maxBytes = DUPLICATE_LOG_TAIL_BYTES) {
+  try {
+    const size = statSync(file).size;
+    if (size <= 0) return [];
+    const start = Math.max(0, size - maxBytes);
+    const length = size - start;
+    const buffer = Buffer.allocUnsafe(length);
+    const descriptor = openSync(file, 'r');
+    let bytesRead = 0;
+    try {
+      while (bytesRead < length) {
+        const count = readSync(descriptor, buffer, bytesRead, length - bytesRead, start + bytesRead);
+        if (count === 0) break;
+        bytesRead += count;
+      }
+    } finally {
+      closeSync(descriptor);
+    }
+    let raw = buffer.subarray(0, bytesRead).toString('utf8');
+    if (start > 0) {
+      const firstNewline = raw.indexOf('\n');
+      raw = firstNewline < 0 ? '' : raw.slice(firstNewline + 1);
+    }
+    return raw.split(/\r?\n/u).flatMap((line) => {
+      if (line.trim().length === 0) return [];
+      try {
+        const entry = JSON.parse(line);
+        return typeof entry === 'object' && entry !== null ? [entry] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+function normalizedTokens(text) {
+  return normalize(text).match(/[\p{L}\p{N}_]+/gu) ?? [];
+}
+
+function tokenBigrams(tokens) {
+  const bigrams = [];
+  for (let index = 0; index + 1 < tokens.length; index += 1) {
+    bigrams.push(`${tokens[index]}\u0000${tokens[index + 1]}`);
+  }
+  return bigrams;
+}
+
+function diceSimilarity(leftItems, rightItems) {
+  const left = new Set(leftItems);
+  const right = new Set(rightItems);
+  if (left.size === 0 || right.size === 0) return 0;
+  let intersection = 0;
+  for (const item of left) {
+    if (right.has(item)) intersection += 1;
+  }
+  return (2 * intersection) / (left.size + right.size);
+}
+
+function outboundReplySimilarity(left, right) {
+  const leftNormalized = normalize(left);
+  const rightNormalized = normalize(right);
+  if (leftNormalized.length === 0 || rightNormalized.length === 0) return 0;
+  if (leftNormalized === rightNormalized) return 1;
+  if (leftNormalized.length < NEAR_DUPLICATE_MIN_CHARS || rightNormalized.length < NEAR_DUPLICATE_MIN_CHARS) return 0;
+  const leftTokens = normalizedTokens(leftNormalized);
+  const rightTokens = normalizedTokens(rightNormalized);
+  if (leftTokens.length < 12 || rightTokens.length < 12) return 0;
+  const tokenScore = diceSimilarity(leftTokens, rightTokens);
+  const bigramScore = diceSimilarity(tokenBigrams(leftTokens), tokenBigrams(rightTokens));
+  return (tokenScore + bigramScore) / 2;
+}
+
+function entryTime(entry) {
+  const raw = entry?.ts ?? entry?.meta?.timestamp;
+  const value = Date.parse(String(raw ?? ''));
+  return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
+
+function entryChatId(entry) {
+  return String(entry?.chat_id ?? entry?.meta?.chat_id ?? '');
+}
+
+function findDuplicateReplyWithoutNewInbound({
+  chatId,
+  inboundFile,
+  now = Date.now(),
+  outboxFile,
+  text,
+}) {
+  const wantedChat = String(chatId ?? '').trim();
+  const candidate = String(text ?? '').trim();
+  if (wantedChat.length === 0 || candidate.length === 0) return null;
+
+  const outbound = readJsonlTail(outboxFile).filter((entry) => (
+    SUCCESSFUL_REPLY_KINDS.has(entry.kind)
+    && entryChatId(entry) === wantedChat
+    && typeof entry.text === 'string'
+  ));
+  if (outbound.length === 0) return null;
+  const latestOutboundAt = Math.max(...outbound.map(entryTime));
+  if (!Number.isFinite(latestOutboundAt)) return null;
+
+  const inboundTimes = readJsonlTail(inboundFile)
+    .filter((entry) => entryChatId(entry) === wantedChat)
+    .map(entryTime)
+    .filter(Number.isFinite);
+  if (inboundTimes.length === 0) return null;
+  if (Math.max(...inboundTimes) > latestOutboundAt) return null;
+
+  const cutoff = Number(now) - DUPLICATE_MAX_AGE_MS;
+  for (let index = outbound.length - 1; index >= 0; index -= 1) {
+    const previous = outbound[index];
+    const previousAt = entryTime(previous);
+    if (previousAt < cutoff || previousAt > Number(now)) continue;
+    const similarity = outboundReplySimilarity(previous.text, candidate);
+    if (similarity < NEAR_DUPLICATE_SIMILARITY) continue;
+    return {
+      kind: previous.kind,
+      similarity,
+      ts: previous.ts,
+    };
+  }
+  return null;
+}
+
 function sanitizePrivateConversationReply(chatId, text) {
   const value = String(text ?? '');
   if (!PRIVATE_CHAT_ID.test(String(chatId ?? '').trim())) return value;
@@ -38,6 +173,12 @@ function isPrivateInternalStatusReply(chatId, text) {
 }
 
 module.exports = {
+  DUPLICATE_LOG_TAIL_BYTES,
+  DUPLICATE_MAX_AGE_MS,
+  NEAR_DUPLICATE_MIN_CHARS,
+  NEAR_DUPLICATE_SIMILARITY,
+  findDuplicateReplyWithoutNewInbound,
   isPrivateInternalStatusReply,
+  outboundReplySimilarity,
   sanitizePrivateConversationReply,
 };

package/telegram-plugin/dist/bridge.mjs

@@ -11,7 +11,7 @@ import telegramApprovalRelay from "../../bin/telegram-approval-relay.cjs";
 import privateConversationPolicy from "../bin/telegram-private-conversation-policy.cjs";
 const { buildTelegramRemoteStatus, resolveTelegramRemoteVersion } = remoteStatusPolicy;
 const { buildTelegramApprovalCard, isAuthorizedTelegramApprovalCallback, listPendingTelegramApprovals, markTelegramApprovalSent, parseTelegramApprovalCallback, resolveTelegramApprovalTarget, wasTelegramApprovalSent, writeTelegramApprovalResponse } = telegramApprovalRelay;
-const { isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
+const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -4199,6 +4199,22 @@ async function sendReplyFallback(chatId, rawText) {
 		logLine(`reply-fallback suppressed (private internal): ${rawText.slice(0, 60)}`);
 		return true;
 	}
+	if (findDuplicateReplyWithoutNewInbound({
+		chatId,
+		inboundFile: inboxLog(),
+		outboxFile: outboxLog(),
+		text: rawText
+	}) !== null) {
+		appendFileSync(outboxLog(), `${JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			direction: "out",
+			kind: "reply-fallback-suppressed-duplicate-without-new-inbound",
+			chat_id: String(chatId),
+			text: rawText
+		})}\n`);
+		logLine(`reply-fallback suppressed (duplicate without new inbound): ${rawText.slice(0, 60)}`);
+		return true;
+	}
 	const privateSafeText = sanitizePrivateConversationReply(chatId, rawText);
 	if (isGroupChat(chatId) && isGroupNoiseReply(rawText)) {
 		logLine(`reply-fallback suppressed (group meta-noise): ${rawText.slice(0, 60)}`);

package/telegram-plugin/dist/mcp-server.mjs

@@ -9667,7 +9667,7 @@ var StdioServerTransport = class {
 * chats the inbound gate would deliver from.
 */
 var import_out = require_out();
-const { isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
+const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
 const TOOL_DEFINITIONS = [
 	{
 		name: "reply",
@@ -9787,34 +9787,17 @@ async function runTool(api, token, name, args) {
 	}
 }
 /**
-* Idempotency guard: models occasionally call reply multiple times with the
-* same text. A message that
-* innerhalb des Fensters bereits wortgleich an denselben Chat ging, wird nicht
-* erneut gesendet — das Tool meldet dem Modell "bereits zugestellt", damit es
-* nicht weiter retryt. Datei-Anhänge sind nie betroffen.
+* Idempotency guard for text-only replies. If no newer inbound message exists,
+* an exact or near-identical successful reply is not sent again. Attachments
+* are never affected.
 */
-const DUPLICATE_WINDOW_MS = 3e5;
-const OUTBOX_TAIL_BYTES = 32768;
 function isRecentDuplicate(chatId, text) {
-	try {
-		const file = outboxLog();
-		const size = statSync(file).size;
-		const raw = readFileSync(file, "utf8");
-		const tail = size > OUTBOX_TAIL_BYTES ? raw.slice(raw.length - OUTBOX_TAIL_BYTES) : raw;
-		const wanted = text.trim();
-		const cutoff = Date.now() - DUPLICATE_WINDOW_MS;
-		for (const line of tail.split("\n")) {
-			if (line.trim().length === 0) continue;
-			try {
-				const entry = JSON.parse(line);
-				if (entry.kind !== "reply" && entry.kind !== "reply-fallback") continue;
-				if (String(entry.chat_id) !== String(chatId)) continue;
-				if (entry.ts === void 0 || Date.parse(entry.ts) < cutoff) continue;
-				if ((entry.text ?? "").trim() === wanted) return true;
-			} catch {}
-		}
-	} catch {}
-	return false;
+	return findDuplicateReplyWithoutNewInbound({
+		chatId,
+		inboundFile: inboxLog(),
+		outboxFile: outboxLog(),
+		text
+	}) !== null;
 }
 function telegramErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);