@blunking/codexlink 0.1.2 → 0.1.10

package/telegram-plugin/lib/bridge.js

@@ -1,23 +1,71 @@
-import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { listLoadedThreadsOverWs, readThreadOverWs } from "./app-server-client.js";
 import { loadConfig } from "./env.js";
-import { injectIntoThread } from "./codex.js";
-import { getUpdates, sendMessage } from "./telegram.js";
+import { injectIntoThread, isAddressOnlyPing } from "./codex.js";
+import { getUpdates, sendChatAction, sendMessage } from "./telegram.js";
 import { appendJsonl, appendLog, defaultState, loadJson, nowIso, readTail, saveJson } from "./storage.js";
 
 function loadState(config) {
-  return loadJson(config.paths.stateFile, defaultState());
+  const state = loadJson(config.paths.stateFile, defaultState());
+  return scrubIdleBriefArtifactsInPlace(state);
 }
 
 function saveStateForConfig(config, state) {
-  saveJson(config.paths.stateFile, state);
+  saveJson(config.paths.stateFile, scrubIdleBriefArtifactsInPlace(state));
+}
+
+function persistActiveThreadBinding(config, threadId) {
+  const value = String(threadId || "").trim();
+  if (!value) {
+    return;
+  }
+
+  try {
+    const envPath = config.paths.envFile;
+    const existing = existsSync(envPath) ? readFileSync(envPath, "utf8").split(/\r?\n/) : [];
+    let wroteThread = false;
+    const lines = existing
+      .filter((line, index, all) => index < all.length - 1 || line.trim() !== "")
+      .map((line) => {
+        if (/^\s*BLUN_TELEGRAM_THREAD_ID\s*=/.test(line)) {
+          wroteThread = true;
+          return `BLUN_TELEGRAM_THREAD_ID=${value}`;
+        }
+        return line;
+      });
+    if (!wroteThread) {
+      lines.push(`BLUN_TELEGRAM_THREAD_ID=${value}`);
+    }
+    writeFileSync(envPath, `${lines.join("\n")}\n`, "utf8");
+  } catch {
+    // Runtime binding is a self-heal path; dispatch can continue with state.
+  }
+
+  try {
+    const runtimePath = config.paths.currentRuntimeFile;
+    const runtime = loadJson(runtimePath, null);
+    if (runtime && (!config.appServerWsUrl || !runtime.ws_url || String(runtime.ws_url).trim() === String(config.appServerWsUrl).trim())) {
+      runtime.thread_id = value;
+      saveJson(runtimePath, runtime);
+    }
+  } catch {
+    // Best effort only.
+  }
 }
 
 function queueKey(entry) {
   return `${entry.chatId}:${entry.messageId}`;
 }
 
+function hasKnownInboundMessage(state, inbound) {
+  const key = queueKey(inbound);
+  return [
+    ...(state.queue || []),
+    ...(state.pendingReplies || [])
+  ].some((entry) => queueKey(entry) === key);
+}
+
 function pendingReplyKey(entry) {
   return entry.turnId || `${entry.threadId || ""}:${entry.chatId}:${entry.messageId}`;
 }
