blun-king-cli 9.1.397 → 9.1.399

package/LIESMICH.txt

@@ -392,6 +392,35 @@ 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.
 
+Projektbezogenes Lernen ohne Übersprechen
+------------------------------------------
+
+Ab BLUN King 9.1.399 bleiben bestätigte Rot-zu-Grün-Lernkandidaten innerhalb
+des Git-Projekts, in dem sie entstanden sind. Zwei Arbeitskopien desselben
+Remote-Repositories teilen denselben anonymisierten Projekt-Schlüssel; andere
+Repositories erhalten getrennte Lernspeicher. Lokale Git-Projekte ohne Remote
+werden anhand ihres Repository-Wurzelpfads getrennt.
+
+Weder Remote-Adresse noch lokaler Projektpfad werden im Lernkandidaten
+gespeichert. Außerhalb eines Git-Projekts bleibt der bisherige globale
+Profilspeicher erhalten. Damit kann eine gemessene Projektregel später wieder
+aufgerufen werden, ohne als vermeintlich allgemeine Regel in fachfremde Projekte
+zu gelangen.
+
+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,33 @@ 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.
 
+## Projektbezogenes Lernen ohne Übersprechen
+
+Ab BLUN King 9.1.399 bleiben bestätigte Rot-zu-Grün-Lernkandidaten innerhalb
+des Git-Projekts, in dem sie entstanden sind. Zwei Arbeitskopien desselben
+Remote-Repositories teilen denselben anonymisierten Projekt-Schlüssel; andere
+Repositories erhalten getrennte Lernspeicher. Lokale Git-Projekte ohne Remote
+werden anhand ihres Repository-Wurzelpfads getrennt.
+
+Weder Remote-Adresse noch lokaler Projektpfad werden im Lernkandidaten
+gespeichert. Außerhalb eines Git-Projekts bleibt der bisherige globale
+Profilspeicher erhalten. Damit kann eine gemessene Projektregel später wieder
+aufgerufen werden, ohne als vermeintlich allgemeine Regel in fachfremde Projekte
+zu gelangen.
+
+## 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/bin/validated-learning-signal.cjs

@@ -115,13 +115,96 @@ function profileKey(value) {
   return (normalized || 'default').replace(/[^a-z0-9._-]/giu, '_').slice(0, 64);
 }
 
