@integrity-labs/agt-cli 0.27.170 → 0.28.2

package/dist/mcp/slack-channel.js

@@ -14452,7 +14452,7 @@ function watchSuccessTextSlack(fileId, durationMs, reused) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { readdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
 
 // src/flags-cache-read.ts
@@ -14498,19 +14498,23 @@ var ACK_STARTUP_GRACE_MS = 6e4;
 var ACK_PANE_FRESH_THRESHOLD_MS = 6e4;
 function decideAckReaction(i) {
   if (!i.hasTarget) return "none";
-  if (!i.integrationReady) return "undeliverable";
-  if (i.tmux === "dead") return "undeliverable";
-  if (!i.withinStartupGrace && i.claude === "dead") return "undeliverable";
+  return classifyUndeliverableCause(i) !== null ? "undeliverable" : "ack";
+}
+function classifyUndeliverableCause(i) {
+  if (!i.hasTarget) return null;
+  if (!i.integrationReady) return "integration_down";
+  if (i.tmux === "dead") return "session_dead";
+  if (!i.withinStartupGrace && i.claude === "dead") return "session_dead";
   const threshold = i.pendingStaleThresholdMs ?? REPLY_WEDGED_THRESHOLD_MS;
   if (i.oldestPendingAgeMs != null && i.oldestPendingAgeMs > threshold) {
     const paneFreshThreshold = i.paneFreshThresholdMs ?? ACK_PANE_FRESH_THRESHOLD_MS;
     const paneIsFresh = i.paneLogFreshAgeMs != null && i.paneLogFreshAgeMs <= paneFreshThreshold;
     if (paneIsFresh && i.tmux === "alive" && i.claude === "alive") {
-      return "ack";
+      return null;
     }
-    return "undeliverable";
+    return "wedged";
   }
-  return "ack";
+  return null;
 }
 function decideRecoveryHeal(i) {
   return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
@@ -14521,8 +14525,8 @@ var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
 function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
   return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
 }
-function undeliverableNoticeText() {
-  return "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+function undeliverableNoticeText(replayEnabled = channelReplayEnabled()) {
+  return replayEnabled ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
 }
 var BUSY_ACK_THRESHOLD_MS = 9e4;
 var BUSY_ACK_NOTICE_THROTTLE_MS = 10 * 60 * 1e3;
@@ -14617,6 +14621,37 @@ var ORPHAN_SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
 function orphanSweepIntervalMs() {
   return Math.max(6e4, Math.min(ORPHAN_SWEEP_INTERVAL_MS, channelOrphanMarkerMs()));
 }
+var MAX_MARKER_REPLAYS = 3;
+function channelReplayEnabled() {
+  const v = process.env.AGT_CHANNEL_REPLAY_ENABLED;
+  return v === "1" || v === "true";
+}
+function shouldReplayMarker(i) {
+  if (!i.enabled) return false;
+  if (!i.hasPayload) return false;
+  if (!i.sessionAlive) return false;
+  if (i.markerAgeMs < (i.minAgeMs ?? REPLY_WEDGED_THRESHOLD_MS)) return false;
+  return i.replayCount < (i.maxReplays ?? MAX_MARKER_REPLAYS);
+}
+var DEFLECTION_COUNTER_SUFFIX = "-deflections.json";
+function deflectionCounterPath(agentDir, channel) {
+  return join2(agentDir, `${channel}${DEFLECTION_COUNTER_SUFFIX}`);
+}
+function recordChannelDeflection(agentDir, channel, cause) {
+  if (!agentDir) return;
+  const path = deflectionCounterPath(agentDir, channel);
+  let counts = {};
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (parsed && typeof parsed === "object") counts = parsed;
+  } catch {
+  }
+  counts[cause] = (counts[cause] ?? 0) + 1;
+  try {
+    writeFileSync(path, JSON.stringify(counts), { mode: 384 });
+  } catch {
+  }
+}
 
 // src/session-probe-runtime.ts
 import { execFileSync } from "child_process";
@@ -15253,7 +15288,7 @@ function resolveReplyThreadTs(input) {
 }
 
 // src/restart-confirm.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
 import { randomUUID } from "crypto";
 var RESTART_CONFIRM_MAX_AGE_MS = 10 * 60 * 1e3;