@@ -32,17 +80,390 @@ function containsToken(text, token) {
 }
 
 function looksLikeEscalation(text) {
-  const value = String(text || "");
-  return [
+  const value = foldTriggerText(text);
+  if (!value) {
+    return false;
+  }
+  if ([
     "eskalation",
     "escalation",
     "urgent",
     "emergency",
-    "sofort",
     "prio 0",
     "p0",
     "blocker"
-  ].some((token) => containsToken(value, token));
+  ].some((token) => containsToken(value, token))) {
+    return true;
+  }
+  return containsToken(value, "sofort") && !/\bab sofort\b/u.test(value);
+}
+
+const CONTINUE_NEGATIVE_ONLY = new Set([
+  "ok",
+  "okay",
+  "ja",
+  "yes",
+  "si",
+  "oui",
+  "passt",
+  "gut",
+  "nice",
+  "cool",
+  "danke",
+  "thanks",
+  "merci",
+  "gracias",
+  "verstanden",
+  "perfekt",
+  "super",
+  "top",
+  "alles klar",
+  "sieht gut aus",
+  "hort sich gut an",
+  "hoert sich gut an"
+]);
+
+const CONTINUE_BLOCK_PATTERNS = [
+  /\bweiter so\b/u,
+  /^status\b/u,
+  /\bexplizites go\b/u,
+  /\bohne\b[\s\S]{0,24}\bgo\b/u
+];
+
+const CONTINUE_PATTERN_GROUPS = [
+  { weight: 4, patterns: [/\bmach weiter\b/u, /\bleg los\b/u, /\blos geht'?s\b/u, /\bfeuer frei\b/u, /\bsetz(?:e)? es um\b/u, /\bfu(?:eh|h)re es aus\b/u, /\bimplementiere es\b/u, /\bfix das\b/u, /\bfix den fehler\b/u, /\bbeheb(?:e)? das\b/u, /\breparier das\b/u, /\bteste es\b/u, /\bdebugge es\b/u] },
+  { weight: 4, patterns: [/\bgo ahead\b/u, /\bcontinue\b/u, /\bkeep going\b/u, /\bexecute it\b/u, /\bimplement it\b/u, /\bfix it\b/u, /\bpatch it\b/u, /\bdebug it\b/u, /\btest it\b/u, /\brun it\b/u, /\bsend it\b/u, /\bship it\b/u, /\bkeep cooking\b/u, /\bfinish the implementation\b/u] },
+  { weight: 4, patterns: [/\bdale\b/u, /\bvas y\b/u, /\bfais le\b/u, /\bcontinua\b/u, /\bvai avanti\b/u, /\bvamos\b/u, /\bga door\b/u, /\bkontynuuj\b/u, /\bdevam et\b/u] },
+  { weight: 3, patterns: [/\bund weiter\b/u, /\barbeite weiter\b/u, /\bsetz(?:e)? fort\b/u, /\bn(?:ae|a)chster schritt\b/u, /\bmach den n(?:ae|a)chsten schritt\b/u, /\bweiter trotz fehler\b/u, /\bnicht abbrechen\b/u, /\bnochmal versuchen\b/u, /\bbrief f(?:ue|u)r dich\b/u, /\bbrief\b[\s\S]{0,30}\babruf(?:en)?\b/u, /\bbrief\b[\s\S]{0,30}\bpull\b/u] },
+  { weight: 3, patterns: [/\bgib gas\b/u, /\bhau rein\b/u, /\bzieh durch\b/u, /\bzieh komplett durch\b/u, /\bnicht quatschen machen\b/u, /\bballer weiter\b/u, /\bmach den rest\b/u, /\bmach alleine weiter\b/u, /\bfull send\b/u, /\bfuck it we ball\b/u, /\byolo\b/u] }
+];
+
+const CONTINUE_ACTION_WORDS = [
+  "mach",
+  "start",
+  "weiter",
+  "los",
+  "arbeite",
+  "setz",
+  "setze",
+  "fuhre",
+  "fuehre",
+  "implementiere",
+  "fix",
+  "teste",
+  "debugge",
+  "patch",
+  "bau",
+  "ander",
+  "aender",
+  "schreib",
+  "go",
+  "continue",
+  "deploy",
+  "ship",
+  "baller",
+  "vollgas",
+  "cook",
+  "run"
+];
+
+const WORK_CONTEXT_HINTS = [
+  "auth",
+  "middleware",
+  "datei",
+  "file",
+  "code",
+  "anderung",
+  "aenderung",
+  "brief",
+  "abruf",
+  "pull",
+  "commit",
+  "test",
+  "debug",
+  "fehler",
+  "bug",
+  "fix",
+  "patch",
+  "implement",
+  "umsetzen",
+  "refactor",
+  "deploy",
+  "ui",
+  "portal",
+  "gruppe",
+  "konsole",
+  "plugin"
+];
+
+function normalizeTriggerText(text) {
+  return String(text || "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[’']/g, "'")
+    .replace(/[“”„"]/g, "\"")
+    .replace(/[–—]/g, "-")
+    .replace(/[^\p{L}\p{N}@_"'-]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function foldTriggerText(text) {
+  return normalizeTriggerText(text)
+    .normalize("NFD")
+    .replace(/\p{Diacritic}+/gu, "");
+}
+
+function tokenCount(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split(/\s+/).filter(Boolean).length;
+}
+
+function looksLikeWorkContextText(text) {
+  const normalized = foldTriggerText(text);
+  if (!normalized || CONTINUE_NEGATIVE_ONLY.has(normalized)) {
+    return false;
+  }
+  return WORK_CONTEXT_HINTS.some((token) => containsToken(normalized, token));
+}
+
+function hasRecentWorkContext(context = {}) {
+  const currentConversationKey = String(context.conversationKey || "").trim();
+  const recentEntries = Array.isArray(context.recentEntries) ? context.recentEntries : [];
+  if (context.hasRecentWorkContext === true) {
+    return true;
+  }
+  if (context.hasPendingReplies) {
+    return true;
+  }
+  if (recentEntries.some((entry) => String(entry.intent || "").trim().toLowerCase() !== "continue_nudge")) {
+    return true;
+  }
+
+  if (currentConversationKey) {
+    const recentConversationEntries = recentEntries.filter((entry) => String(entry.conversationKey || "").trim() === currentConversationKey);
+    if (recentConversationEntries.some((entry) => looksLikeWorkContextText(entry.text || entry.sourceText || ""))) {
+      return true;
+    }
+  }
+
+  if (looksLikeWorkContextText(context.lastUserWorkText || "")) {
+    return true;
+  }
+
+  return false;
+}
+
+function getContinueTriggerScore(text, context = {}) {
+  const normalized = foldTriggerText(text);
+  if (!normalized) {
+    return 0;
+  }
+  if (CONTINUE_NEGATIVE_ONLY.has(normalized)) {
+    return 0;
+  }
+  if (looksLikeStatusBroadcast(normalized)) {
+    return 0;
+  }
+
+  const words = tokenCount(normalized);
+  let score = 0;
+
+  for (const pattern of CONTINUE_BLOCK_PATTERNS) {
+    if (pattern.test(normalized)) {
+      score -= 2;
+    }
+  }
+
+  for (const group of CONTINUE_PATTERN_GROUPS) {
+    for (const pattern of group.patterns) {
+      if (pattern.test(normalized)) {
+        score += group.weight;
+      }
+    }
+  }
+
+  for (const actionWord of CONTINUE_ACTION_WORDS) {
+    if (containsToken(normalized, actionWord)) {
+      score += 1;
+    }
+  }
+
+  if (words > 0 && words <= 4 && score > 0) {
+    score += 1;
+  }
+
+  if (hasRecentWorkContext(context) && score > 0) {
+    score += 1;
+  }
+
+  if (/[!?]/.test(String(text || "")) && score < 3) {
+    score -= 1;
+  }
+
+  if (words > 12 && score < 3) {
+    score = Math.min(score, 1);
+  }
+
+  return Math.max(0, score);
+}
+
+function looksLikeContinueNudge(text, context = {}) {
+  const score = getContinueTriggerScore(text, context);
+  if (score >= 3) {
+    return true;
+  }
+  return score >= 1 && hasRecentWorkContext(context);
+}
+
+function looksLikeAckOnly(text) {
+  const value = String(text || "").trim().toLowerCase();
+  if (!value) {
+    return true;
+  }
+  if (value.length > 220) {
+    return false;
+  }
+  return [
+    "ok",
+    "okay",
+    "ja",
+    "verstanden",
+    "alles klar",
+    "mache ich",
+    "ich arbeite weiter",
+    "ich mache weiter",
+    "ich bin dran",
+    "ich bin da",
+    "weiter",
+    "alles klar, ich mache weiter",
+    "verstanden. ich arbeite weiter."
+  ].includes(value);
+}
+
+function looksLikeContextRequestOnly(text) {
+  const value = String(text || "").trim().toLowerCase();
+  if (!value || value.length > 280) {
+    return false;
+  }
+  return [
+    "mir fehlt in diesem chat gerade der konkrete arbeitskontext. schick mir bitte den letzten stand oder die aufgabe kurz hier rein, dann setze ich direkt fort.",
+    "schick mir kurz den letzten stand oder den punkt, ab dem ich anknüpfen soll.",
+    "schick mir bitte den letzten stand.",
+    "mir fehlt gerade der konkrete arbeitskontext.",
+    "welcher punkt genau?",
+    "womit genau soll ich weitermachen?"
+  ].includes(value);
+}
+
+function uniqueAgentMentionNames(config) {
+  const values = [
+    ...(Array.isArray(config.mentionNames) ? config.mentionNames : []),
+    config.agentName
+  ];
+  return Array.from(new Set(
+    values
+      .map((value) => foldTriggerText(value))
+      .filter((value) => value && value !== "default")
+  ));
+}
+
+function uniqueOtherAgentMentionNames(config) {
+  const ownNames = new Set(uniqueAgentMentionNames(config));
+  const values = Array.isArray(config.otherAgentNames) ? config.otherAgentNames : [];
+  return Array.from(new Set(
+    values
+      .map((value) => foldTriggerText(value))
+      .filter((value) => value && value !== "default" && !ownNames.has(value))
+  ));
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function looksLikeStatusBroadcast(text) {
+  const normalized = foldTriggerText(text);
+  if (/^status(?:\s|$|[~:.-])/u.test(normalized)) {
+    return true;
+  }
+  return /^[a-z][a-z0-9_-]{1,24}\s+\d{1,2}:\d{2}\b/u.test(normalized);
+}
+
+function isAgentAddressed(config, text) {
+  const normalized = foldTriggerText(text);
+  if (!normalized) {
+    return false;
+  }
+
+  const mentionNames = uniqueAgentMentionNames(config);
+  if (mentionNames.length === 0) {
+    return false;
+  }
+
+  for (const name of mentionNames) {
+    const mention = escapeRegExp(name);
+    const startsAddressed = new RegExp(`^@?${mention}\\b(?:\\s|\\s*[-:,]|$)`, "u").test(normalized);
+    if (startsAddressed) {
+      return true;
+    }
+
+    const routedToAgent = new RegExp(`\\b(?:fuer|fur|for|an|to)\\s+@?${mention}\\b`, "u").test(normalized);
+    if (routedToAgent) {
+      return true;
+    }
+
+    const briefDirective = new RegExp(`\\bbrief\\b[\\s\\S]{0,60}\\b@?${mention}\\b|\\b@?${mention}\\b[\\s\\S]{0,60}\\bbrief\\b`, "u").test(normalized);
+    if (briefDirective) {
+      return true;
+    }
+
+    const imperativeAfterMention = new RegExp(`\\b@?${mention}\\b\\s+(?:bitte|please|pull|abruf|abrufen|zieh|hol|hole|pruef|pruf|teste|debugge|fix|patch|mach|setz|starte|antwort|melde)\\b`, "u").test(normalized);
+    if (imperativeAfterMention) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isOtherAgentAddressed(config, text) {
+  const normalized = foldTriggerText(text);
+  if (!normalized) {
+    return false;
+  }
+
+  const mentionNames = uniqueOtherAgentMentionNames(config);
+  if (mentionNames.length === 0) {
+    return false;
+  }
+
+  for (const name of mentionNames) {
+    const mention = escapeRegExp(name);
+    const startsAddressed = new RegExp(`^@?${mention}\\b(?:\\s|\\s*[-:,]|$)`, "u").test(normalized);
+    if (startsAddressed) {
+      return true;
+    }
+
+    const routedToAgent = new RegExp(`\\b(?:fuer|fur|for|an|to)\\s+@?${mention}\\b`, "u").test(normalized);
+    if (routedToAgent) {
+      return true;
+    }
+
+    const briefDirective = new RegExp(`\\bbrief\\b[\\s\\S]{0,60}\\b@?${mention}\\b|\\b@?${mention}\\b[\\s\\S]{0,60}\\bbrief\\b`, "u").test(normalized);
+    if (briefDirective) {
+      return true;
+    }
+
+    const workDirective = new RegExp(`\\b@?${mention}\\b[\\s\\S]{0,80}\\b(?:bitte|please|weiter|continue|mach|pull|abruf|abrufen|zieh|hol|hole|pruef|pruf|teste|debugge|fix|patch|setz|starte|antwort|melde|uebersetz|ubersetz|translate)\\b|\\b(?:weiter|continue|mach|pull|abruf|abrufen|zieh|hol|hole|pruef|pruf|teste|debugge|fix|patch|setz|starte|antwort|melde|uebersetz|ubersetz|translate)\\b[\\s\\S]{0,80}\\b@?${mention}\\b`, "u").test(normalized);
+    if (workDirective) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 function classifyInboundRelevance(config, inbound) {
@@ -55,8 +476,21 @@ function classifyInboundRelevance(config, inbound) {
   }
 
   const text = String(inbound.text || "");
+  if (!looksLikeStatusBroadcast(text) && isAgentAddressed(config, text)) {
+    return "direct";
+  }
+
+  if (!looksLikeStatusBroadcast(text) && isOtherAgentAddressed(config, text)) {
+    return "ambient";
+  }
+
+  const allowedUserIds = Array.isArray(config.allowedChatIds) ? config.allowedChatIds : [];
+  if (!inbound.senderIsBot && allowedUserIds.includes(String(inbound.userId || ""))) {
+    return "direct";
+  }
+
   const agentName = String(config.agentName || "").trim();
-  if (agentName && agentName.toLowerCase() !== "default" && containsToken(text, agentName)) {
+  if (agentName && agentName.toLowerCase() !== "default" && !looksLikeStatusBroadcast(text) && containsToken(text, agentName)) {
     return "direct";
   }
 
@@ -75,6 +509,8 @@ function statusWeight(status) {
       return 4;
     case "submitted":
       return 2;
+    case "parked":
+      return 0;
     case "queued":
     default:
       return 1;
@@ -114,6 +550,215 @@ function pickLatestRecord(current, incoming) {
   return incomingId >= currentId ? { ...incoming } : { ...current };
 }
 
+function isoAgeMs(isoString) {
+  const millis = Date.parse(isoString || "");
+  if (Number.isNaN(millis)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, Date.now() - millis);
+}
+
+function isNonTerminalPendingReply(entry) {
+  return Boolean(entry)
+    && !entry.sentAt
+    && !["error", "ignored_bot", "superseded", "expired", "stale_thread"].includes(String(entry.status || ""));
+}
+
+function hasResponseMessageIds(entry) {
+  return Array.isArray(entry?.responseMessageIds)
+    && entry.responseMessageIds.filter(Boolean).length > 0;
+}
+
+function isReplyAwaitingOutcome(entry) {
+  if (!entry || typeof entry !== "object") {
+    return false;
+  }
+  const status = String(entry.status || "").trim().toLowerCase();
+  if (["sent", "suppressed_ack", "error", "ignored_bot", "superseded", "expired", "stale_thread"].includes(status)) {
+    return false;
+  }
+  return !hasResponseMessageIds(entry);
+}
+
+function closeStaleThreadPendingRepliesInPlace(pendingReplies, activeThreadId) {
+  const threadId = String(activeThreadId || "").trim();
+  if (!threadId) {
+    return 0;
+  }
+  const replies = Array.isArray(pendingReplies) ? pendingReplies : [];
+  let closed = 0;
+  for (const entry of replies) {
+    if (!isNonTerminalPendingReply(entry)) {
+      continue;
+    }
+    const entryThreadId = String(entry.threadId || "").trim();
+    if (!entryThreadId || entryThreadId === threadId) {
+      continue;
+    }
+    entry.status = "stale_thread";
+    entry.sentAt = nowIso();
+    entry.responsePreview = entry.responsePreview || `[stale pending reply from previous thread ${entryThreadId}]`;
+    closed += 1;
+  }
+  return closed;
+}
+
+function supersedeOlderPendingRepliesInPlace(pendingReplies) {
+  const replies = Array.isArray(pendingReplies) ? pendingReplies : [];
+  const newestByConversation = new Map();
+
+  for (const entry of replies) {
+    if (!isReplyAwaitingOutcome(entry)) {
+      continue;
+    }
+    const key = [
+      String(entry.chatId || "").trim(),
+      String(entry.conversationKey || "").trim(),
+      String(entry.telegramThreadId || "").trim()
+    ].join("|");
+    const current = newestByConversation.get(key);
+    const stamp = String(entry.createdAt || "");
+    if (!current || stamp > current.stamp) {
+      newestByConversation.set(key, { entry, stamp });
+    }
+  }
+
+  let superseded = 0;
+  for (const entry of replies) {
+    if (!isReplyAwaitingOutcome(entry)) {
+      continue;
+    }
+    const key = [
+      String(entry.chatId || "").trim(),
+      String(entry.conversationKey || "").trim(),
+      String(entry.telegramThreadId || "").trim()
+    ].join("|");
+    const newest = newestByConversation.get(key)?.entry || null;
+    if (!newest || newest === entry) {
+      continue;
+    }
+    entry.status = "superseded";
+    entry.sentAt = nowIso();
+    entry.responsePreview = entry.responsePreview || "[superseded by newer message]";
+    superseded += 1;
+  }
+
+  return superseded;
+}
+
+function isPrivateIdleBriefArtifact(entry) {
+  if (!entry) {
+    return false;
+  }
+  if (String(entry.chatType || "").toLowerCase() !== "private") {
+    return false;
+  }
+  return looksLikeMnemoIdleLoopBrief(entry.text || entry.sourceText || "");
+}
+
+function scrubIdleBriefArtifactsInPlace(state) {
+  if (!state || typeof state !== "object") {
+    return state;
+  }
+
+  const queue = Array.isArray(state.queue) ? state.queue : [];
+  state.queue = mergeQueueLists([], queue.filter((entry) => !isPrivateIdleBriefArtifact(entry)));
+
+  const pendingReplies = Array.isArray(state.pendingReplies) ? state.pendingReplies : [];
+  state.pendingReplies = mergePendingReplyLists([], pendingReplies.filter((entry) => !isPrivateIdleBriefArtifact(entry)));
+
+  if (isPrivateIdleBriefArtifact(state.lastInbound)) {
+    state.lastInbound = [...state.queue]
+      .filter((entry) => !isPrivateIdleBriefArtifact(entry))
+      .sort((left, right) => {
+        const leftStamp = String(left?.ts || left?.deliveredAt || left?.lastAttemptAt || "");
+        const rightStamp = String(right?.ts || right?.deliveredAt || right?.lastAttemptAt || "");
+        if (leftStamp !== rightStamp) {
+          return rightStamp.localeCompare(leftStamp);
+        }
+        return Number(right?.messageId || 0) - Number(left?.messageId || 0);
+      })[0] || null;
+  }
+
+  return state;
+}
+
+function closeExpiredPendingRepliesInPlace(config, pendingReplies) {
+  const replies = Array.isArray(pendingReplies) ? pendingReplies : [];
+  const timeoutMs = getEffectivePendingReplyTimeoutMs(config);
+  if (timeoutMs <= 0) {
+    return 0;
+  }
+
+  let expired = 0;
+  for (const entry of replies) {
+    if (hasResponseMessageIds(entry)) {
+      entry.status = String(entry.status || "").trim().toLowerCase() === "suppressed_ack" ? "suppressed_ack" : "sent";
+      entry.sentAt = entry.sentAt || getPendingReplyActivityAt(entry) || nowIso();
+      continue;
+    }
+    if (!isNonTerminalPendingReply(entry)) {
+      continue;
+    }
+    if (isoAgeMs(getPendingReplyActivityAt(entry)) < timeoutMs) {
+      continue;
+    }
+    entry.status = "expired";
+    entry.sentAt = nowIso();
+    entry.responsePreview = entry.responsePreview || `[pending reply expired after ${timeoutMs}ms]`;
+    expired += 1;
+  }
+  return expired;
+}
+
+function getEffectivePendingReplyTimeoutMs(config) {
+  const configuredMs = Math.max(Number(config.pendingReplyTimeoutMs || 0), 0);
+  if (configuredMs <= 0) {
+    return 0;
+  }
+  return configuredMs;
+}
+
+function getEffectiveIdleCooldownMs(config, entry = null) {
+  const configuredMs = Math.max(Number(config.idleCooldownMs || 0), 0);
+  if (configuredMs <= 0) {
+    return 0;
+  }
+  const relevance = String(entry?.relevance || "").trim().toLowerCase();
+  const chatType = String(entry?.chatType || "").trim().toLowerCase();
+  const directLike = chatType === "private" || relevance === "direct" || relevance === "lane";
+  const capMs = directLike ? 3000 : 5000;
+  return Math.min(configuredMs, capMs);
+}
+
+function parkExpiredAmbientQueueEntriesInPlace(config, queue) {
+  const entries = Array.isArray(queue) ? queue : [];
+  const ttlMs = Math.max(Number(config.ambientQueueTtlMs || 0), 0);
+  if (ttlMs <= 0) {
+    return 0;
+  }
+
+  let parked = 0;
+  for (const entry of entries) {
+    if (!entry || entry.status !== "queued") {
+      continue;
+    }
+    if (String(entry.relevance || "") !== "ambient") {
+      continue;
+    }
+    if (isoAgeMs(entry.ts) < ttlMs) {
+      continue;
+    }
+    entry.status = "parked";
+    entry.parkedAt = nowIso();
+    if (!entry.responsePreview) {
+      entry.responsePreview = `[ambient parked after ${ttlMs}ms]`;
+    }
+    parked += 1;
+  }
+  return parked;
+}
+
 function mergeQueueEntry(current, incoming) {
   if (!current && !incoming) {
     return null;
@@ -142,7 +787,7 @@ function mergeQueueEntry(current, incoming) {
   merged.deliveredAt = pickIsoLater(current.deliveredAt, incoming.deliveredAt);
   merged.ts = pickIsoLater(current.ts, incoming.ts);
 
-  for (const field of ["threadId", "responsePreview", "stderr", "stdout", "chatType", "conversationKey", "groupTitle", "telegramThreadId", "senderIsBot", "relevance"]) {
+  for (const field of ["threadId", "responsePreview", "stderr", "stdout", "chatType", "conversationKey", "groupTitle", "telegramThreadId", "senderIsBot", "relevance", "intent"]) {
     if (!merged[field]) {
       merged[field] = current[field] || incoming[field] || null;
     }
@@ -298,6 +943,22 @@ function syncRecordFromQueue(record, queue) {
   return match ? mergeQueueEntry(record, match) : record;
 }
 
+function markMatchingQueueEntriesInPlace(state, source, updates) {
+  const key = queueKey(source || {});
+  if (!key || key === ":") {
+    return 0;
+  }
+  let changed = 0;
+  for (const entry of state.queue || []) {
+    if (queueKey(entry) !== key) {
+      continue;
+    }
+    Object.assign(entry, updates);
+    changed += 1;
+  }
+  return changed;
+}
+
 function mergeStateSnapshots(currentState, incomingState) {
   const merged = {
     ...currentState,
@@ -320,6 +981,7 @@ function mergeStateSnapshots(currentState, incomingState) {
     merged.queue
   );
   merged.lastOutbound = pickLatestRecord(currentState.lastOutbound || null, incomingState.lastOutbound || null);
+  merged.lastUiNotice = pickLatestRecord(currentState.lastUiNotice || null, incomingState.lastUiNotice || null);
   merged.lastPollAt = pickIsoLater(currentState.lastPollAt, incomingState.lastPollAt);
   merged.lastInjectAt = pickIsoLater(currentState.lastInjectAt, incomingState.lastInjectAt);
   merged.currentThreadId = incomingState.currentThreadId || currentState.currentThreadId || "";
@@ -346,6 +1008,7 @@ function normalizeInbound(message) {
     userId: message.from?.id ? String(message.from.id) : "",
     text,
     ts: nowIso(),
+    intent: "message",
     relevance: "ambient",
     status: "queued",
     attempts: 0,
@@ -353,47 +1016,377 @@ function normalizeInbound(message) {
   };
 }
 
-function normalizeTelegramThreadId(value) {
-  return String(value || "").trim();
+function buildContinueContext(state, inbound) {
+  const sameConversation = (entry) => String(entry?.conversationKey || "").trim() === String(inbound?.conversationKey || "").trim();
+  const recentEntries = [
+    ...(state.queue || []),
+    ...(state.pendingReplies || [])
+  ].filter((entry) => {
+    if (!entry || entry.senderIsBot) {
+      return false;
+    }
+    if (!sameConversation(entry)) {
+      return false;
+    }
+    const ageMs = isoAgeMs(entry.ts || entry.createdAt || entry.deliveredAt || entry.lastAttemptAt || "");
+    return ageMs <= 1000 * 60 * 60 * 6;
+  });
+
+  const lastUserWorkEntry = [...recentEntries]
+    .reverse()
+    .find((entry) => String(entry.intent || "").trim().toLowerCase() !== "continue_nudge");
+
+  return {
+    conversationKey: inbound?.conversationKey || "",
+    recentEntries,
+    lastUserWorkText: lastUserWorkEntry?.text || lastUserWorkEntry?.sourceText || "",
+    hasPendingReplies: (state.pendingReplies || []).some((entry) => {
+      if (!entry || entry.senderIsBot || entry.sentAt) {
+        return false;
+      }
+      return sameConversation(entry);
+    })
+  };
+}
+
+function looksLikeMnemoIdleLoopBrief(text) {
+  const value = String(text || "").trim();
+  if (!value) {
+    return false;
+  }
+  if (/^Mnemo Idle #\d+:/i.test(value)) {
+    return true;
+  }
+  return /^---\s*BRIEF\b[\s\S]*\bfrom=mnemo-idle-loop\b[\s\S]*\[IDLE-CYCLE\]/i.test(value);
+}
+
+function normalizeTelegramThreadId(value) {
+  return String(value || "").trim();
+}
+
+function isAllowedChat(config, chatId) {
+  const allowed = Array.isArray(config.allowedChatIds) ? config.allowedChatIds : [];
+  if (allowed.length === 0) {
+    return true;
+  }
+  return allowed.includes(String(chatId || "").trim());
+}
+
+function splitTelegramText(text, maxLength = 3500) {
+  const value = String(text || "").trim();
+  if (!value) {
+    return [];
+  }
+  if (value.length <= maxLength) {
+    return [value];
+  }
+
+  const chunks = [];
+  let remaining = value;
+  while (remaining.length > maxLength) {
+    let cut = remaining.lastIndexOf("\n\n", maxLength);
+    if (cut < 0 || cut < maxLength * 0.5) {
+      cut = remaining.lastIndexOf("\n", maxLength);
+    }
+    if (cut < 0 || cut < maxLength * 0.5) {
+      cut = remaining.lastIndexOf(" ", maxLength);
+    }
+    if (cut < 0 || cut < maxLength * 0.5) {
+      cut = maxLength;
+    }
+    chunks.push(remaining.slice(0, cut).trim());
+    remaining = remaining.slice(cut).trim();
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks.filter(Boolean);
+}
+
+function shouldSendDeferredReceipt(config, entry, reason) {
+  if (!config?.queueNoticeEnabled) {
+    return false;
+  }
+  if (!entry) {
+    return false;
+  }
+  if (entry.senderIsBot) {
+    return false;
+  }
+  if (entry.intent === "continue_nudge") {
+    return false;
+  }
+  if (entry.queueNoticeSentAt) {
+    return false;
+  }
+  if (!["pending_reply", "session_active"].includes(String(reason || ""))) {
+    return false;
+  }
+  const relevance = String(entry.relevance || "").toLowerCase();
+  const chatType = String(entry.chatType || "").toLowerCase();
+  return chatType === "private" || relevance === "direct" || relevance === "lane";
+}
+
+function shouldSendTypingIndicator(entry) {
+  if (!entry || entry.senderIsBot) {
+    return false;
+  }
+  const relevance = String(entry.relevance || "").toLowerCase();
+  const chatType = String(entry.chatType || "").toLowerCase();
+  return chatType === "private" || relevance === "direct" || relevance === "lane";
+}
+
+function buildDeferredReceiptText(entry) {
+  const chatType = String(entry?.chatType || "").toLowerCase();
+  const user = String(entry?.user || "").trim();
+  if (chatType === "private") {
+    return "Ich habe deine Nachricht. Ich ziehe sie nach dem aktuellen Lauf.";
+  }
+  if (user) {
+    return `Alles klar ${user}, ich habe deine Nachricht. Ich ziehe sie nach dem aktuellen Lauf.`;
+  }
+  return "Ich habe die Nachricht. Ich ziehe sie nach dem aktuellen Lauf.";
+}
+
+function buildProgressFallbackText(entry) {
+  const chatType = String(entry?.chatType || "").toLowerCase();
+  const user = String(entry?.user || "").trim();
+  if (chatType === "private") {
+    return "Ich arbeite noch daran und melde den naechsten konkreten Stand hier.";
+  }
+  if (user) {
+    return `${user}, ich arbeite noch daran und melde den naechsten konkreten Stand hier.`;
+  }
+  return "Ich arbeite noch daran und melde den naechsten konkreten Stand hier.";
+}
+
+function hasRecentSessionWrite(entry, sessionPath, activeWindowMs = 15000) {
+  if (!entry?.createdAt || !sessionPath || !existsSync(sessionPath)) {
+    return false;
+  }
+  try {
+    const modifiedAt = statSync(sessionPath).mtimeMs;
+    const createdAt = Date.parse(entry.createdAt);
+    if (!Number.isFinite(createdAt) || modifiedAt < createdAt) {
+      return false;
+    }
+    return Date.now() - modifiedAt <= activeWindowMs;
+  } catch {
+    return false;
+  }
+}
+
+function shouldSendFallbackProgress(config, entry, sessionPath) {
+  if (!entry || entry.senderIsBot) {
+    return false;
+  }
+  const fallbackMs = Math.max(Number(config.progressFallbackMs || 0), 0);
+  if (fallbackMs <= 0 || isoAgeMs(entry.createdAt) < fallbackMs) {
+    return false;
+  }
+
+  const intent = String(entry.intent || "").trim().toLowerCase();
+  const relevance = String(entry.relevance || "").trim().toLowerCase();
+  const sourceText = entry.sourceText || entry.text || "";
+  const looksLikeWork = intent === "continue_nudge"
+    || relevance === "escalation"
+    || looksLikeWorkContextText(sourceText);
+  if (!looksLikeWork) {
+    return false;
+  }
+
+  return hasRecentSessionWrite(entry, sessionPath);
+}
+
+function shouldSendProgressUpgrade(entry, progress) {
+  if (!entry || !progress) {
+    return false;
+  }
+  if (String(entry.progressMode || "").trim().toLowerCase() !== "fallback") {
+    return false;
+  }
+  if (entry.progressUpgradeSentAt) {
+    return false;
+  }
+  const progressText = normalizeWhitespace(repairMojibake(progress.message || ""));
+  if (!progressText) {
+    return false;
+  }
+  const fallbackText = normalizeWhitespace(repairMojibake(entry.progressPreview || ""));
+  if (!fallbackText || progressText === fallbackText) {
+    return false;
+  }
+  if (looksLikeAckOnly(progressText) || looksLikeContextRequestOnly(progressText)) {
+    return false;
+  }
+  return true;
+}
+
+function getProgressRelayMode(config) {
+  const mode = String(config?.progressRelayMode || "status").trim().toLowerCase();
+  if (["off", "status", "commentary"].includes(mode)) {
+    return mode;
+  }
+  return "status";
 }
 
-function isAllowedChat(config, chatId) {
-  const allowed = Array.isArray(config.allowedChatIds) ? config.allowedChatIds : [];
-  if (allowed.length === 0) {
-    return true;
+function getPendingReplyActivityAt(entry) {
+  if (!entry || typeof entry !== "object") {
+    return "";
   }
-  return allowed.includes(String(chatId || "").trim());
+  return String(
+    entry.lastSignalAt
+    || entry.progressSentAt
+    || entry.sentAt
+    || entry.createdAt
+    || ""
+  ).trim();
 }
 
-function splitTelegramText(text, maxLength = 3500) {
-  const value = String(text || "").trim();
-  if (!value) {
-    return [];
-  }
-  if (value.length <= maxLength) {
-    return [value];
+function normalizeWhitespace(text) {
+  return String(text || "")
+    .replace(/\r/g, " ")
+    .replace(/\n/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function repairMojibake(text) {
+  const value = String(text || "");
+  if (!/[Ãâ�]/.test(value)) {
+    return value;
   }
 
-  const chunks = [];
-  let remaining = value;
-  while (remaining.length > maxLength) {
-    let cut = remaining.lastIndexOf("\n\n", maxLength);
-    if (cut < 0 || cut < maxLength * 0.5) {
-      cut = remaining.lastIndexOf("\n", maxLength);
-    }
-    if (cut < 0 || cut < maxLength * 0.5) {
-      cut = remaining.lastIndexOf(" ", maxLength);
+  try {
+    const repaired = Buffer.from(value, "latin1").toString("utf8");
+    if (repaired && !/\u0000/.test(repaired)) {
+      return repaired;
     }
-    if (cut < 0 || cut < maxLength * 0.5) {
-      cut = maxLength;
+  } catch {
+    // Fall through to targeted replacements.
+  }
+
+  return value
+    .replace(/—/g, "-")
+    .replace(/–/g, "-")
+    .replace(/„|“|”/g, "\"")
+    .replace(/’|‘/g, "'")
+    .replace(/…/g, "...")
+    .replace(/€/g, "EUR")
+    .replace(/Ä/g, "Ä")
+    .replace(/Ö/g, "Ö")
+    .replace(/Ãœ/g, "Ü")
+    .replace(/ä/g, "ä")
+    .replace(/ö/g, "ö")
+    .replace(/ü/g, "ü")
+    .replace(/ß/g, "ß");
+}
+
+function shouldPublishInboundUiNotice(entry) {
+  if (!entry) {
+    return false;
+  }
+  if (entry.senderIsBot) {
+    return false;
+  }
+  const chatType = String(entry.chatType || "").toLowerCase();
+  const relevance = String(entry.relevance || "").toLowerCase();
+  return chatType === "private" || ["direct", "lane", "escalation"].includes(relevance);
+}
+
+function formatCompactInboundUiNotice(entry) {
+  const text = normalizeWhitespace(repairMojibake(entry?.text || "")).slice(0, 180);
+  if (!text) {
+    return "";
+  }
+  if (/^(brief von|mnemo idle #)/i.test(text)) {
+    return text;
+  }
+  const user = String(entry?.user || "unknown").trim();
+  const groupTitle = String(entry?.groupTitle || "").trim();
+  const chatType = String(entry?.chatType || "").trim().toLowerCase();
+  if (chatType === "private" || !groupTitle) {
+    return `${user}: ${text}`;
+  }
+  return `${user} @ ${groupTitle}: ${text}`;
+}
+
+function findRecentOutboundForTurn(config, chatId, source, sourceTurnId, text = "") {
+  if (!config?.paths?.outboxFile || !existsSync(config.paths.outboxFile)) {
+    return null;
+  }
+  const normalizedChatId = String(chatId || "").trim();
+  const normalizedSource = String(source || "").trim();
+  const normalizedTurnId = String(sourceTurnId || "").trim();
+  const normalizedText = normalizeWhitespace(repairMojibake(text || ""));
+  if (!normalizedChatId || !normalizedSource || !normalizedTurnId) {
+    return null;
+  }
+
+  const matches = [];
+  for (const line of readTail(config.paths.outboxFile, 400).reverse()) {
+    try {
+      const item = JSON.parse(line);
+      if (String(item?.chatId || "").trim() !== normalizedChatId) {
+        continue;
+      }
+      if (String(item?.source || "").trim() !== normalizedSource) {
+        continue;
+      }
+      if (String(item?.sourceTurnId || "").trim() !== normalizedTurnId) {
+        continue;
+      }
+      if (normalizedText) {
+        const itemText = normalizeWhitespace(repairMojibake(item?.text || ""));
+        if (itemText !== normalizedText) {
+          continue;
+        }
+      }
+      matches.push(item);
+    } catch {
+      // Ignore malformed tail lines.
     }
-    chunks.push(remaining.slice(0, cut).trim());
-    remaining = remaining.slice(cut).trim();
   }
-  if (remaining) {
-    chunks.push(remaining);
+
+  if (matches.length === 0) {
+    return null;
+  }
+
+  matches.sort((left, right) => String(left?.ts || "").localeCompare(String(right?.ts || "")));
+  return {
+    outbound: matches[matches.length - 1],
+    messageIds: matches.map((item) => String(item.messageId || "").trim()).filter(Boolean)
+  };
+}
+
+async function maybeSendDeferredReceipt(config, state, entry, reason) {
+  if (!shouldSendDeferredReceipt(config, entry, reason)) {
+    return false;
+  }
+
+  try {
+    await sendOutboundChunks(config, state, {
+      chatId: entry.chatId,
+      text: buildDeferredReceiptText(entry),
+      replyToMessageId: entry.messageId,
+      telegramThreadId: entry.telegramThreadId,
+      source: "queue_notice"
+    });
+    entry.queueNoticeSentAt = nowIso();
+    entry.queueNoticeReason = String(reason || "");
+    state.lastQueueNoticeAt = entry.queueNoticeSentAt;
+    appendLog(
+      config.paths.activityFile,
+      `QUEUE_NOTICE chat=${entry.chatId} message=${entry.messageId} reason=${entry.queueNoticeReason || "-"}`
+    );
+    return true;
+  } catch (error) {
+    appendLog(
+      config.paths.activityFile,
+      `QUEUE_NOTICE_ERROR chat=${entry.chatId} message=${entry.messageId} reason=${String(reason || "-")}: ${error}`
+    );
+    return false;
   }
-  return chunks.filter(Boolean);
 }
 
 function readJsonlDelta(path, offset, carry = "") {
@@ -456,17 +1449,28 @@ async function resolveThreadSessionPath(config, threadId) {
   return findRolloutFile(config.paths.sessionsDir, threadId) || "";
 }
 
-function countOpenPendingReplies(state) {
-  return (state.pendingReplies || []).filter((entry) => !entry.sentAt && !["error", "ignored_bot", "superseded"].includes(String(entry.status || ""))).length;
+function countOpenPendingReplies(state, config) {
+  const timeoutMs = getEffectivePendingReplyTimeoutMs(config);
+  return (state.pendingReplies || []).filter((entry) => {
+    if (!isNonTerminalPendingReply(entry)) {
+      return false;
+    }
+    if (timeoutMs > 0 && isoAgeMs(entry.createdAt) >= timeoutMs) {
+      return false;
+    }
+    return true;
+  }).length;
 }
 
-async function resolveSessionActivity(config, threadId) {
+async function resolveSessionActivity(config, threadId, entry = null) {
   const sessionPath = await resolveThreadSessionPath(config, threadId);
+  const cooldownMs = getEffectiveIdleCooldownMs(config, entry);
   if (!sessionPath || !existsSync(sessionPath)) {
     return {
       sessionPath,
       quietMs: Number.POSITIVE_INFINITY,
-      active: false
+      active: false,
+      cooldownMs
     };
   }
 
@@ -474,7 +1478,8 @@ async function resolveSessionActivity(config, threadId) {
   return {
     sessionPath,
     quietMs,
-    active: quietMs < Number(config.idleCooldownMs || 0)
+    active: quietMs < cooldownMs,
+    cooldownMs
   };
 }
 
@@ -494,6 +1499,7 @@ function buildPendingReplyEntry(message, threadId, turnId, sessionPath, sessionO
     groupTitle: String(message.groupTitle || "").trim(),
     user: String(message.user || "").trim(),
     sourceText: String(message.text || ""),
+    intent: String(message.intent || "message").trim(),
     createdAt: nowIso(),
     status: "pending",
     sentAt: null,
@@ -502,6 +1508,16 @@ function buildPendingReplyEntry(message, threadId, turnId, sessionPath, sessionO
   };
 }
 
+function shouldTrackPendingReply(message) {
+  if (!message) {
+    return false;
+  }
+  if (looksLikeBotSender(message)) {
+    return false;
+  }
+  return String(message.intent || "message").trim().toLowerCase() !== "continue_nudge";
+}
+
 function parseUnixSeconds(isoString) {
   const millis = Date.parse(isoString || "");
   if (Number.isNaN(millis)) {
@@ -510,6 +1526,46 @@ function parseUnixSeconds(isoString) {
   return Math.floor(millis / 1000);
 }
 
+function isPidAlive(pid) {
+  const parsed = Number.parseInt(String(pid || "0"), 10);
+  if (!parsed || parsed <= 0) {
+    return false;
+  }
+  try {
+    process.kill(parsed, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getRuntimeOwner(config) {
+  if (!config.paths.currentRuntimeFile || !existsSync(config.paths.currentRuntimeFile)) {
+    return null;
+  }
+  const runtime = loadJson(config.paths.currentRuntimeFile, null);
+  if (!runtime) {
+    return null;
+  }
+  if (config.appServerWsUrl && runtime.ws_url && String(runtime.ws_url).trim() !== String(config.appServerWsUrl).trim()) {
+    return null;
+  }
+  const frontendHostPid = Number.parseInt(String(runtime.frontend_host_pid || "0"), 10) || 0;
+  return {
+    runtime,
+    frontendHostPid,
+    frontendAlive: isPidAlive(frontendHostPid)
+  };
+}
+
+function normalizeThreadTimestampMs(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return 0;
+  }
+  return numeric > 100000000000 ? numeric : numeric * 1000;
+}
+
 function buildHistoryText(message) {
   const text = String(message.text || "").trim();
   const chatType = String(message.chatType || "");
@@ -602,7 +1658,7 @@ function promoteVisibleQueuedEntry(config, state, threadId, message) {
   return true;
 }
 
-async function resolveActiveThreadId(config, state, preferredThreadId) {
+async function resolveActiveThreadId(config, state, preferredThreadId, options = {}) {
   const fallbackThreadId = String(preferredThreadId || config.currentThreadId || state.currentThreadId || "").trim();
   if (!config.appServerWsUrl) {
     return fallbackThreadId;
@@ -618,6 +1674,19 @@ async function resolveActiveThreadId(config, state, preferredThreadId) {
       return fallbackThreadId;
     }
 
+    const runtimeOwner = getRuntimeOwner(config);
+    const runtimeThreadId = String(runtimeOwner?.runtime?.thread_id || "").trim();
+    const pinnedThreadId = String(preferredThreadId || config.currentThreadId || runtimeThreadId || "").trim();
+    if (options.forcePreferred && pinnedThreadId && loadedIds.includes(pinnedThreadId)) {
+      if (state.currentThreadId !== pinnedThreadId) {
+        state.currentThreadId = pinnedThreadId;
+        saveStateForConfig(config, state);
+        appendLog(config.paths.activityFile, `REMOTE_ACTIVE_THREAD_PINNED thread=${pinnedThreadId}`);
+      }
+      persistActiveThreadBinding(config, pinnedThreadId);
+      return pinnedThreadId;
+    }
+
     let bestThreadId = loadedIds[loadedIds.length - 1];
     let bestScore = Number.NEGATIVE_INFINITY;
 
@@ -629,9 +1698,23 @@ async function resolveActiveThreadId(config, state, preferredThreadId) {
           threadId: candidateThreadId,
           timeoutMs: 5000
         });
-        const sessionPath = String(readResult?.response?.result?.thread?.path || "").trim();
+        const thread = readResult?.response?.result?.thread || {};
+        const createdAtMs = normalizeThreadTimestampMs(thread.createdAt);
+        if (createdAtMs > 0) {
+          score = createdAtMs;
+        }
+        const source = String(thread.source || "").toLowerCase();
+        const statusType = String(thread.status?.type || "").toLowerCase();
+        if (source === "cli" && statusType === "active") {
+          score += 1000000000000000;
+        } else if (statusType === "active") {
+          score += 900000000000000;
+        } else if (source === "cli") {
+          score += 800000000000000;
+        }
+        const sessionPath = String(thread.path || "").trim();
         if (sessionPath && existsSync(sessionPath)) {
-          score = statSync(sessionPath).mtimeMs;
+          score = Math.max(score, statSync(sessionPath).birthtimeMs || 0);
         }
       } catch {
         score = 0;
@@ -648,6 +1731,7 @@ async function resolveActiveThreadId(config, state, preferredThreadId) {
       saveStateForConfig(config, state);
       appendLog(config.paths.activityFile, `REMOTE_ACTIVE_THREAD thread=${bestThreadId}`);
     }
+    persistActiveThreadBinding(config, bestThreadId);
     return bestThreadId;
   } catch (error) {
     const message = String(error?.message || error).replace(/\s+/g, " ").slice(0, 180);
@@ -659,20 +1743,38 @@ async function resolveActiveThreadId(config, state, preferredThreadId) {
 export function bridgeStatus() {
   const config = loadConfig();
   const state = loadState(config);
+  const runtimeOwner = getRuntimeOwner(config);
+  const parkedAmbient = parkExpiredAmbientQueueEntriesInPlace(config, state.queue || []);
+  state.pendingReplies = reconcilePendingRepliesInPlace(state.pendingReplies || []);
+  const expiredPendingReplies = closeExpiredPendingRepliesInPlace(config, state.pendingReplies || []);
+  if (expiredPendingReplies > 0 || parkedAmbient > 0) {
+    if (parkedAmbient > 0) {
+      appendLog(config.paths.activityFile, `AMBIENT_PARKED count=${parkedAmbient}`);
+    }
+    saveStateForConfig(config, state);
+  }
   const queued = state.queue.filter((item) => item.status === "queued");
   const submitted = state.queue.filter((item) => item.status === "submitted");
+  const parked = state.queue.filter((item) => item.status === "parked");
   const ambient = queued.filter((item) => item.relevance === "ambient");
-  const pendingReplies = (state.pendingReplies || []).filter((item) => !item.sentAt && item.status !== "error");
+  const pendingReplies = (state.pendingReplies || []).filter((item) => isNonTerminalPendingReply(item));
+  const expiredReplies = (state.pendingReplies || []).filter((item) => String(item.status || "") === "expired");
   return {
     agent: config.agentName,
     allowedChatId: config.allowedChatId || null,
     boundThreadId: config.currentThreadId || state.currentThreadId || null,
+    frontendOwnerPid: runtimeOwner?.frontendHostPid || null,
+    frontendOwnerAlive: runtimeOwner?.frontendAlive ?? null,
     dispatchMode: config.dispatchMode,
     idleCooldownMs: config.idleCooldownMs,
+    pendingReplyTimeoutMs: config.pendingReplyTimeoutMs,
     queueDepth: queued.length,
     ambientQueueDepth: ambient.length,
+    parkedQueueDepth: parked.length,
     submittedDepth: submitted.length,
     pendingReplyDepth: pendingReplies.length,
+    expiredPendingReplyDepth: expiredReplies.length,
+    progressRelayMode: getProgressRelayMode(config),
     lastInbound: state.lastInbound,
     lastOutbound: state.lastOutbound,
     lastPollAt: state.lastPollAt,
@@ -696,10 +1798,43 @@ async function sendOutboundChunks(config, state, options) {
     throw new Error("Outbound Telegram text is empty.");
   }
 
+  if ((source === "auto" || source === "auto_progress") && sourceTurnId) {
+    const existing = findRecentOutboundForTurn(config, chatId, source, sourceTurnId, text);
+    if (existing?.outbound) {
+      state.lastOutbound = existing.outbound;
+      appendLog(
+        config.paths.activityFile,
+        `OUT_AUTO_SKIP_DUP chat=${chatId} reply_to=${replyToMessageId || "-"} turn=${sourceTurnId} outbound=${existing.messageIds.join(",")}`
+      );
+      return {
+        ok: true,
+        outbound: existing.outbound,
+        messageIds: existing.messageIds,
+        skippedDuplicate: true
+      };
+    }
+  }
+
   const chunks = splitTelegramText(text);
   const messageIds = [];
   let lastOutbound = null;
 
+  const contextEntry = [
+    ...(state.queue || []),
+    ...(state.pendingReplies || [])
+  ].find((entry) => {
+    if (String(entry.chatId || "").trim() !== chatId) {
+      return false;
+    }
+    if (replyToMessageId && String(entry.messageId || entry.replyToMessageId || "").trim() === replyToMessageId) {
+      return true;
+    }
+    if (telegramThreadId && String(entry.telegramThreadId || "").trim() === telegramThreadId) {
+      return true;
+    }
+    return false;
+  }) || null;
+
   for (let index = 0; index < chunks.length; index += 1) {
     const chunk = chunks[index];
     const result = await sendMessage(config, {
@@ -725,6 +1860,36 @@ async function sendOutboundChunks(config, state, options) {
     lastOutbound = outbound;
   }
 
+  if (lastOutbound) {
+    try {
+      const preview = (
+        typeof normalizeWhitespace === "function"
+          ? normalizeWhitespace(repairMojibake(lastOutbound.text))
+          : String(lastOutbound.text || "")
+            .replace(/\r/g, " ")
+            .replace(/\n/g, " ")
+            .replace(/\s+/g, " ")
+            .trim()
+      ).slice(0, 140);
+      const groupTitle = String(contextEntry?.groupTitle || "").trim();
+      const user = String(contextEntry?.user || "").trim();
+      const chatType = String(contextEntry?.chatType || "").trim().toLowerCase();
+      let label = "Antwort";
+      if (groupTitle) {
+        label = `Antwort @ ${groupTitle}`;
+      } else if (chatType === "private" && user) {
+        label = `Antwort an ${user}`;
+      }
+      state.lastUiNotice = {
+        ts: nowIso(),
+        kind: "outbound",
+        text: `${label}: ${preview}`
+      };
+    } catch (error) {
+      appendLog(config.paths.activityFile, `UI_NOTICE_ERROR chat=${chatId} reply_to=${replyToMessageId || "-"}: ${error}`);
+    }
+  }
+
   return {
     ok: true,
     outbound: lastOutbound,
@@ -751,6 +1916,10 @@ export function bindCurrentThread(threadId) {
 export async function pollOnce() {
   const config = loadConfig();
   const state = loadState(config);
+  const parkedAmbientAtStart = parkExpiredAmbientQueueEntriesInPlace(config, state.queue || []);
+  if (parkedAmbientAtStart > 0) {
+    appendLog(config.paths.activityFile, `AMBIENT_PARKED count=${parkedAmbientAtStart}`);
+  }
   const startOffset = Number(state.offset || 0);
   const updates = await getUpdates(config, startOffset);
   let captured = 0;
@@ -768,14 +1937,45 @@ export async function pollOnce() {
       appendLog(config.paths.activityFile, `IGNORED chat=${inbound.chatId} message=${inbound.messageId}`);
       continue;
     }
+    if (String(inbound.chatType || "") === "private" && looksLikeMnemoIdleLoopBrief(inbound.text)) {
+      ignored += 1;
+      appendLog(config.paths.activityFile, `IGNORED_IDLE_BRIEF chat=${inbound.chatId} message=${inbound.messageId}`);
+      continue;
+    }
     if (!inbound.text.trim()) {
       ignored += 1;
       appendLog(config.paths.activityFile, `IGNORED_EMPTY chat=${inbound.chatId} message=${inbound.messageId}`);
       continue;
     }
+    const continueContext = buildContinueContext(state, inbound);
+    inbound.intent = looksLikeContinueNudge(inbound.text, continueContext) ? "continue_nudge" : "message";
     inbound.relevance = classifyInboundRelevance(config, inbound);
+    if (hasKnownInboundMessage(state, inbound)) {
+      ignored += 1;
+      appendLog(config.paths.activityFile, `IGNORED_DUPLICATE chat=${inbound.chatId} message=${inbound.messageId}`);
+      continue;
+    }
+    if (String(inbound.chatType || "") !== "private" && String(inbound.relevance || "") === "ambient") {
+      ignored += 1;
+      appendJsonl(config.paths.inboxFile, { ...inbound, status: "ignored_ambient" });
+      appendLog(config.paths.activityFile, `IGNORED_AMBIENT chat=${inbound.chatId} message=${inbound.messageId} user=${inbound.user}: ${inbound.text.replace(/\s+/g, " ").slice(0, 180)}`);
+      continue;
+    }
+    if (shouldSendTypingIndicator(inbound)) {
+      void sendChatAction(config, {
+        chatId: inbound.chatId,
+        telegramThreadId: inbound.telegramThreadId
+      }).catch(() => {});
+    }
     state.queue.push(inbound);
     state.lastInbound = inbound;
+    if (shouldPublishInboundUiNotice(inbound)) {
+      state.lastUiNotice = {
+        ts: nowIso(),
+        kind: "inbound",
+        text: formatCompactInboundUiNotice(inbound)
+      };
+    }
     appendJsonl(config.paths.inboxFile, inbound);
     appendLog(config.paths.activityFile, `IN chat=${inbound.chatId} message=${inbound.messageId} relevance=${inbound.relevance} user=${inbound.user}: ${inbound.text.replace(/\s+/g, " ").slice(0, 180)}`);
     captured += 1;
@@ -796,52 +1996,177 @@ export async function pollOnce() {
 export function listQueue(limit = 10) {
   const config = loadConfig();
   const state = loadState(config);
+  const parkedAmbient = parkExpiredAmbientQueueEntriesInPlace(config, state.queue || []);
+  if (parkedAmbient > 0) {
+    appendLog(config.paths.activityFile, `AMBIENT_PARKED count=${parkedAmbient}`);
+    saveStateForConfig(config, state);
+  }
   return state.queue.slice(-Math.max(1, limit));
 }
 
+function getQueuedDispatchPriority(item) {
+  if (!item || item.status !== "queued") {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const relevance = String(item.relevance || "").toLowerCase();
+  const chatType = String(item.chatType || "").toLowerCase();
+  if (relevance === "escalation") {
+    return 0;
+  }
+  if (isFastDispatchEntry(item)) {
+    return 1;
+  }
+  if (chatType === "private" || relevance === "direct" || relevance === "lane") {
+    return 2;
+  }
+  return 3;
+}
+
+function compareQueuedDispatchOrder(left, right) {
+  const priorityDiff = getQueuedDispatchPriority(left) - getQueuedDispatchPriority(right);
+  if (priorityDiff !== 0) {
+    return priorityDiff;
+  }
+  const leftTs = String(left?.ts || "");
+  const rightTs = String(right?.ts || "");
+  if (leftTs !== rightTs) {
+    return leftTs.localeCompare(rightTs);
+  }
+  const leftMessage = Number.parseInt(String(left?.messageId || "0"), 10);
+  const rightMessage = Number.parseInt(String(right?.messageId || "0"), 10);
+  if (Number.isFinite(leftMessage) && Number.isFinite(rightMessage) && leftMessage !== rightMessage) {
+    return leftMessage - rightMessage;
+  }
+  return String(left?.messageId || "").localeCompare(String(right?.messageId || ""));
+}
+
+function selectNextQueuedEntry(queue, options = {}) {
+  const auto = Boolean(options.auto);
+  const deferredMode = String(options.dispatchMode || "deferred").toLowerCase() !== "legacy";
+  const queued = Array.isArray(queue) ? queue.filter((item) => item?.status === "queued") : [];
+  if (!auto || !deferredMode) {
+    return queued.sort(compareQueuedDispatchOrder)[0] || null;
+  }
+  const eligible = queued.filter((item) => {
+    const relevance = String(item.relevance || "").toLowerCase();
+    const chatType = String(item.chatType || "").toLowerCase();
+    return relevance === "escalation" || chatType === "private" || relevance === "direct" || relevance === "lane";
+  });
+  return eligible.sort(compareQueuedDispatchOrder)[0] || null;
+}
+
+function isFastDispatchEntry(entry) {
+  if (!entry) {
+    return false;
+  }
+  if (String(entry.intent || "").trim().toLowerCase() === "continue_nudge") {
+    return true;
+  }
+  return false;
+}
+
 export async function injectNext(threadId, options = {}) {
   const config = loadConfig();
   const state = loadState(config);
+  const parkedAmbient = parkExpiredAmbientQueueEntriesInPlace(config, state.queue || []);
+  const runtimeOwner = getRuntimeOwner(config);
+  state.pendingReplies = reconcilePendingRepliesInPlace(state.pendingReplies || []);
+  const expiredPendingReplies = closeExpiredPendingRepliesInPlace(config, state.pendingReplies || []);
+  if (expiredPendingReplies > 0 || parkedAmbient > 0) {
+    if (parkedAmbient > 0) {
+      appendLog(config.paths.activityFile, `AMBIENT_PARKED count=${parkedAmbient}`);
+    }
+    appendLog(config.paths.activityFile, `PENDING_REPLY_EXPIRED count=${expiredPendingReplies}`);
+    saveStateForConfig(config, state);
+  }
   const auto = Boolean(options.auto);
   const useAppServer = Boolean(config.appServerWsUrl);
+  if (auto && useAppServer && runtimeOwner && !runtimeOwner.frontendAlive) {
+    appendLog(config.paths.activityFile, `OWNER_OFFLINE frontend_pid=${runtimeOwner.frontendHostPid || 0}`);
+    return {
+      ok: false,
+      status: "deferred",
+      reason: "owner_offline",
+      frontendHostPid: runtimeOwner.frontendHostPid || 0
+    };
+  }
+
+  const next = selectNextQueuedEntry(state.queue || [], {
+    auto,
+    dispatchMode: config.dispatchMode
+  });
+
+  if (!next) {
+    return {
+      ok: true,
+      status: auto ? "deferred" : "empty",
+      reason: auto ? "no_eligible_message" : undefined
+    };
+  }
+
+  if (isAddressOnlyPing(config, next.text) && !looksLikeBotSender(next)) {
+    next.status = "delivered";
+    next.deliveredAt = nowIso();
+    next.threadId = null;
+    next.turnId = null;
+    next.responsePreview = "plugin_ping_ack";
+    next.stderr = null;
+    next.stdout = null;
+    markMatchingQueueEntriesInPlace(state, next, {
+      status: next.status,
+      deliveredAt: next.deliveredAt,
+      threadId: next.threadId,
+      turnId: next.turnId,
+      responsePreview: next.responsePreview,
+      stderr: next.stderr,
+      stdout: next.stdout
+    });
+    appendLog(config.paths.activityFile, `PING_ACK chat=${next.chatId} message=${next.messageId}`);
+    await sendOutboundChunks(config, state, {
+      chatId: next.chatId,
+      text: "Ja, ich bin da.",
+      replyToMessageId: next.messageId,
+      telegramThreadId: next.telegramThreadId,
+      source: "ping_ack"
+    });
+    const latestState = loadState(config);
+    saveStateForConfig(config, mergeStateSnapshots(latestState, state));
+    return {
+      ok: true,
+      status: "delivered",
+      reason: "ping_ack",
+      message: next
+    };
+  }
+
+  const explicitThreadId = String(threadId || "").trim();
   const preferredThreadId = (
     threadId
     || (useAppServer ? config.currentThreadId : state.currentThreadId)
     || (useAppServer ? state.currentThreadId : config.currentThreadId)
     || ""
   ).trim();
-  const resolvedThreadId = await resolveActiveThreadId(config, state, preferredThreadId);
+  const resolvedThreadId = await resolveActiveThreadId(config, state, preferredThreadId, {
+    forcePreferred: Boolean(explicitThreadId)
+  });
   if (!resolvedThreadId) {
     throw new Error("No bound thread id. Use bridge_bind_current_thread first.");
   }
-
-  let next = null;
-  if (auto && String(config.dispatchMode || "deferred").toLowerCase() !== "legacy") {
-    next = state.queue.find((item) => {
-      if (item.status !== "queued") {
-        return false;
-      }
-      if (String(item.chatType || "") === "private") {
-        return true;
-      }
-      return ["direct", "lane", "escalation"].includes(String(item.relevance || ""));
-    });
-  } else {
-    next = state.queue.find((item) => item.status === "queued");
+  const staleThreadPendingReplies = closeStaleThreadPendingRepliesInPlace(state.pendingReplies || [], resolvedThreadId);
+  if (staleThreadPendingReplies > 0) {
+    appendLog(config.paths.activityFile, `PENDING_REPLY_STALE_THREAD count=${staleThreadPendingReplies} active_thread=${resolvedThreadId}`);
+    saveStateForConfig(config, state);
   }
 
-  if (!next) {
-    return {
-      ok: true,
-      status: auto ? "deferred" : "empty",
-      reason: auto ? "no_eligible_message" : undefined
-    };
+  const bypassDeferredGate = auto && (next.relevance === "escalation" || isFastDispatchEntry(next));
+  if (bypassDeferredGate && auto && isFastDispatchEntry(next)) {
+    appendLog(config.paths.activityFile, `FAST_TRIGGER_BYPASS chat=${next.chatId} message=${next.messageId} intent=${next.intent}`);
   }
-
-  const bypassDeferredGate = auto && next.relevance === "escalation";
   if (auto && !bypassDeferredGate && String(config.dispatchMode || "deferred").toLowerCase() !== "legacy") {
-    const openPendingReplies = countOpenPendingReplies(state);
+    const openPendingReplies = countOpenPendingReplies(state, config);
     if (openPendingReplies > 0) {
+      await maybeSendDeferredReceipt(config, state, next, "pending_reply");
+      saveStateForConfig(config, state);
       return {
         ok: false,
         status: "deferred",
@@ -850,14 +2175,16 @@ export async function injectNext(threadId, options = {}) {
       };
     }
 
-    const sessionActivity = await resolveSessionActivity(config, resolvedThreadId);
+    const sessionActivity = await resolveSessionActivity(config, resolvedThreadId, next);
     if (sessionActivity.active) {
+      await maybeSendDeferredReceipt(config, state, next, "session_active");
+      saveStateForConfig(config, state);
       return {
         ok: false,
         status: "deferred",
         reason: "session_active",
         quietMs: sessionActivity.quietMs,
-        readyInMs: Math.max(0, Number(config.idleCooldownMs || 0) - Number(sessionActivity.quietMs || 0))
+        readyInMs: Math.max(0, Number(sessionActivity.cooldownMs || 0) - Number(sessionActivity.quietMs || 0))
       };
     }
   }
@@ -915,8 +2242,19 @@ export async function injectNext(threadId, options = {}) {
   next.responsePreview = result.responseText.slice(0, 400);
   next.stderr = result.stderr.slice(0, 400);
   next.stdout = result.stdout.slice(0, 400);
+  markMatchingQueueEntriesInPlace(state, next, {
+    status: next.status,
+    deliveredAt: next.deliveredAt,
+    threadId: next.threadId,
+    turnId: next.turnId,
+    responsePreview: next.responsePreview,
+    stderr: next.stderr,
+    stdout: next.stdout
+  });
   if (useAppServer && result.ok) {
-    if (looksLikeBotSender(next)) {
+    if (!shouldTrackPendingReply(next)) {
+      appendLog(config.paths.activityFile, `REPLY_SKIP_CONTINUE thread=${resolvedThreadId} turn=${next.turnId || "-"} message=${next.messageId} chat=${next.chatId}`);
+    } else if (looksLikeBotSender(next)) {
       appendLog(config.paths.activityFile, `REPLY_SKIP_BOT thread=${resolvedThreadId} turn=${next.turnId || "-"} message=${next.messageId} chat=${next.chatId}`);
     } else {
       const pendingReply = buildPendingReplyEntry(next, resolvedThreadId, next.turnId, sessionPath, sessionOffset);
@@ -942,7 +2280,16 @@ export async function injectNext(threadId, options = {}) {
 export async function relayRepliesOnce() {
   const config = loadConfig();
   const state = loadState(config);
+  const parkedAmbient = parkExpiredAmbientQueueEntriesInPlace(config, state.queue || []);
   state.pendingReplies = reconcilePendingRepliesInPlace(state.pendingReplies || []);
+  const supersededPendingReplies = supersedeOlderPendingRepliesInPlace(state.pendingReplies || []);
+  closeExpiredPendingRepliesInPlace(config, state.pendingReplies || []);
+  if (parkedAmbient > 0 || supersededPendingReplies > 0) {
+    appendLog(config.paths.activityFile, `AMBIENT_PARKED count=${parkedAmbient}`);
+    if (supersededPendingReplies > 0) {
+      appendLog(config.paths.activityFile, `PENDING_REPLY_SUPERSEDED count=${supersededPendingReplies}`);
+    }
+  }
 
   for (const entry of state.pendingReplies || []) {
     if (entry.sentAt || entry.status === "error") {
@@ -956,7 +2303,7 @@ export async function relayRepliesOnce() {
     entry.responsePreview = entry.responsePreview || "[ignored bot message]";
   }
 
-  const pendingReplies = (state.pendingReplies || []).filter((entry) => !entry.sentAt && entry.status !== "error");
+  const pendingReplies = (state.pendingReplies || []).filter((entry) => isReplyAwaitingOutcome(entry));
   if (pendingReplies.length === 0) {
     saveStateForConfig(config, state);
     return { ok: true, status: "empty", delivered: 0 };
@@ -964,7 +2311,8 @@ export async function relayRepliesOnce() {
 
   let delivered = 0;
   const usedTurnIds = new Set();
-  const sessionCompletions = new Map();
+  const usedProgressKeys = new Set();
+  const sessionSignals = new Map();
 
   for (const entry of pendingReplies) {
     if (!entry.sessionPath) {
@@ -974,11 +2322,12 @@ export async function relayRepliesOnce() {
       continue;
     }
 
-    if (!sessionCompletions.has(entry.sessionPath)) {
+    if (!sessionSignals.has(entry.sessionPath)) {
       const fallbackOffset = pendingReplies
         .filter((candidate) => candidate.sessionPath === entry.sessionPath)
         .reduce((lowest, candidate) => Math.min(lowest, Number(candidate.sessionOffset || 0)), Number(entry.sessionOffset || 0));
-      const currentOffset = Number((state.replyOffsets || {})[entry.sessionPath] ?? fallbackOffset);
+      const savedOffset = Number((state.replyOffsets || {})[entry.sessionPath] ?? fallbackOffset);
+      const currentOffset = Math.min(savedOffset, fallbackOffset);
       const currentCarry = String((state.replyBuffers || {})[entry.sessionPath] || "");
       const delta = readJsonlDelta(entry.sessionPath, currentOffset, currentCarry);
       state.replyOffsets = {
@@ -997,21 +2346,128 @@ export async function relayRepliesOnce() {
           timestamp: String(item?.timestamp || "").trim()
         }))
         .filter((item) => item.message);
-      sessionCompletions.set(entry.sessionPath, completions);
+      const finalAnswers = delta.items
+        .filter((item) => item?.type === "event_msg" && item?.payload?.type === "agent_message" && String(item?.payload?.phase || "").trim().toLowerCase() === "final_answer")
+        .map((item) => ({
+          message: String(item?.payload?.message || "").trim(),
+          timestamp: String(item?.timestamp || "").trim()
+        }))
+        .filter((item) => item.message);
+      const commentaries = delta.items
+        .filter((item) => item?.type === "event_msg" && item?.payload?.type === "agent_message" && String(item?.payload?.phase || "").trim().toLowerCase() === "commentary")
+        .map((item) => ({
+          message: String(item?.payload?.message || "").trim(),
+          timestamp: String(item?.timestamp || "").trim()
+        }))
+        .filter((item) => item.message);
+      sessionSignals.set(entry.sessionPath, { completions, finalAnswers, commentaries });
+    }
+
+    const signals = sessionSignals.get(entry.sessionPath) || { completions: [], finalAnswers: [], commentaries: [] };
+    const completions = signals.completions || [];
+    const finalAnswers = signals.finalAnswers || [];
+    const commentaries = signals.commentaries || [];
+    const progressRelayMode = getProgressRelayMode(config);
+
+    if (progressRelayMode === "commentary" && !entry.progressSentAt) {
+      const progress = commentaries.find((item) => {
+        const key = `${item.timestamp}|${item.message}`;
+        return item.timestamp >= entry.createdAt && !usedProgressKeys.has(key);
+      });
+      if (progress) {
+        const outboundProgress = await sendOutboundChunks(config, state, {
+          chatId: entry.chatId,
+          text: progress.message,
+          replyToMessageId: entry.replyToMessageId,
+          telegramThreadId: entry.telegramThreadId,
+          source: "auto_progress",
+          sourceTurnId: entry.turnId || null
+        });
+        entry.progressSentAt = nowIso();
+        entry.lastSignalAt = entry.progressSentAt;
+        entry.progressMode = "commentary";
+        entry.progressPreview = progress.message.slice(0, 400);
+        entry.progressMessageIds = outboundProgress.messageIds;
+        entry.progressKey = `${progress.timestamp}|${progress.message}`;
+        usedProgressKeys.add(`${progress.timestamp}|${progress.message}`);
+        appendLog(config.paths.activityFile, `REPLY_PROGRESS_SENT thread=${entry.threadId} turn=${entry.turnId || "-"} chat=${entry.chatId} source_message=${entry.messageId} outbound=${outboundProgress.messageIds.join(",")}`);
+      }
     }
 
-    const completions = sessionCompletions.get(entry.sessionPath) || [];
+    if (progressRelayMode !== "off" && !entry.progressSentAt && shouldSendFallbackProgress(config, entry, entry.sessionPath)) {
+      const fallbackText = buildProgressFallbackText(entry);
+      const outboundProgress = await sendOutboundChunks(config, state, {
+        chatId: entry.chatId,
+        text: fallbackText,
+        replyToMessageId: entry.replyToMessageId,
+        telegramThreadId: entry.telegramThreadId,
+        source: "auto_progress",
+        sourceTurnId: entry.turnId || null
+      });
+      entry.progressSentAt = nowIso();
+      entry.lastSignalAt = entry.progressSentAt;
+      entry.progressMode = "fallback";
+      entry.progressPreview = fallbackText.slice(0, 400);
+      entry.progressMessageIds = outboundProgress.messageIds;
+      appendLog(config.paths.activityFile, `REPLY_PROGRESS_FALLBACK thread=${entry.threadId} turn=${entry.turnId || "-"} chat=${entry.chatId} source_message=${entry.messageId} outbound=${outboundProgress.messageIds.join(",")}`);
+    }
+
+    if (progressRelayMode === "commentary" && entry.progressSentAt) {
+      const upgrade = commentaries.find((item) => {
+        const key = `${item.timestamp}|${item.message}`;
+        return item.timestamp >= entry.createdAt
+          && key !== entry.progressKey
+          && !usedProgressKeys.has(key)
+          && shouldSendProgressUpgrade(entry, item);
+      });
+      if (upgrade) {
+        const outboundUpgrade = await sendOutboundChunks(config, state, {
+          chatId: entry.chatId,
+          text: upgrade.message,
+          replyToMessageId: entry.replyToMessageId,
+          telegramThreadId: entry.telegramThreadId,
+          source: "auto_progress",
+          sourceTurnId: entry.turnId || null
+        });
+        entry.progressUpgradeSentAt = nowIso();
+        entry.lastSignalAt = entry.progressUpgradeSentAt;
+        entry.progressUpgradePreview = upgrade.message.slice(0, 400);
+        entry.progressUpgradeMessageIds = outboundUpgrade.messageIds;
+        entry.progressUpgradeKey = `${upgrade.timestamp}|${upgrade.message}`;
+        usedProgressKeys.add(`${upgrade.timestamp}|${upgrade.message}`);
+        appendLog(config.paths.activityFile, `REPLY_PROGRESS_UPGRADE thread=${entry.threadId} turn=${entry.turnId || "-"} chat=${entry.chatId} source_message=${entry.messageId} outbound=${outboundUpgrade.messageIds.join(",")}`);
+      }
+    }
 
     let match = null;
+    const finalAnswer = finalAnswers.find((item) => item.timestamp >= entry.createdAt && !usedProgressKeys.has(`final|${item.timestamp}|${item.message}`));
+    if (finalAnswer) {
+      match = {
+        turnId: entry.turnId || "",
+        message: finalAnswer.message,
+        timestamp: finalAnswer.timestamp,
+        source: "final_answer"
+      };
+      usedProgressKeys.add(`final|${finalAnswer.timestamp}|${finalAnswer.message}`);
+    }
     if (entry.turnId) {
-      match = completions.find((item) => item.turnId === entry.turnId);
+      match = match || completions.find((item) => item.turnId === entry.turnId);
     } else {
-      match = completions.find((item) => item.timestamp >= entry.createdAt && !usedTurnIds.has(item.turnId));
+      match = match || completions.find((item) => item.timestamp >= entry.createdAt && !usedTurnIds.has(item.turnId));
     }
     if (!match) {
       continue;
     }
 
+    if (entry.intent === "continue_nudge" && (looksLikeAckOnly(match.message) || looksLikeContextRequestOnly(match.message))) {
+      entry.sentAt = nowIso();
+      entry.status = "suppressed_ack";
+      entry.turnId = entry.turnId || match.turnId;
+      entry.responsePreview = match.message.slice(0, 400);
+      usedTurnIds.add(match.turnId);
+      appendLog(config.paths.activityFile, `REPLY_SUPPRESSED_CONTINUE_ACK thread=${entry.threadId} turn=${entry.turnId || "-"} chat=${entry.chatId} source_message=${entry.messageId}`);
+      continue;
+    }
     const outboundResult = await sendOutboundChunks(config, state, {
       chatId: entry.chatId,
       text: match.message,
@@ -1023,8 +2479,16 @@ export async function relayRepliesOnce() {
     entry.sentAt = nowIso();
     entry.status = "sent";
     entry.turnId = entry.turnId || match.turnId;
+    entry.lastSignalAt = entry.sentAt;
     entry.responsePreview = match.message.slice(0, 400);
     entry.responseMessageIds = outboundResult.messageIds;
+    markMatchingQueueEntriesInPlace(state, entry, {
+      status: "delivered",
+      deliveredAt: entry.sentAt,
+      threadId: entry.threadId,
+      turnId: entry.turnId,
+      responsePreview: entry.responsePreview
+    });
     usedTurnIds.add(match.turnId);
     appendLog(config.paths.activityFile, `REPLY_SENT thread=${entry.threadId} turn=${entry.turnId || "-"} chat=${entry.chatId} source_message=${entry.messageId} outbound=${outboundResult.messageIds.join(",")}`);
     delivered += 1;
@@ -1036,7 +2500,7 @@ export async function relayRepliesOnce() {
     ok: true,
     status: delivered > 0 ? "sent" : "pending",
     delivered,
-    pending: (state.pendingReplies || []).filter((entry) => !entry.sentAt && entry.status !== "error").length
+    pending: (state.pendingReplies || []).filter((entry) => isNonTerminalPendingReply(entry)).length
   };
 }