-function candidateDirectory(homeDir, profile) {
-  return path.join(
+function normalizedRemote(value) {
+  let remote = typeof value === 'string' ? value.trim() : '';
+  if (!remote) return '';
+  remote = remote.replace(/^git@([^:]+):/iu, 'ssh://git@$1/');
+  try {
+    const parsed = new URL(remote);
+    const host = parsed.hostname.toLowerCase();
+    const pathname = parsed.pathname.replace(/^\/+|\/+$/gu, '').replace(/\.git$/iu, '').toLowerCase();
+    return host && pathname ? `${host}/${pathname}` : '';
+  } catch {
+    return remote.replace(/\\/gu, '/').replace(/\.git$/iu, '').toLowerCase();
+  }
+}
+
+function gitConfigPath(dotGitPath) {
+  try {
+    const stat = fs.lstatSync(dotGitPath);
+    if (stat.isDirectory()) return path.join(dotGitPath, 'config');
+    if (!stat.isFile()) return '';
+    const pointer = fs.readFileSync(dotGitPath, 'utf8').match(/^gitdir:\s*(.+)$/imu)?.[1]?.trim();
+    if (!pointer) return '';
+    const gitDir = path.resolve(path.dirname(dotGitPath), pointer);
+    const commonPointerPath = path.join(gitDir, 'commondir');
+    if (fs.existsSync(commonPointerPath)) {
+      const commonPointer = fs.readFileSync(commonPointerPath, 'utf8').trim();
+      if (commonPointer) return path.join(path.resolve(gitDir, commonPointer), 'config');
+    }
+    return path.join(gitDir, 'config');
+  } catch {
+    return '';
+  }
+}
+
+function originRemote(configPath) {
+  if (!configPath) return '';
+  try {
+    const stat = fs.statSync(configPath);
+    if (!stat.isFile() || stat.size > 1024 * 1024) return '';
+    const lines = fs.readFileSync(configPath, 'utf8').split(/\r?\n/gu);
+    let inOrigin = false;
+    for (const line of lines) {
+      const section = line.match(/^\s*\[([^\]]+)\]\s*$/u)?.[1]?.trim();
+      if (section !== undefined) {
+        inOrigin = /^remote\s+"origin"$/iu.test(section);
+        continue;
+      }
+      if (!inOrigin) continue;
+      const url = line.match(/^\s*url\s*=\s*(.+?)\s*$/iu)?.[1];
+      if (url) return normalizedRemote(url);
+    }
+  } catch {
+    return '';
+  }
+  return '';
+}
+
+function resolveValidatedLearningProject(projectDir) {
+  const requested = typeof projectDir === 'string' ? projectDir.trim() : '';
+  if (!requested) return { scope: 'global', projectId: '' };
+  let current;
+  try {
+    current = fs.realpathSync(path.resolve(requested));
+  } catch {
+    return { scope: 'global', projectId: '' };
+  }
+  for (let depth = 0; depth < 64; depth += 1) {
+    const dotGitPath = path.join(current, '.git');
+    if (fs.existsSync(dotGitPath)) {
+      const remote = originRemote(gitConfigPath(dotGitPath));
+      const identity = remote ? `remote:${remote}` : `path:${current.toLowerCase()}`;
+      return {
+        scope: 'project',
+        projectId: crypto.createHash('sha256').update(identity).digest('hex').slice(0, 16),
+      };
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return { scope: 'global', projectId: '' };
+}
+
+function candidateDirectory(homeDir, profile, projectId = '') {
+  const base = path.join(
     path.resolve(homeDir),
     'self-improvement',
     'validated-learning',
     profileKey(profile),
   );
+  return projectId ? path.join(base, 'projects', projectId) : base;
 }
 
 function atomicCreate(filePath, value) {
@@ -161,7 +244,8 @@ function readCandidate(filePath) {
 function readValidatedLearningCandidates(options = {}) {
   const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
   if (!homeDir) return [];
-  const directory = candidateDirectory(homeDir, options.profile);
+  const project = resolveValidatedLearningProject(options.projectDir);
+  const directory = candidateDirectory(homeDir, options.profile, project.projectId);
   try {
     return fs.readdirSync(directory, { withFileTypes: true })
       .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
@@ -255,21 +339,25 @@ function pendingCandidateForSignal(candidates, signal) {
 
 function createCandidate(signal, options, nowIso) {
   const profile = profileKey(options.profile);
+  const projectId = typeof options.projectId === 'string' ? options.projectId : '';
   const commandHash = verificationCommandHash(signal);
   const digest = crypto.createHash('sha256').update([
     profile,
+    projectId,
     commandHash,
     signal.failedToolCallId,
     signal.successfulToolCallId,
   ].join('\0')).digest('hex').slice(0, 32);
   const id = `vl-${digest}`;
-  const filePath = path.join(candidateDirectory(options.homeDir, profile), `${id}.json`);
+  const filePath = path.join(candidateDirectory(options.homeDir, profile, projectId), `${id}.json`);
   atomicCreate(filePath, {
     schemaVersion: SCHEMA_VERSION,
     id,
     type: 'validated_red_green',
     status: 'pending',
     profile,
+    scope: projectId ? 'project' : 'global',
+    ...(projectId ? { projectId } : {}),
     verification: {
       toolName: signal.toolName,
       commandHash,
@@ -286,6 +374,7 @@ function createCandidate(signal, options, nowIso) {
 function syncValidatedLearningCandidate(history, options = {}) {
   const signal = detectValidatedLearningSignal(history);
   const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
+  const project = resolveValidatedLearningProject(options.projectDir);
   if (!homeDir) {
     return signal === null ? null : {
       ...signal,
@@ -300,6 +389,7 @@ function syncValidatedLearningCandidate(history, options = {}) {
     let candidates = readValidatedLearningCandidates({
       homeDir,
       profile: options.profile,
+      projectDir: options.projectDir,
     });
     const recordedCandidateIds = successfulMistakeRecordCandidateIds(history);
     for (const candidateId of recordedCandidateIds) {
@@ -309,7 +399,11 @@ function syncValidatedLearningCandidate(history, options = {}) {
       markCandidate(candidate, 'recorded', nowIso);
     }
     if (recordedCandidateIds.size > 0) {
-      candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+      candidates = readValidatedLearningCandidates({
+        homeDir,
+        profile: options.profile,
+        projectDir: options.projectDir,
+      });
     }
     let expiredCandidate = false;
     for (const candidate of candidates) {
@@ -320,11 +414,19 @@ function syncValidatedLearningCandidate(history, options = {}) {
       }
     }
     if (expiredCandidate) {
-      candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+      candidates = readValidatedLearningCandidates({
+        homeDir,
+        profile: options.profile,
+        projectDir: options.projectDir,
+      });
     }
     const retention = pruneTerminalValidatedLearningCandidates({ candidates });
     if (retention.deleted > 0) {
-      candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+      candidates = readValidatedLearningCandidates({
+        homeDir,
+        profile: options.profile,
+        projectDir: options.projectDir,
+      });
     }
     if (signal !== null) {
       const duplicate = pendingCandidateForSignal(candidates, signal);
@@ -332,7 +434,11 @@ function syncValidatedLearningCandidate(history, options = {}) {
         return { ...duplicate, source: 'current_turn' };
       }
       return {
-        ...createCandidate(signal, { homeDir, profile: options.profile }, nowIso),
+        ...createCandidate(signal, {
+          homeDir,
+          profile: options.profile,
+          projectId: project.projectId,
+        }, nowIso),
         source: 'current_turn',
       };
     }
@@ -352,5 +458,6 @@ module.exports = {
   normalizeCommand,
   pruneTerminalValidatedLearningCandidates,
   readValidatedLearningCandidates,
+  resolveValidatedLearningProject,
   syncValidatedLearningCandidate,
 };

package/blun.mjs

@@ -232224,7 +232224,8 @@ var init_validated_learning_signal = __esmMin((() => {
 			if (!shouldSyncValidatedLearningCandidate(this.agent.context.history)) return;
 			const signal = syncValidatedLearningCandidate(this.agent.context.history, {
 				homeDir: process.env["BLUN_SHARED_HOME"] ?? process.env["BLUN_HOME"] ?? "",
-				profile: process.env["BLUN_PROFILE"] ?? "default"
+				profile: process.env["BLUN_PROFILE"] ?? "default",
+				projectDir: process.cwd()
 			});
 			if (signal === null) {
 				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isValidatedLearningSignalReminder);
@@ -514729,7 +514730,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 +514839,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.399",
   "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);