@@ -15273,7 +15308,7 @@ function writeRestartConfirmMarker(filePath, marker) {
   const dir = dirname(filePath);
   if (!existsSync4(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(tmpPath, JSON.stringify(marker) + "\n", { encoding: "utf8", mode: 384 });
+  writeFileSync2(tmpPath, JSON.stringify(marker) + "\n", { encoding: "utf8", mode: 384 });
   renameSync(tmpPath, filePath);
 }
 function readRestartConfirmMarker(filePath) {
@@ -15388,23 +15423,27 @@ var StdioServerTransport = class {
 // src/slack-channel.ts
 import {
   chmodSync,
+  closeSync,
   createWriteStream,
   existsSync as existsSync7,
+  ftruncateSync,
   mkdirSync as mkdirSync5,
+  openSync,
   readFileSync as readFileSync8,
   readdirSync as readdirSync3,
   renameSync as renameSync3,
   statSync as statSync2,
   unlinkSync as unlinkSync4,
   watch,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6,
+  writeSync
 } from "fs";
 import { basename, join as join7, resolve as resolve2 } from "path";
 import { homedir as homedir3 } from "os";
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 
 // src/slack-thread-store.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 var FILE_VERSION = 1;
 var DEFAULT_TTL_DAYS = 30;
@@ -15464,7 +15503,7 @@ function createThreadPersister(opts) {
   const writeNow = (snap) => {
     try {
       mkdirSync2(dirname2(opts.filePath), { recursive: true });
-      writeFileSync2(opts.filePath, serializeThreadStore(snap), "utf-8");
+      writeFileSync3(opts.filePath, serializeThreadStore(snap), "utf-8");
       lastWriteAt = Date.now();
     } catch (err) {
       opts.onError?.(
@@ -15533,7 +15572,7 @@ async function runOrRetry(fn, opts) {
 }
 
 // src/slack-bot-photo.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname3 } from "path";
 async function applyBotPhoto(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
@@ -15585,7 +15624,7 @@ async function applyBotPhoto(opts) {
     if (markerPath) {
       try {
         mkdirSync3(dirname3(markerPath), { recursive: true, mode: 448 });
-        writeFileSync3(markerPath, avatarUrl, { mode: 384 });
+        writeFileSync4(markerPath, avatarUrl, { mode: 384 });
       } catch {
       }
     }
@@ -16341,7 +16380,7 @@ import {
   readFileSync as readFileSync7,
   renameSync as renameSync2,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { join as join6 } from "path";
 function defaultIsPidAlive(pid) {
@@ -16374,7 +16413,7 @@ function acquireMcpSpawnLock(args) {
   mkdirSync4(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync4(tmpPath, JSON.stringify(payload), { mode: 384 });
+  writeFileSync5(tmpPath, JSON.stringify(payload), { mode: 384 });
   renameSync2(tmpPath, path);
   return { kind: "acquired", path };
 }
@@ -16608,7 +16647,7 @@ function slackPendingInboundPath(channel, threadTs, messageTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return null;
   return join7(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
 }
-function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false, discretionary = false) {
+function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false, discretionary = false, payload) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !SLACK_PENDING_INBOUND_DIR) return;
   const marker = {
@@ -16618,11 +16657,14 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
     received_at: (/* @__PURE__ */ new Date()).toISOString(),
     // Only persist the flags when set — keeps healthy-path markers byte-identical.
     ...undeliverable ? { undeliverable: true } : {},
-    ...discretionary ? { discretionary: true } : {}
+    ...discretionary ? { discretionary: true } : {},
+    // ENG-5969/ENG-6327: carry the replay payload only when provided (the
+    // durable-replay path). Absent ⇒ the marker can't be replayed.
+    ...payload ? { payload } : {}
   };
   try {
     mkdirSync5(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync5(path, JSON.stringify(marker), { mode: 384 });
+    writeFileSync6(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -16630,6 +16672,35 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
     );
   }
 }
+function rewriteSlackMarkerInPlace(path, marker) {
+  let fd;
+  try {
+    fd = openSync(path, "r+");
+    const buf = Buffer.from(JSON.stringify(marker));
+    ftruncateSync(fd, 0);
+    writeSync(fd, buf, 0, buf.length, 0);
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function attachSlackReplayPayload(channel, threadTs, messageTs, payload) {
+  const path = slackPendingInboundPath(channel, threadTs, messageTs);
+  if (!path) return;
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync8(path, "utf-8"));
+  } catch {
+    return;
+  }
+  marker.payload = payload;
+  rewriteSlackMarkerInPlace(path, marker);
+}
 function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !existsSync7(path)) return null;
@@ -16743,7 +16814,14 @@ function scheduleBusyAck(channel, threadTs, messageTs, isThreadReply) {
       paneLogFreshAgeMs,
       thresholdMs
     });
-    if (post) postBusyAckNotice(channel, threadTs, isThreadReply);
+    if (post) {
+      recordChannelDeflection(SLACK_AGENT_DIR, "slack", "busy");
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): [channel-deflection] cause=busy channel=slack ts=${redactSlackId(messageTs)}
+`
+      );
+      postBusyAckNotice(channel, threadTs, isThreadReply);
+    }
   }, thresholdMs);
   timer.unref();
 }
@@ -16967,8 +17045,8 @@ function startSlackRecoveryOutboxWatcher() {
 startSlackRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
 var DISCRETIONARY_MARKER_MS = 10 * 60 * 1e3;
-function trackPendingMessage(channel, threadTs, messageTs, undeliverable = false, discretionary = false) {
-  writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable, discretionary);
+function trackPendingMessage(channel, threadTs, messageTs, undeliverable = false, discretionary = false, payload) {
+  writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable, discretionary, payload);
 }
 function sweepSlackStaleMarkers(thresholdMs) {
   if (!SLACK_PENDING_INBOUND_DIR) return;
@@ -17684,7 +17762,7 @@ async function handleSlashCommandEnvelope(payload) {
         }
       };
       const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-      writeFileSync5(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+      writeFileSync6(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync3(tmpPath, flagPath);
       process.stderr.write(
         `slack-channel(${codeName}): /restart slash-command queued from channel ${hashChannelId(payload.channel_id)}
@@ -17803,7 +17881,7 @@ async function handleRestartCommand(opts) {
       }
     };
     const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-    writeFileSync5(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    writeFileSync6(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync3(tmpPath, flagPath);
     process.stderr.write(
       `slack-channel(${codeName}): /restart queued from channel ${hashChannelId(opts.channel)}
@@ -19164,7 +19242,7 @@ async function downloadSlackFile(fileId, codeName) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
   mkdirSync5(dir, { recursive: true });
-  writeFileSync5(savedPath, bytes, { mode: 384 });
+  writeFileSync6(savedPath, bytes, { mode: 384 });
   try {
     chmodSync(savedPath, 384);
   } catch {
@@ -19216,6 +19294,77 @@ async function buildInboundFileMeta(rawFiles, codeName, channel) {
   return out;
 }
 await mcp.connect(new StdioServerTransport());
+var SLACK_REPLAY_SCAN_INTERVAL_MS = 6e4;
+async function replayPendingSlackMarkers() {
+  if (!channelReplayEnabled()) return;
+  if (!SLACK_PENDING_INBOUND_DIR || !existsSync7(SLACK_PENDING_INBOUND_DIR)) return;
+  const probe = process.env.TMUX && AGENT_CODE_NAME ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
+  const sessionAlive = probe.tmux === "alive" && probe.claude === "alive";
+  if (!sessionAlive) return;
+  let filenames;
+  try {
+    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  const entries = [];
+  for (const name of filenames) {
+    if (!name.endsWith(".json") || name.endsWith(".tmp")) continue;
+    const fullPath = join7(SLACK_PENDING_INBOUND_DIR, name);
+    let marker;
+    try {
+      marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+    } catch {
+      continue;
+    }
+    const t = Date.parse(marker.received_at ?? "");
+    const ageMs = Number.isFinite(t) ? now - t : 0;
+    entries.push({ path: fullPath, marker, ageMs });
+  }
+  entries.sort((a, b) => b.ageMs - a.ageMs);
+  for (const { path, marker, ageMs } of entries) {
+    if (!shouldReplayMarker({
+      enabled: true,
+      hasPayload: Boolean(marker.payload),
+      sessionAlive,
+      markerAgeMs: ageMs,
+      replayCount: marker.replay_count ?? 0
+    })) {
+      continue;
+    }
+    const payload = marker.payload;
+    const replayParams = {
+      ...payload,
+      meta: { ...payload.meta, replayed: "true" }
+    };
+    try {
+      await mcp.notification({
+        method: "notifications/claude/channel",
+        params: replayParams
+      });
+    } catch (err) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): replay push failed: ${err.message}
+`
+      );
+      continue;
+    }
+    rewriteSlackMarkerInPlace(path, {
+      ...marker,
+      replay_count: (marker.replay_count ?? 0) + 1
+    });
+  }
+}
+var slackReplayScanInFlight = false;
+var slackReplayTimer = setInterval(() => {
+  if (slackReplayScanInFlight) return;
+  slackReplayScanInFlight = true;
+  void replayPendingSlackMarkers().finally(() => {
+    slackReplayScanInFlight = false;
+  });
+}, SLACK_REPLAY_SCAN_INTERVAL_MS);
+slackReplayTimer.unref?.();
 var userNameCache = /* @__PURE__ */ new Map();
 async function resolveUserName(userId) {
   if (!userId || userId === "unknown") return userId ?? "unknown";
@@ -19530,7 +19679,7 @@ async function connectSocketMode() {
         } catch {
         }
       }
-      const ackDecision = decideAckReaction({
+      const ackInputs = {
         hasTarget: decideSlackAckReaction({ channel, ts }),
         integrationReady: Boolean(BOT_TOKEN),
         tmux: ackProbe.tmux,
@@ -19538,7 +19687,16 @@ async function connectSocketMode() {
         withinStartupGrace: process.uptime() * 1e3 < ACK_STARTUP_GRACE_MS,
         oldestPendingAgeMs: oldestPendingMarkerAgeMs(SLACK_PENDING_INBOUND_DIR),
         paneLogFreshAgeMs
-      });
+      };
+      const ackDecision = decideAckReaction(ackInputs);
+      if (ackDecision === "undeliverable") {
+        const cause = classifyUndeliverableCause(ackInputs) ?? "unknown";
+        recordChannelDeflection(SLACK_AGENT_DIR, "slack", cause);
+        process.stderr.write(
+          `slack-channel(${AGENT_CODE_NAME}): [channel-deflection] cause=${cause} channel=slack ts=${redactSlackId(ts)}
+`
+        );
+      }
       if (ackDecision !== "none") {
         const reactionName = ackDecision === "undeliverable" ? SLACK_UNDELIVERABLE_REACTION : "eyes";
         fetch("https://slack.com/api/reactions.add", {
@@ -19596,32 +19754,36 @@ async function connectSocketMode() {
 `
         );
       }
+      const replayPayload = {
+        content: inboundContent,
+        meta: {
+          user,
+          user_name: userName,
+          channel,
+          thread_ts: threadTs,
+          // ENG-5861: explicit message_ts so the agent can pass it back
+          // to slack.reply for reliable pending-inbound cleanup. For
+          // top-level messages threadTs === ts; for threaded replies
+          // threadTs is the thread root and message_ts is the specific
+          // reply being addressed — different keys, both needed by the
+          // marker-cleanup gate.
+          message_ts: ts,
+          event_type: evt.type,
+          ...isAutoFollowed ? { auto_followed: "true" } : {},
+          // Only set these when we actually have attachments to avoid
+          // bloating every notification with empty metadata.
+          ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
+          ...imagePath ? { image_path: imagePath } : {},
+          // ENG-5830: the pre-loaded surrounding thread (thread replies only).
+          ...threadContext ? { thread_context: threadContext } : {}
+        }
+      };
+      if (channel && ts && armMarker) {
+        attachSlackReplayPayload(channel, threadTs, ts, replayPayload);
+      }
       await mcp.notification({
         method: "notifications/claude/channel",
-        params: {
-          content: inboundContent,
-          meta: {
-            user,
-            user_name: userName,
-            channel,
-            thread_ts: threadTs,
-            // ENG-5861: explicit message_ts so the agent can pass it back
-            // to slack.reply for reliable pending-inbound cleanup. For
-            // top-level messages threadTs === ts; for threaded replies
-            // threadTs is the thread root and message_ts is the specific
-            // reply being addressed — different keys, both needed by the
-            // marker-cleanup gate.
-            message_ts: ts,
-            event_type: evt.type,
-            ...isAutoFollowed ? { auto_followed: "true" } : {},
-            // Only set these when we actually have attachments to avoid
-            // bloating every notification with empty metadata.
-            ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
-            ...imagePath ? { image_path: imagePath } : {},
-            // ENG-5830: the pre-loaded surrounding thread (thread replies only).
-            ...threadContext ? { thread_context: threadContext } : {}
-          }
-        }
+        params: replayPayload
       });
       if (channel) {
         conversationIngestClient?.ingest({

package/dist/mcp/telegram-channel.js

@@ -14317,16 +14317,20 @@ var StdioServerTransport = class {
 import https from "https";
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 import {
+  closeSync,
   createWriteStream,
   existsSync as existsSync5,
+  ftruncateSync,
   mkdirSync as mkdirSync4,
+  openSync,
   readFileSync as readFileSync7,
   readdirSync as readdirSync3,
   renameSync as renameSync4,
   statSync as statSync2,
   unlinkSync as unlinkSync4,
   watch,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5,
+  writeSync
 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join7 } from "path";
@@ -16107,7 +16111,7 @@ function readLockHolder(path) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { join as join6 } from "path";
 
 // src/flags-cache-read.ts
@@ -16153,19 +16157,23 @@ var ACK_STARTUP_GRACE_MS = 6e4;
 var ACK_PANE_FRESH_THRESHOLD_MS = 6e4;
 function decideAckReaction(i) {
   if (!i.hasTarget) return "none";
-  if (!i.integrationReady) return "undeliverable";
-  if (i.tmux === "dead") return "undeliverable";
-  if (!i.withinStartupGrace && i.claude === "dead") return "undeliverable";
+  return classifyUndeliverableCause(i) !== null ? "undeliverable" : "ack";
+}
+function classifyUndeliverableCause(i) {
+  if (!i.hasTarget) return null;
+  if (!i.integrationReady) return "integration_down";
+  if (i.tmux === "dead") return "session_dead";
+  if (!i.withinStartupGrace && i.claude === "dead") return "session_dead";
   const threshold = i.pendingStaleThresholdMs ?? REPLY_WEDGED_THRESHOLD_MS;
   if (i.oldestPendingAgeMs != null && i.oldestPendingAgeMs > threshold) {
     const paneFreshThreshold = i.paneFreshThresholdMs ?? ACK_PANE_FRESH_THRESHOLD_MS;
     const paneIsFresh = i.paneLogFreshAgeMs != null && i.paneLogFreshAgeMs <= paneFreshThreshold;
     if (paneIsFresh && i.tmux === "alive" && i.claude === "alive") {
-      return "ack";
+      return null;
     }
-    return "undeliverable";
+    return "wedged";
   }
-  return "ack";
+  return null;
 }
 function decideRecoveryHeal(i) {
   return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
@@ -16174,8 +16182,8 @@ var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
 function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
   return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
 }
-function undeliverableNoticeText() {
-  return "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+function undeliverableNoticeText(replayEnabled = channelReplayEnabled()) {
+  return replayEnabled ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
 }
 var BUSY_ACK_THRESHOLD_MS = 9e4;
 var BUSY_ACK_NOTICE_THROTTLE_MS = 10 * 60 * 1e3;
@@ -16282,6 +16290,25 @@ function shouldReplayMarker(i) {
   if (i.markerAgeMs < (i.minAgeMs ?? REPLY_WEDGED_THRESHOLD_MS)) return false;
   return i.replayCount < (i.maxReplays ?? MAX_MARKER_REPLAYS);
 }
+var DEFLECTION_COUNTER_SUFFIX = "-deflections.json";
+function deflectionCounterPath(agentDir, channel) {
+  return join6(agentDir, `${channel}${DEFLECTION_COUNTER_SUFFIX}`);
+}
+function recordChannelDeflection(agentDir, channel, cause) {
+  if (!agentDir) return;
+  const path = deflectionCounterPath(agentDir, channel);
+  let counts = {};
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    if (parsed && typeof parsed === "object") counts = parsed;
+  } catch {
+  }
+  counts[cause] = (counts[cause] ?? 0) + 1;
+  try {
+    writeFileSync4(path, JSON.stringify(counts), { mode: 384 });
+  } catch {
+  }
+}
 
 // src/telegram-channel.ts
 function redactId(id) {
@@ -16590,7 +16617,14 @@ function scheduleBusyAck(chatId, messageId) {
       paneLogFreshAgeMs,
       thresholdMs
     });
-    if (post) postBusyAckNotice(chatId, messageId);
+    if (post) {
+      recordChannelDeflection(AGENT_DIR, "telegram", "busy");
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): [channel-deflection] cause=busy channel=telegram chat=${redactId(chatId)}
+`
+      );
+      postBusyAckNotice(chatId, messageId);
+    }
   }, thresholdMs);
   timer.unref();
 }
@@ -16802,7 +16836,7 @@ async function handleRestartCommand(opts) {
       reply: { chat_id: opts.chatId, message_id: opts.messageId }
     };
     const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-    writeFileSync4(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    writeFileSync5(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync4(tmpPath, flagPath);
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): /restart queued from chat ${redactId(opts.chatId)}
@@ -17202,7 +17236,7 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
   };
   try {
     mkdirSync4(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync4(path, JSON.stringify(marker), { mode: 384 });
+    writeFileSync5(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -17210,6 +17244,23 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
     );
   }
 }
+function rewriteTelegramMarkerInPlace(path, marker) {
+  let fd;
+  try {
+    fd = openSync(path, "r+");
+    const buf = Buffer.from(JSON.stringify(marker));
+    ftruncateSync(fd, 0);
+    writeSync(fd, buf, 0, buf.length, 0);
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
 function clearTelegramMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
@@ -18232,10 +18283,15 @@ async function replayPendingTelegramMarkers() {
     })) {
       continue;
     }
+    const replayPayload = marker.payload;
+    const replayParams = {
+      ...replayPayload,
+      meta: { ...replayPayload.meta, replayed: "true" }
+    };
     try {
       await mcp.notification({
         method: "notifications/claude/channel",
-        params: marker.payload
+        params: replayParams
       });
     } catch (err) {
       process.stderr.write(
@@ -18244,20 +18300,19 @@ async function replayPendingTelegramMarkers() {
       );
       continue;
     }
-    try {
-      if (existsSync5(path)) {
-        const updated = {
-          ...marker,
-          replay_count: (marker.replay_count ?? 0) + 1
-        };
-        writeFileSync4(path, JSON.stringify(updated), { mode: 384 });
-      }
-    } catch {
-    }
+    rewriteTelegramMarkerInPlace(path, {
+      ...marker,
+      replay_count: (marker.replay_count ?? 0) + 1
+    });
   }
 }
+var telegramReplayScanInFlight = false;
 var replayTimer = setInterval(() => {
-  void replayPendingTelegramMarkers();
+  if (telegramReplayScanInFlight) return;
+  telegramReplayScanInFlight = true;
+  void replayPendingTelegramMarkers().finally(() => {
+    telegramReplayScanInFlight = false;
+  });
 }, REPLAY_SCAN_INTERVAL_MS);
 replayTimer.unref?.();
 var LONG_POLL_SECONDS = 50;
@@ -18626,7 +18681,7 @@ async function pollLoop() {
           } catch {
           }
         }
-        const ackDecision = decideAckReaction({
+        const ackInputs = {
           hasTarget: Boolean(chatId && messageId),
           integrationReady: Boolean(BOT_TOKEN),
           tmux: ackProbe.tmux,
@@ -18634,7 +18689,16 @@ async function pollLoop() {
           withinStartupGrace: process.uptime() * 1e3 < ACK_STARTUP_GRACE_MS,
           oldestPendingAgeMs: oldestPendingMarkerAgeMs(PENDING_INBOUND_DIR),
           paneLogFreshAgeMs
-        });
+        };
+        const ackDecision = decideAckReaction(ackInputs);
+        if (ackDecision === "undeliverable") {
+          const cause = classifyUndeliverableCause(ackInputs) ?? "unknown";
+          recordChannelDeflection(AGENT_DIR, "telegram", cause);
+          process.stderr.write(
+            `telegram-channel(${AGENT_CODE_NAME}): [channel-deflection] cause=${cause} channel=telegram chat=${redactId(chatId)}
+`
+          );
+        }
         if (ackDecision === "ack") {
           void setMessageReaction(chatId, messageId, ACK_EMOJI);
         } else if (ackDecision === "undeliverable") {