@integrity-labs/agt-cli 0.27.8 → 0.27.9-test.12

package/dist/mcp/telegram-channel.js

@@ -6986,13 +6986,10 @@ __export(slack_block_kit_runtime_exports, {
   DEFAULT_ASK_USER_LIMITS: () => DEFAULT_ASK_USER_LIMITS,
   apiCall: () => apiCall,
   buildAskUserBlocks: () => buildAskUserBlocks,
-  buildRatingActionsBlock: () => buildRatingActionsBlock,
   createPendingInteraction: () => createPendingInteraction,
   decodeActionId: () => decodeActionId,
-  defaultRatingLabels: () => defaultRatingLabels,
   encodeActionId: () => encodeActionId,
   generateOptionToken: () => generateOptionToken,
-  ratingValuesForScale: () => ratingValuesForScale,
   recordSlackDelivery: () => recordSlackDelivery,
   resolveInteractive: () => resolveInteractive,
   updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
@@ -7159,22 +7156,6 @@ function buildAskUserBlocks(opts) {
     }
   ];
 }
-function ratingValuesForScale(scale) {
-  return scale === "1-5" ? [1, 2, 3, 4, 5] : [-1, 0, 1];
-}
-function defaultRatingLabels(scale) {
-  return scale === "1-5" ? ["1", "2", "3", "4", "5"] : ["\u{1F44E}", "\u{1F914}", "\u{1F44D}"];
-}
-function buildRatingActionsBlock(opts) {
-  return {
-    type: "actions",
-    elements: opts.options.map(({ label, token }) => ({
-      type: "button",
-      text: { type: "plain_text", text: label },
-      action_id: encodeActionId(opts.callbackId, token)
-    }))
-  };
-}
 async function resolveInteractive(cfg, input) {
   const res = await apiCall(cfg, "POST", "/host/interactive/resolve", {
     agent_id: cfg.agentId,
@@ -14293,13 +14274,13 @@ var StdioServerTransport = class {
 
 // src/telegram-channel.ts
 import https from "https";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import {
   createWriteStream,
   existsSync as existsSync2,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync2,
-  readdirSync,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
   renameSync as renameSync3,
   statSync,
   unlinkSync as unlinkSync3,
@@ -14307,7 +14288,7 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/channel-attachments.ts
 import { homedir } from "os";
@@ -14545,23 +14526,33 @@ var DEFAULT_THROTTLE = {
   windowMs: 12e4,
   ringSize: 8
 };
-function decideReplyThrottle(input) {
+var DEFAULT_REPLY_QUEUE_DEPTH = 2;
+function planReplyDelivery(input) {
   const cfg = input.config ?? DEFAULT_THROTTLE;
+  const maxDepth = input.maxQueueDepth ?? DEFAULT_REPLY_QUEUE_DEPTH;
   const cutoff = input.now - cfg.windowMs;
-  const inWindow = input.recentReplyTimestamps.filter((t) => t >= cutoff);
-  if (inWindow.length >= cfg.threshold) {
-    return {
-      allow: false,
-      recentCount: inWindow.length,
-      reason: "throttle_threshold_exceeded"
-    };
+  const inWindow = input.recentReplyTimestamps.filter((t) => t >= cutoff).sort((a, b) => a - b);
+  const occupancy = inWindow.length + input.queuedCount;
+  if (occupancy < cfg.threshold) {
+    return { action: "send", recentCount: inWindow.length, reason: "under_threshold" };
+  }
+  if (input.queuedCount >= maxDepth) {
+    return { action: "refuse", recentCount: inWindow.length, reason: "queue_full" };
   }
+  const idx = Math.min(input.queuedCount, inWindow.length - 1);
+  const opensAt = (inWindow[idx] ?? input.now) + cfg.windowMs;
   return {
-    allow: true,
+    action: "queue",
+    deliverAtMs: Math.max(opensAt, input.now),
     recentCount: inWindow.length,
-    reason: "under_threshold"
+    reason: "queued_for_slot"
   };
 }
+function relaxedThrottleConfig(cfg, env = process.env, envVar = "TELEGRAM_PRIVATE_REPLY_THROTTLE_COUNT") {
+  const raw = Number(env[envVar]);
+  const threshold = Number.isFinite(raw) && raw > 0 ? raw : cfg.threshold * 2;
+  return { ...cfg, threshold, ringSize: Math.max(cfg.ringSize, threshold + 2) };
+}
 var buffers = /* @__PURE__ */ new Map();
 function key(channelId, threadKey) {
   return `${channelId}
${threadKey}`;
@@ -15163,8 +15154,316 @@ function createCrossTeamPeerAuditClient(args) {
   };
 }
 
-// src/observed-chat-client.ts
+// src/diagnostic-event-client.ts
 var REQUEST_TIMEOUT_MS2 = 1e4;
+function createDiagnosticEventClient(args) {
+  if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const log = args.log ?? (() => {
+  });
+  const base = args.agtHost.replace(/\/+$/, "");
+  const agentId = args.agentId;
+  const apiKey = args.agtApiKey;
+  let cachedToken = null;
+  let cachedTokenExpiresAt = 0;
+  async function getToken() {
+    if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;
+    const resp = await fetchImpl(`${base}/host/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_key: apiKey }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`/host/exchange failed (${resp.status}): ${body.slice(0, 200)}`);
+    }
+    const data = await resp.json();
+    cachedToken = data.token;
+    cachedTokenExpiresAt = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : Date.now() + 55 * 6e4;
+    return cachedToken;
+  }
+  async function postOnce(event) {
+    const token = await getToken();
+    return fetchImpl(`${base}/host/diagnostic-command-event`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ agent_id: agentId, ...event }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+  }
+  async function emitAsync(event) {
+    try {
+      let resp = await postOnce(event);
+      if (resp.status === 401) {
+        cachedToken = null;
+        cachedTokenExpiresAt = 0;
+        resp = await postOnce(event);
+      }
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        log(
+          `diagnostic-event: POST failed (${resp.status}) outcome=${event.outcome}: ${body.slice(0, 200)}`
+        );
+      }
+    } catch (err) {
+      log(`diagnostic-event: emit threw outcome=${event.outcome}: ${err.message}`);
+    }
+  }
+  return {
+    emit(event) {
+      void emitAsync(event);
+    }
+  };
+}
+
+// src/telegram-investigate.ts
+var INVESTIGATE_SYNTAX_RE = /^\/investigate(?:[-_]([A-Za-z0-9_-]{1,64}))?(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
+function isInvestigateSyntax(text) {
+  return INVESTIGATE_SYNTAX_RE.test(text);
+}
+function classifyInvestigateText(text, opts) {
+  const m = INVESTIGATE_SYNTAX_RE.exec(text);
+  if (!m) return "ignore";
+  const codeSuffix = m[1];
+  if (codeSuffix) {
+    const normalise = (s) => s.toLowerCase().replace(/_/g, "-");
+    if (normalise(codeSuffix) !== normalise(opts.codeName)) return "ignore";
+  }
+  const botSuffix = m[2]?.toLowerCase();
+  if (!botSuffix) return "act";
+  if (!opts.botUsername) return "verification_failed";
+  return botSuffix === opts.botUsername.toLowerCase() ? "act" : "ignore";
+}
+function evaluateInvestigateGate(opts) {
+  if (opts.chatType !== "private") return { ok: false, reason: "not-dm" };
+  if (opts.diagnosticChatIds.size === 0) return { ok: false, reason: "allowlist-empty" };
+  if (!opts.senderId || !opts.diagnosticChatIds.has(opts.senderId)) {
+    return { ok: false, reason: "not-allowed" };
+  }
+  return { ok: true };
+}
+function createSingleTailSlot() {
+  let expiresAtMs = null;
+  return {
+    reserve(windowMs, nowMs = Date.now()) {
+      if (expiresAtMs !== null && expiresAtMs > nowMs) return null;
+      expiresAtMs = nowMs + windowMs;
+      return expiresAtMs;
+    },
+    remainingMs(nowMs = Date.now()) {
+      if (expiresAtMs === null) return 0;
+      return Math.max(0, expiresAtMs - nowMs);
+    },
+    release() {
+      expiresAtMs = null;
+    }
+  };
+}
+
+// src/telegram-command-registry.ts
+var HELP = {
+  command: "help",
+  description: "Show available commands"
+};
+var RESTART = {
+  command: "restart",
+  description: "Restart this agent"
+};
+var INVESTIGATE = {
+  command: "investigate",
+  description: "Live tail of this agent's terminal pane (operators only)"
+};
+function buildCommandRegistrations() {
+  return [
+    { scope: { type: "default" }, commands: [HELP, RESTART] },
+    { scope: { type: "all_private_chats" }, commands: [HELP, RESTART, INVESTIGATE] }
+  ];
+}
+
+// src/pane-tail.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { open, stat } from "fs/promises";
+
+// src/session-probe-runtime.ts
+import { execFileSync } from "child_process";
+function agentTmuxSessionName(codeName) {
+  return `agt-${codeName}`;
+}
+function escapePgrepRegex(value) {
+  return value.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&");
+}
+function probeClaudeProcessInTmux(tmuxSession) {
+  const escapedSession = escapePgrepRegex(tmuxSession);
+  const pattern = `(^|[[:space:]])--name ${escapedSession}([[:space:]]|$)`;
+  try {
+    const out = execFileSync("pgrep", ["-f", "--", pattern], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return out.length > 0 ? "alive" : "dead";
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT") return "unknown";
+    return e?.status === 1 ? "dead" : "unknown";
+  }
+}
+function probeTmuxSession(tmuxSession) {
+  try {
+    execFileSync("tmux", ["has-session", "-t", tmuxSession], {
+      stdio: "ignore",
+      timeout: 3e3
+    });
+    return "alive";
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT") return "unknown";
+    return "dead";
+  }
+}
+function probeAgentSession(codeName) {
+  const session = agentTmuxSessionName(codeName);
+  const tmux = probeTmuxSession(session);
+  const claude = tmux === "alive" ? probeClaudeProcessInTmux(session) : tmux;
+  return { tmux, claude };
+}
+var probeCache = /* @__PURE__ */ new Map();
+var SESSION_PROBE_TTL_MS = 15e3;
+function probeAgentSessionCached(codeName, ttlMs = SESSION_PROBE_TTL_MS, now = Date.now()) {
+  const cached2 = probeCache.get(codeName);
+  if (cached2 && now - cached2.at < ttlMs) return cached2.value;
+  const value = probeAgentSession(codeName);
+  probeCache.set(codeName, { at: now, value });
+  return value;
+}
+
+// src/pane-tail.ts
+var execFileAsync = promisify(execFile);
+var PANE_LOG_TAIL_BYTES = 64 * 1024;
+var TMUX_CAPTURE_TIMEOUT_MS = 2e3;
+async function capturePaneSnapshot(opts) {
+  const scrollback = opts.scrollbackLines ?? 200;
+  try {
+    const { stdout } = await execFileAsync(
+      "tmux",
+      ["capture-pane", "-p", "-t", agentTmuxSessionName(opts.codeName), "-S", `-${scrollback}`],
+      { timeout: TMUX_CAPTURE_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 }
+    );
+    return { source: "tmux", text: stdout };
+  } catch {
+  }
+  if (!opts.agentDir) return null;
+  const paneLogPath = `${opts.agentDir}/pane.log`;
+  try {
+    const tail = await readFileTail(paneLogPath, PANE_LOG_TAIL_BYTES);
+    if (tail === null) return null;
+    return { source: "pane-log", text: stripAnsi(tail) };
+  } catch {
+    return null;
+  }
+}
+async function readFileTail(path, maxBytes) {
+  const st = await stat(path);
+  if (!st.isFile()) return null;
+  const start = Math.max(0, st.size - maxBytes);
+  const length = st.size - start;
+  if (length === 0) return "";
+  const handle = await open(path, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    await handle.read(buf, 0, length, start);
+    let text = buf.toString("utf8");
+    if (start > 0) {
+      const nl = text.indexOf("\n");
+      if (nl !== -1) text = text.slice(nl + 1);
+    }
+    return text;
+  } finally {
+    await handle.close();
+  }
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-9;?<=>!]*[ -\/]*[@-~]/g, "").replace(/\x1b./g, "").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+}
+var SECRET_PATTERNS = [
+  // Augmented host API keys
+  { re: /tlk_[A-Za-z0-9]{8,}/g, label: "agt-api-key" },
+  // Slack tokens: bot/app/user/refresh/config
+  { re: /x(?:ox[abprs]|app)-[A-Za-z0-9-]{8,}/g, label: "slack-token" },
+  // JWTs (three base64url segments, first one always starts with eyJ)
+  { re: /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, label: "jwt" },
+  // OpenAI / Anthropic-style keys (sk-..., sk-ant-...)
+  { re: /sk-[A-Za-z0-9_-]{16,}/g, label: "sk-key" },
+  // AWS access key IDs
+  { re: /(?:AKIA|ASIA)[0-9A-Z]{16}/g, label: "aws-key" },
+  // GitHub tokens
+  { re: /gh[pousr]_[A-Za-z0-9]{20,}/g, label: "github-token" }
+];
+function redactPaneText(text) {
+  let out = redactAugmentedPaths(text);
+  for (const { re, label } of SECRET_PATTERNS) {
+    out = out.replace(re, `<redacted:${label}>`);
+  }
+  return out;
+}
+var DEFAULT_MAX_CHARS = 3900;
+var REFLOW_COLS = 80;
+function formatPaneSnapshot(opts) {
+  const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+  const commandName = opts.commandName ?? "/debug";
+  const header = opts.status.kind === "live" ? `\u{1F50E} Live pane tail for \`${opts.codeName}\` \u2014 captured ${opts.capturedAtLabel} \xB7 updates ~3s \xB7 expires in ${formatCountdown(opts.status.secondsRemaining)}` : `\u{1F50E} Pane tail for \`${opts.codeName}\` \u2014 captured ${opts.capturedAtLabel} \xB7 *expired* \u2014 run \`${commandName}\` to restart`;
+  const fenceOverhead = header.length + "\n```\n".length + "\n```".length + 16;
+  const contentBudget = Math.max(0, maxChars - fenceOverhead);
+  const lines = reflowLines(sanitizeForCodeBlock(opts.text), REFLOW_COLS);
+  const kept = [];
+  let used = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const cost = lines[i].length + 1;
+    if (used + cost > contentBudget) break;
+    kept.unshift(lines[i]);
+    used += cost;
+  }
+  const truncated = kept.length < lines.length;
+  const body = kept.join("\n").trimEnd();
+  const block = body.length > 0 ? `\`\`\`
+${truncated ? "\u2026\n" : ""}${body}
+\`\`\`` : "_(pane is empty)_";
+  return `${header}
+${block}`;
+}
+function formatCountdown(totalSeconds) {
+  const s = Math.max(0, Math.floor(totalSeconds));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+function sanitizeForCodeBlock(text) {
+  return text.replace(/```/g, "`\u200B`\u200B`");
+}
+function reflowLines(text, cols) {
+  const out = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.length <= cols) {
+      out.push(line);
+      continue;
+    }
+    for (let i = 0; i < line.length; i += cols) {
+      out.push(line.slice(i, i + cols));
+    }
+  }
+  const collapsed = [];
+  for (const line of out) {
+    if (line === "" && collapsed[collapsed.length - 1] === "") continue;
+    collapsed.push(line);
+  }
+  return collapsed;
+}
+
+// src/observed-chat-client.ts
+var REQUEST_TIMEOUT_MS3 = 1e4;
 function createObservedChatClient(args) {
   if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
   const fetchImpl = args.fetchImpl ?? fetch;
@@ -15182,7 +15481,7 @@ function createObservedChatClient(args) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ host_key: apiKey }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
     });
     if (!resp.ok) {
       const body = await resp.text().catch(() => "");
@@ -15199,7 +15498,7 @@ function createObservedChatClient(args) {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       body: JSON.stringify({ agent_id: agentId, ...chat }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
     });
   }
   async function emitAsync(chat) {
@@ -15246,7 +15545,7 @@ function createObservedChatClient(args) {
 }
 
 // src/conversation-ingest-client.ts
-var REQUEST_TIMEOUT_MS3 = 1e4;
+var REQUEST_TIMEOUT_MS4 = 1e4;
 function createConversationIngestClient(args) {
   if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
   const fetchImpl = args.fetchImpl ?? fetch;
@@ -15263,7 +15562,7 @@ function createConversationIngestClient(args) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ host_key: apiKey }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS4)
     });
     if (!resp.ok) {
       const body = await resp.text().catch(() => "");
@@ -15286,7 +15585,7 @@ function createConversationIngestClient(args) {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       body: JSON.stringify({ agent_id: agentId, ...payload }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS4)
     });
   }
   function refKey(payload) {
@@ -15318,7 +15617,7 @@ function createConversationIngestClient(args) {
 }
 
 // src/inbound-context-client.ts
-var REQUEST_TIMEOUT_MS4 = 1e4;
+var REQUEST_TIMEOUT_MS5 = 1e4;
 function createInboundContextClient(args) {
   if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
   const fetchImpl = args.fetchImpl ?? fetch;
@@ -15335,7 +15634,7 @@ function createInboundContextClient(args) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ host_key: apiKey }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS4)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS5)
     });
     if (!resp.ok) {
       const body = await resp.text().catch(() => "");
@@ -15352,7 +15651,7 @@ function createInboundContextClient(args) {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS4)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS5)
     });
   }
   async function emit(args2) {
@@ -15386,465 +15685,87 @@ function createInboundContextClient(args) {
   };
 }
 
-// src/progress-tools.ts
-import { randomUUID } from "crypto";
-
-// src/progress-handle.ts
-async function startProgressHandle(opts) {
-  const now = opts.now ?? (() => Date.now());
-  const setTimer = opts.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-  const clearTimer = opts.clearTimer ?? ((id) => clearTimeout(id));
-  const debounceMs = opts.debounceMs ?? 1e3;
-  const onPostTerminalUpdate = opts.onPostTerminalUpdate ?? defaultPostTerminalWarn;
-  const state = {
-    initialLabel: opts.initialLabel,
-    mode: opts.initialMode ?? "working",
-    lastChangeAt: now()
-  };
-  let lastFlushAt = 0;
-  let pendingTimer = null;
-  let inFlight = null;
-  let terminal = false;
-  async function doFlush() {
-    while (inFlight) await inFlight;
-    if (pendingTimer != null) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    lastFlushAt = now();
-    const promise = opts.flush(snapshotState());
-    inFlight = promise.then(
-      () => {
-        inFlight = null;
-      },
-      (err) => {
-        inFlight = null;
-        throw err;
-      }
-    );
-    await inFlight;
-  }
-  function snapshotState() {
-    return {
-      initialLabel: state.initialLabel,
-      mode: state.mode,
-      stepLabel: state.stepLabel,
-      stepNumber: state.stepNumber ? { ...state.stepNumber } : void 0,
-      detail: state.detail,
-      lastChangeAt: state.lastChangeAt,
-      terminal: state.terminal ? { ...state.terminal } : void 0
-    };
-  }
-  function applyUpdate(next) {
-    if (next.mode !== void 0) state.mode = next.mode;
-    if (next.stepLabel !== void 0) state.stepLabel = next.stepLabel;
-    if (next.stepNumber !== void 0) state.stepNumber = { ...next.stepNumber };
-    if (next.detail !== void 0) state.detail = next.detail;
-    state.lastChangeAt = now();
-  }
-  async function scheduleOrFlush() {
-    const elapsed = now() - lastFlushAt;
-    if (elapsed >= debounceMs) {
-      await doFlush();
-      return;
-    }
-    if (pendingTimer != null) return;
-    const remaining = debounceMs - elapsed;
-    pendingTimer = setTimer(() => {
-      pendingTimer = null;
-      void doFlush().catch(() => {
-      });
-    }, remaining);
-  }
-  lastFlushAt = now();
-  await opts.flush(snapshotState());
+// src/impersonation.ts
+var ENV_VAR = "AGT_ACT_AS_AGENT_ID";
+var OVERRIDE_ENV_VAR = "ENABLE_IMPERSONATION_CHANNELS";
+function isImpersonating() {
+  return impersonatedAgentId() !== null;
+}
+function impersonatedAgentId() {
+  const raw = process.env[ENV_VAR];
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function channelsEnabledOverride() {
+  const raw = process.env[OVERRIDE_ENV_VAR];
+  if (typeof raw !== "string") return false;
+  const trimmed = raw.trim().toLowerCase();
+  return trimmed === "1" || trimmed === "true" || trimmed === "yes" || trimmed === "on";
+}
+var IMPERSONATION_REFUSAL_CODE = "CHANNEL.IMPERSONATION_DISABLED";
+var IMPERSONATION_REFUSAL_MESSAGE = "Posting as an agent under impersonation is disabled in v0 \u2014 quit impersonation with `agt impersonate exit` to send as yourself.";
+function buildImpersonationRefusal(toolName) {
   return {
-    snapshot: snapshotState,
-    async update(next) {
-      if (terminal) {
-        const peeked = snapshotState();
-        Object.assign(peeked, {
-          mode: next.mode ?? peeked.mode,
-          stepLabel: next.stepLabel ?? peeked.stepLabel,
-          stepNumber: next.stepNumber ?? peeked.stepNumber,
-          detail: next.detail ?? peeked.detail
-        });
-        try {
-          onPostTerminalUpdate(peeked);
-        } catch (err) {
-          console.warn(
-            "[progress-handle] onPostTerminalUpdate threw \u2014 swallowed to keep update() non-throwing:",
-            err
-          );
-        }
-        return;
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: {
+            code: IMPERSONATION_REFUSAL_CODE,
+            message: IMPERSONATION_REFUSAL_MESSAGE,
+            tool: toolName
+          }
+        })
       }
-      applyUpdate(next);
-      await scheduleOrFlush();
-    },
-    async complete(summary) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "completed", message: summary };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    async fail(reason) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "failed", message: reason };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    isTerminal: () => terminal
+    ],
+    isError: true
   };
 }
-function defaultPostTerminalWarn(state) {
-  console.warn(
-    `[progress-handle] update() called after terminal transition (${state.terminal?.kind}) \u2014 ignored.`
-  );
-}
 
-// src/progress-tools.ts
-var ProgressToolRegistry = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.toolNames = {
-      start: `${opts.prefix}_progress_start`,
-      update: `${opts.prefix}_progress_update`,
-      complete: `${opts.prefix}_progress_complete`,
-      fail: `${opts.prefix}_progress_fail`
-    };
-  }
-  handles = /* @__PURE__ */ new Map();
-  toolNames;
-  /** Tool definitions to splice into the MCP ListToolsRequest response. */
-  getDefinitions() {
-    const { surfaceDescription, startArgsSchema } = this.opts;
-    const debounceMs = this.opts.debounceMs ?? 1e3;
-    const debounceText = debounceMs === 1e3 ? "per second" : `every ${debounceMs}ms`;
-    return [
-      {
-        name: this.toolNames.start,
-        description: `Post a "still working" anchor to ${surfaceDescription} and return a progress_id. The anchor message updates in place as you call ${this.toolNames.update} \u2014 operators see one message that ticks forward instead of a flood of new ones. Always end with ${this.toolNames.complete} or ${this.toolNames.fail}; otherwise the anchor lingers as "working" until the stale-state sweep flips it. Opt-in \u2014 only call this for tasks that will take more than a few seconds.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            label: {
-              type: "string",
-              description: 'Short top-line label for the task (e.g. "diagnose vigil"). Stays constant for the lifetime of this progress anchor.'
-            },
-            initial_mode: {
-              type: "string",
-              enum: ["thinking", "working", "waiting"],
-              description: 'Initial mode emoji \u2014 defaults to "working".'
-            },
-            ...startArgsSchema.properties
-          },
-          required: ["label", ...startArgsSchema.required]
-        }
-      },
-      {
-        name: this.toolNames.update,
-        description: `Update the progress anchor in place. The state machine debounces calls to one ${surfaceDescription} API call ${debounceText}, so spamming this every step is safe \u2014 only the latest pending state will paint. Any subset of fields can be passed; omitted ones retain their previous value.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string", description: "The progress_id returned from start." },
-            step_label: { type: "string", description: 'Short label for the current step (e.g. "Querying CloudWatch logs").' },
-            step_current: { type: "number", description: "1-based step counter \u2014 current." },
-            step_total: { type: "number", description: "Total steps if known. Omit for open-ended progress." },
-            mode: { type: "string", enum: ["thinking", "working", "waiting"] },
-            detail: { type: "string", description: "Free-text detail line under the step label." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.complete,
-        description: `Mark the progress anchor as \u2705 completed. Flushes any pending debounced state before painting the terminal banner \u2014 the operator never sees a stale "Step N" beside the \u2705. After this, the handle is dead; further updates are no-ops.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            summary: { type: "string", description: "Optional one-line summary of what was achieved." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.fail,
-        description: `Mark the progress anchor as \u274C failed. Always include a one-sentence reason \u2014 the operator can't tell *why* from emoji alone. Same flush-then-paint behaviour as complete.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            reason: { type: "string", description: "One-sentence failure reason." }
-          },
-          required: ["progress_id", "reason"]
-        }
-      }
-    ];
-  }
-  /**
-   * Dispatch a CallToolRequest. Returns `undefined` if the tool name
-   * isn't one of ours (so the caller can keep walking its dispatch
-   * chain). Returns a tool result otherwise.
-   */
-  async handle(name, args) {
-    if (name === this.toolNames.start) return this.handleStart(args);
-    if (name === this.toolNames.update) return this.handleUpdate(args);
-    if (name === this.toolNames.complete) return this.handleComplete(args);
-    if (name === this.toolNames.fail) return this.handleFail(args);
-    return void 0;
-  }
-  /** Live count of in-flight handles. Exposed for tests + diagnostics. */
-  size() {
-    return this.handles.size;
-  }
-  async handleStart(args) {
-    const label = typeof args.label === "string" ? args.label : null;
-    if (!label) return errResult(`${this.toolNames.start}: 'label' must be a non-empty string`);
-    if ("initial_mode" in args && !isMode(args.initial_mode)) {
-      return errResult(
-        `${this.toolNames.start}: 'initial_mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    for (const k of this.opts.startArgsSchema.required) {
-      if (typeof args[k] !== "string" || args[k].length === 0) {
-        return errResult(`${this.toolNames.start}: '${k}' must be a non-empty string`);
-      }
-    }
-    const initialMode = isMode(args.initial_mode) ? args.initial_mode : void 0;
-    const progressId = randomUUID();
-    try {
-      const flush = this.opts.createFlush(args);
-      const handle = await startProgressHandle({
-        initialLabel: label,
-        initialMode,
-        flush,
-        debounceMs: this.opts.debounceMs ?? 1e3
-      });
-      this.handles.set(progressId, handle);
-      return okResult(JSON.stringify({ progress_id: progressId }));
-    } catch (err) {
-      return errResult(`${this.toolNames.start} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleUpdate(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.update}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.update}: unknown progress_id (already terminated, or never started)`);
-    if ("mode" in args && !isMode(args.mode)) {
-      return errResult(
-        `${this.toolNames.update}: 'mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    if (typeof args.step_total === "number" && typeof args.step_current !== "number") {
-      return errResult(
-        `${this.toolNames.update}: 'step_total' requires 'step_current'`
-      );
-    }
-    const next = {};
-    if (typeof args.step_label === "string") next.stepLabel = args.step_label;
-    if (typeof args.step_current === "number") {
-      next.stepNumber = {
-        current: args.step_current,
-        ...typeof args.step_total === "number" ? { total: args.step_total } : {}
-      };
-    }
-    if (isMode(args.mode)) next.mode = args.mode;
-    if (typeof args.detail === "string") next.detail = args.detail;
-    try {
-      await handle.update(next);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.update} failed: ${err.message ?? String(err)}`);
-    }
+// src/channel-egress-tools.ts
+var TELEGRAM_EGRESS_TOOLS = /* @__PURE__ */ new Set([
+  "telegram.reply",
+  "telegram.send_message",
+  "telegram.react",
+  "channel_request_input"
+]);
+
+// src/mcp-spawn-lock.ts
+import {
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2 } from "path";
+function defaultIsPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") return false;
+    return true;
   }
-  async handleComplete(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.complete}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.complete}: unknown progress_id`);
-    const summary = typeof args.summary === "string" ? args.summary : void 0;
-    try {
-      await handle.complete(summary);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.complete} failed: ${err.message ?? String(err)}`);
+}
+function acquireMcpSpawnLock(args) {
+  const { agentDir, basename, options = {} } = args;
+  if (!agentDir) return { kind: "no-agent-dir" };
+  const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
+  const selfPid = options.selfPid ?? process.pid;
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const path = join2(agentDir, basename);
+  const existing = readLockHolder(path);
+  if (existing) {
+    if (existing.pid === selfPid) {
+      return { kind: "acquired", path };
     }
-  }
-  async handleFail(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.fail}: 'progress_id' must be a string`);
-    const reason = typeof args.reason === "string" ? args.reason : null;
-    if (!reason) return errResult(`${this.toolNames.fail}: 'reason' must be a non-empty string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.fail}: unknown progress_id`);
-    try {
-      await handle.fail(reason);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.fail} failed: ${err.message ?? String(err)}`);
-    }
-  }
-};
-function okResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function errResult(text) {
-  return { content: [{ type: "text", text }], isError: true };
-}
-function isMode(value) {
-  return value === "thinking" || value === "working" || value === "waiting";
-}
-
-// src/telegram-progress.ts
-var MODE_EMOJI = {
-  thinking: "\u{1F4AD}",
-  working: "\u{1F6E0}\uFE0F",
-  waiting: "\u23F3"
-};
-var TERMINAL_EMOJI = {
-  completed: "\u2705",
-  failed: "\u274C"
-};
-function formatWallClock(ms, timeZone) {
-  const fmt = new Intl.DateTimeFormat("en-GB", {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-    timeZone,
-    timeZoneName: "short"
-  });
-  const parts = fmt.formatToParts(new Date(ms));
-  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
-  return `${get("hour")}:${get("minute")}:${get("second")} ${get("timeZoneName")}`;
-}
-function escapeHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function renderProgressHtml(state) {
-  const lines = [];
-  if (state.terminal) {
-    const banner = state.terminal.kind === "completed" ? "Done" : "Failed";
-    lines.push(`${TERMINAL_EMOJI[state.terminal.kind]} <b>${banner}</b> \u2014 ${escapeHtml(state.initialLabel)}`);
-    if (state.terminal.message) lines.push(escapeHtml(state.terminal.message));
-    const verb = state.terminal.kind === "completed" ? "completed" : "failed";
-    lines.push(`<i>${verb}: ${formatWallClock(state.lastChangeAt)}</i>`);
-    return lines.join("\n");
-  }
-  lines.push(`${MODE_EMOJI[state.mode]} <b>Working on:</b> ${escapeHtml(state.initialLabel)}`);
-  if (state.stepNumber || state.stepLabel) {
-    const parts = [];
-    if (state.stepNumber) {
-      if (state.stepNumber.total != null) {
-        parts.push(`<b>Step ${state.stepNumber.current} of ${state.stepNumber.total}</b>`);
-      } else {
-        parts.push(`<b>Step ${state.stepNumber.current}</b>`);
-      }
-    }
-    if (state.stepLabel) parts.push(escapeHtml(state.stepLabel));
-    lines.push(parts.join(": "));
-  }
-  if (state.detail) lines.push(`<i>${escapeHtml(state.detail)}</i>`);
-  lines.push(`<i>last update: ${formatWallClock(state.lastChangeAt)}</i>`);
-  return lines.join("\n");
-}
-var TelegramApiError = class extends Error {
-  constructor(endpoint, apiError) {
-    super(`Telegram ${endpoint} failed: ${apiError}`);
-    this.endpoint = endpoint;
-    this.apiError = apiError;
-    this.name = "TelegramApiError";
-  }
-};
-function isMessageNotModified(description) {
-  if (!description) return false;
-  return /message is not modified/i.test(description);
-}
-function createTelegramProgressFlush(opts) {
-  let anchorMessageId = null;
-  return async function flush(state) {
-    const text = renderProgressHtml(state);
-    if (anchorMessageId == null) {
-      const body = {
-        chat_id: opts.chatId,
-        text,
-        parse_mode: "HTML",
-        disable_notification: true
-      };
-      if (opts.messageThreadId != null) body.message_thread_id = opts.messageThreadId;
-      if (opts.replyToMessageId != null) body.reply_to_message_id = opts.replyToMessageId;
-      const res = await opts.callImpl("sendMessage", body);
-      if (!res.ok || !res.result?.message_id) {
-        throw new TelegramApiError("sendMessage", res.description ?? "missing message_id");
-      }
-      anchorMessageId = res.result.message_id;
-      opts.onAnchorPosted?.(res.result.message_id);
-      return;
-    }
-    try {
-      const res = await opts.callImpl("editMessageText", {
-        chat_id: opts.chatId,
-        message_id: anchorMessageId,
-        text,
-        parse_mode: "HTML"
-      });
-      if (!res.ok) {
-        if (isMessageNotModified(res.description)) return;
-        throw new TelegramApiError("editMessageText", res.description ?? "unknown");
-      }
-    } catch (err) {
-      if (opts.onApiError && err instanceof TelegramApiError) {
-        await opts.onApiError(err);
-        return;
-      }
-      throw err;
-    }
-  };
-}
-
-// src/mcp-spawn-lock.ts
-import {
-  existsSync,
-  mkdirSync as mkdirSync2,
-  readFileSync,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { join as join2 } from "path";
-function defaultIsPidAlive(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "ESRCH") return false;
-    return true;
-  }
-}
-function acquireMcpSpawnLock(args) {
-  const { agentDir, basename, options = {} } = args;
-  if (!agentDir) return { kind: "no-agent-dir" };
-  const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
-  const selfPid = options.selfPid ?? process.pid;
-  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const path = join2(agentDir, basename);
-  const existing = readLockHolder(path);
-  if (existing) {
-    if (existing.pid === selfPid) {
-      return { kind: "acquired", path };
-    }
-    if (isPidAlive(existing.pid)) {
-      return { kind: "blocked", path, holder: existing };
+    if (isPidAlive(existing.pid)) {
+      return { kind: "blocked", path, holder: existing };
     }
   }
   mkdirSync2(agentDir, { recursive: true, mode: 448 });
@@ -15879,19 +15800,133 @@ function readLockHolder(path) {
   }
 }
 
+// src/ack-reaction.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
+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";
+  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 "undeliverable";
+  }
+  return "ack";
+}
+function decideRecoveryHeal(i) {
+  return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
+}
+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.";
+}
+var GIVE_UP_SIGNAL_FILENAME = "watchdog-give-up.json";
+var GIVE_UP_SIGNAL_MAX_AGE_MS = 30 * 60 * 1e3;
+function readGiveUpSignalAtMs(path, now = Date.now()) {
+  if (!path) return null;
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf8"));
+    if (typeof raw.gave_up_at !== "string") return null;
+    const t = Date.parse(raw.gave_up_at);
+    if (!Number.isFinite(t) || t > now) return null;
+    return t;
+  } catch {
+    return null;
+  }
+}
+function decideGiveUpNotice(input) {
+  const maxAge = input.maxAgeMs ?? GIVE_UP_SIGNAL_MAX_AGE_MS;
+  if (input.signalAtMs == null) return false;
+  if (input.nowMs - input.signalAtMs > maxAge) return false;
+  if (input.lastHandledAtMs != null && input.signalAtMs <= input.lastHandledAtMs) return false;
+  return true;
+}
+function giveUpNoticeText() {
+  return "\u26A0\uFE0F I couldn't read your last message \u2014 please resend it.";
+}
+function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
+  if (!dir) return null;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  let oldest = null;
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    let receivedAt;
+    try {
+      const raw = JSON.parse(readFileSync2(join3(dir, name), "utf-8"));
+      receivedAt = raw.received_at;
+    } catch {
+      continue;
+    }
+    if (!receivedAt) continue;
+    const t = Date.parse(receivedAt);
+    if (Number.isNaN(t)) continue;
+    const age = now - t;
+    if (age < 0) continue;
+    if (oldest == null || age > oldest) oldest = age;
+  }
+  return oldest;
+}
+function isPendingMarkerStale(receivedAt, nowMs, thresholdMs) {
+  if (!receivedAt) return true;
+  const t = Date.parse(receivedAt);
+  if (!Number.isFinite(t)) return true;
+  if (t > nowMs) return true;
+  return nowMs - t > thresholdMs;
+}
+function channelOrphanMarkerMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_ORPHAN_MARKER_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 30 * 6e4;
+}
+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);
+}
+
 // src/telegram-channel.ts
 function redactId(id) {
   return createHash("sha256").update(String(id)).digest("hex").slice(0, 8);
 }
 var BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 var AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME ?? "unknown";
-var TELEGRAM_AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join3(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var TELEGRAM_AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join4(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
 var AGT_HOST = process.env.AGT_HOST ?? null;
 var AGT_API_KEY = process.env.AGT_API_KEY ?? null;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID ?? null;
 var ALLOWED_CHATS = new Set(
   (process.env.TELEGRAM_ALLOWED_CHATS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
 );
+var DIAGNOSTIC_CHAT_IDS = new Set(
+  (process.env.TELEGRAM_DIAGNOSTIC_CHAT_IDS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
+);
 var PEER_CLASSIFIER_CONFIG = {
   peer_agent_mode: parsePeerAgentModeEnv(process.env.TELEGRAM_PEER_AGENT_MODE),
   peer_group_ids: parsePeerGroupIdsEnv(process.env.TELEGRAM_PEER_GROUP_IDS),
@@ -15927,6 +15962,13 @@ var crossTeamPeerAuditClient = createCrossTeamPeerAuditClient({
   log: (line) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${line}
 `)
 });
+var diagnosticEventClient = createDiagnosticEventClient({
+  agtHost: AGT_HOST,
+  agtApiKey: AGT_API_KEY,
+  agentId: process.env.AGT_AGENT_ID ?? null,
+  log: (line) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${line}
+`)
+});
 var observedChatClient = createObservedChatClient({
   agtHost: AGT_HOST,
   agtApiKey: AGT_API_KEY,
@@ -15969,9 +16011,9 @@ if (!BOT_TOKEN) {
 var stderrLogStream = null;
 if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
   try {
-    const logDir = join3(homedir2(), ".augmented", AGENT_CODE_NAME);
+    const logDir = join4(homedir2(), ".augmented", AGENT_CODE_NAME);
     mkdirSync3(logDir, { recursive: true });
-    stderrLogStream = createWriteStream(join3(logDir, "telegram-channel-stderr.log"), {
+    stderrLogStream = createWriteStream(join4(logDir, "telegram-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -16052,14 +16094,82 @@ async function setMessageReaction(chatId, messageId, emoji2) {
     );
   }
 }
-var RESTART_FLAGS_DIR = join3(homedir2(), ".augmented", "restart-flags");
+var lastUndeliverableNoticeAt = /* @__PURE__ */ new Map();
+async function notifyUndeliverable(chatId, messageId) {
+  const key2 = String(chatId);
+  const now = Date.now();
+  if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(key2), now)) return;
+  lastUndeliverableNoticeAt.set(key2, now);
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: chatId,
+        // ENG-6025: shared copy with the Slack undeliverable notice.
+        text: undeliverableNoticeText(),
+        reply_to_message_id: Number(messageId),
+        allow_sending_without_reply: true
+      },
+      1e4
+    );
+    if (!resp.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): undeliverable notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): undeliverable notice error: ${err.message}
+`
+    );
+  }
+}
+function __resetUndeliverableNoticeThrottle() {
+  lastUndeliverableNoticeAt.clear();
+}
+var lastBackOnlineNoticeAt = /* @__PURE__ */ new Map();
+function notifyBackOnline(chatId) {
+  const key2 = String(chatId);
+  const now = Date.now();
+  if (!shouldPostUndeliverableNotice(lastBackOnlineNoticeAt.get(key2), now)) return;
+  lastBackOnlineNoticeAt.set(key2, now);
+  void (async () => {
+    try {
+      const resp = await telegramApiCall(
+        "sendMessage",
+        {
+          chat_id: chatId,
+          text: "\u2705 Back online \u2014 catching up on what I missed."
+        },
+        1e4
+      );
+      if (!resp.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): back-online notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): back-online notice error: ${err.message}
+`
+      );
+    }
+  })();
+}
+function __resetBackOnlineNoticeThrottle() {
+  lastBackOnlineNoticeAt.clear();
+}
+var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
 function buildTelegramHelpMessage(codeName) {
   return [
     `\u{1F916} *Available commands for \`${codeName}\`*`,
     "",
     `_Type these in any chat where the bot is present (intercepted by the agent):_`,
     `\u2022 /help \u2014 show this help`,
-    `\u2022 /restart \u2014 restart this agent`
+    `\u2022 /restart \u2014 restart this agent`,
+    `\u2022 /investigate-${codeName} \u2014 live tail of this agent's terminal pane (DM only; team owners/admins and the agent's reports-to person)`
   ].join("\n");
 }
 async function handleHelpCommand(opts) {
@@ -16092,14 +16202,14 @@ async function handleRestartCommand(opts) {
     if (!existsSync2(RESTART_FLAGS_DIR)) {
       mkdirSync3(RESTART_FLAGS_DIR, { recursive: true });
     }
-    const flagPath = join3(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+    const flagPath = join4(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
     const flag = {
       codeName: AGENT_CODE_NAME,
       source: "telegram",
       ts: Date.now(),
       reply: { chat_id: opts.chatId, message_id: opts.messageId }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
     writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync3(tmpPath, flagPath);
     process.stderr.write(
@@ -16154,6 +16264,261 @@ async function handleRestartCommand(opts) {
     }
   }
 }
+var INVESTIGATE_TAIL_WINDOW_MS = 12e4;
+var INVESTIGATE_TAIL_INTERVAL_MS = 3e3;
+var INVESTIGATE_TAIL_MAX_CONSECUTIVE_FAILURES = 4;
+var INVESTIGATE_MAX_CHARS = 3800;
+var investigateTailSlot = createSingleTailSlot();
+function investigateAuditLog(line) {
+  process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): /investigate ${line}
+`);
+}
+function investigateNowUtcLabel() {
+  return `${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)} UTC`;
+}
+function investigateSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function classifyInvestigateCommand(text) {
+  const needsUsername = /@[A-Za-z0-9_]{1,64}(?:\s|$)/.test(text);
+  const ours = needsUsername ? await resolveBotUsername() : null;
+  return classifyInvestigateText(text, { codeName: AGENT_CODE_NAME, botUsername: ours });
+}
+async function sendInvestigateReply(chatId, messageId, text) {
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: chatId,
+        text,
+        parse_mode: "Markdown",
+        reply_to_message_id: Number(messageId)
+      },
+      1e4
+    );
+    if (!resp.ok) {
+      investigateAuditLog(`reply rejected by Telegram: ${resp.description ?? "unknown"}`);
+    }
+  } catch (err) {
+    investigateAuditLog(`reply send failed: ${redactAugmentedPaths(err.message)}`);
+  }
+}
+async function runInvestigateTailLoop(opts) {
+  const investigateCmd = `/investigate-${AGENT_CODE_NAME}`;
+  let last = opts.initialFrame;
+  let consecutiveFailures = 0;
+  let delayMs = INVESTIGATE_TAIL_INTERVAL_MS;
+  try {
+    while (Date.now() + delayMs < opts.expiresAtMs) {
+      await investigateSleep(delayMs);
+      delayMs = INVESTIGATE_TAIL_INTERVAL_MS;
+      const snapshot = await capturePaneSnapshot({
+        codeName: AGENT_CODE_NAME,
+        agentDir: TELEGRAM_AGENT_DIR
+      });
+      if (!snapshot) {
+        consecutiveFailures++;
+        if (consecutiveFailures >= INVESTIGATE_TAIL_MAX_CONSECUTIVE_FAILURES) {
+          investigateAuditLog(`tail aborted after ${consecutiveFailures} consecutive capture failures`);
+          break;
+        }
+        continue;
+      }
+      const frame = {
+        body: redactPaneText(snapshot.text),
+        source: snapshot.source,
+        capturedAtLabel: investigateNowUtcLabel()
+      };
+      if (frame.body === last.body) continue;
+      const text = formatPaneSnapshot({
+        codeName: AGENT_CODE_NAME,
+        text: frame.body,
+        source: frame.source,
+        capturedAtLabel: frame.capturedAtLabel,
+        status: {
+          kind: "live",
+          secondsRemaining: Math.max(0, Math.round((opts.expiresAtMs - Date.now()) / 1e3))
+        },
+        maxChars: INVESTIGATE_MAX_CHARS,
+        commandName: investigateCmd
+      });
+      try {
+        const resp = await telegramApiCall(
+          "editMessageText",
+          {
+            chat_id: opts.chatId,
+            message_id: opts.messageId,
+            text,
+            parse_mode: "Markdown"
+          },
+          1e4
+        );
+        if (resp.ok) {
+          last = frame;
+          consecutiveFailures = 0;
+          continue;
+        }
+        const retryAfter = resp.parameters?.retry_after;
+        if (typeof retryAfter === "number" && retryAfter > 0) {
+          delayMs = Math.max(INVESTIGATE_TAIL_INTERVAL_MS, retryAfter * 1e3);
+          continue;
+        }
+        consecutiveFailures++;
+        if (consecutiveFailures >= INVESTIGATE_TAIL_MAX_CONSECUTIVE_FAILURES) {
+          investigateAuditLog(
+            `tail aborted after ${consecutiveFailures} consecutive update failures (last: ${resp.description ?? "unknown"})`
+          );
+          break;
+        }
+      } catch (err) {
+        consecutiveFailures++;
+        if (consecutiveFailures >= INVESTIGATE_TAIL_MAX_CONSECUTIVE_FAILURES) {
+          investigateAuditLog(
+            `tail aborted after ${consecutiveFailures} consecutive update failures (last: ${redactAugmentedPaths(err.message)})`
+          );
+          break;
+        }
+      }
+    }
+  } finally {
+    investigateTailSlot.release();
+    try {
+      await telegramApiCall(
+        "editMessageText",
+        {
+          chat_id: opts.chatId,
+          message_id: opts.messageId,
+          text: formatPaneSnapshot({
+            codeName: AGENT_CODE_NAME,
+            text: last.body,
+            source: last.source,
+            capturedAtLabel: last.capturedAtLabel,
+            status: { kind: "expired" },
+            maxChars: INVESTIGATE_MAX_CHARS,
+            commandName: investigateCmd
+          }),
+          parse_mode: "Markdown"
+        },
+        1e4
+      );
+    } catch (err) {
+      investigateAuditLog(`expired-edit failed: ${redactAugmentedPaths(err.message)}`);
+    }
+  }
+}
+async function handleInvestigateCommand(opts) {
+  const investigateCmd = `/investigate-${AGENT_CODE_NAME}`;
+  const emitAudit = (outcome, reason) => {
+    diagnosticEventClient?.emit({
+      channel: "telegram",
+      command: "investigate",
+      outcome,
+      reason,
+      chat_id: opts.chatId,
+      sender_chat_id: opts.senderId
+    });
+  };
+  const verdict = evaluateInvestigateGate({
+    chatType: opts.chatType,
+    senderId: opts.senderId,
+    diagnosticChatIds: DIAGNOSTIC_CHAT_IDS
+  });
+  if (!verdict.ok) {
+    investigateAuditLog(
+      `denied reason=${verdict.reason} sender=${opts.senderId ? redactId(opts.senderId) : "unknown"}`
+    );
+    emitAudit("denied", verdict.reason);
+    const denialText = verdict.reason === "not-dm" ? `\u26A0\uFE0F \`${investigateCmd}\` only works in a direct message with \`${AGENT_CODE_NAME}\` \u2014 it shows the agent's raw terminal, so it stays 1:1. Open a DM with the bot and run it there.` : verdict.reason === "allowlist-empty" ? `\u{1F6AB} \`${investigateCmd}\` is disabled for \`${AGENT_CODE_NAME}\` \u2014 no diagnostic allowlist reached this host. It is derived from team owners/admins and the agent's reports-to person; if that's you, link your Telegram in your Augmented Team contact preferences and wait for the next refresh.` : `\u{1F6AB} \`${investigateCmd}\` denied \u2014 it's limited to team owners/admins and the person this agent reports to. If that's you, link your Telegram in your Augmented Team contact preferences and wait for the next refresh.`;
+    await sendInvestigateReply(opts.chatId, opts.messageId, denialText);
+    return;
+  }
+  const reservedExpiresAtMs = investigateTailSlot.reserve(INVESTIGATE_TAIL_WINDOW_MS);
+  if (reservedExpiresAtMs === null) {
+    const remaining = formatCountdown(investigateTailSlot.remainingMs() / 1e3);
+    investigateAuditLog(
+      `not-started reason=tail-already-running sender=${redactId(opts.senderId ?? "unknown")} remaining=${remaining}`
+    );
+    emitAudit("not_started", "tail-already-running");
+    await sendInvestigateReply(
+      opts.chatId,
+      opts.messageId,
+      `\u23F3 A \`${investigateCmd}\` tail is already running for \`${AGENT_CODE_NAME}\` (one at a time) \u2014 it expires in ${remaining}.`
+    );
+    return;
+  }
+  const snapshot = await capturePaneSnapshot({
+    codeName: AGENT_CODE_NAME,
+    agentDir: TELEGRAM_AGENT_DIR
+  });
+  if (!snapshot) {
+    investigateTailSlot.release();
+    investigateAuditLog(`not-started reason=no-pane-output sender=${redactId(opts.senderId ?? "unknown")}`);
+    emitAudit("not_started", "no-pane-output");
+    await sendInvestigateReply(
+      opts.chatId,
+      opts.messageId,
+      `\u26A0\uFE0F No pane output available for \`${AGENT_CODE_NAME}\` yet \u2014 the agent session may not have started. (If the whole host is wedged, \`${investigateCmd}\` can't reach it either \u2014 fall back to the SSM diagnostics runbook.)`
+    );
+    return;
+  }
+  investigateAuditLog(`granted sender=${redactId(opts.senderId ?? "unknown")} \u2014 starting live tail (source=${snapshot.source})`);
+  emitAudit("granted", null);
+  const initialFrame = {
+    body: redactPaneText(snapshot.text),
+    source: snapshot.source,
+    capturedAtLabel: investigateNowUtcLabel()
+  };
+  let postedMessageId = null;
+  try {
+    const posted = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: opts.chatId,
+        text: formatPaneSnapshot({
+          codeName: AGENT_CODE_NAME,
+          text: initialFrame.body,
+          source: initialFrame.source,
+          capturedAtLabel: initialFrame.capturedAtLabel,
+          status: {
+            kind: "live",
+            secondsRemaining: Math.max(0, Math.round((reservedExpiresAtMs - Date.now()) / 1e3))
+          },
+          maxChars: INVESTIGATE_MAX_CHARS,
+          commandName: investigateCmd
+        }),
+        parse_mode: "Markdown",
+        reply_to_message_id: Number(opts.messageId)
+      },
+      1e4
+    );
+    const result = posted.result;
+    if (posted.ok && typeof result?.message_id === "number") {
+      postedMessageId = result.message_id;
+    } else {
+      investigateAuditLog(`not-started reason=post-failed error=${posted.description ?? "unknown"}`);
+    }
+  } catch (err) {
+    investigateAuditLog(`not-started reason=post-failed error=${redactAugmentedPaths(err.message)}`);
+  }
+  if (postedMessageId === null) {
+    investigateTailSlot.release();
+    await sendInvestigateReply(
+      opts.chatId,
+      opts.messageId,
+      `\u274C Failed to post the pane snapshot. Try again in a moment.`
+    );
+    return;
+  }
+  void runInvestigateTailLoop({
+    chatId: opts.chatId,
+    messageId: postedMessageId,
+    initialFrame,
+    expiresAtMs: reservedExpiresAtMs
+  }).catch((err) => {
+    investigateTailSlot.release();
+    investigateAuditLog(`tail loop crashed: ${redactAugmentedPaths(err.message)}`);
+  });
+}
 var cachedBotUsername = null;
 var cachedBotId = null;
 async function refreshBotIdentity() {
@@ -16208,25 +16573,30 @@ async function classifyRestartCommand(text) {
   if (!ours) return "verification_failed";
   return target === ours ? "act" : "ignore";
 }
-var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join3(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
-var PENDING_INBOUND_DIR = AGENT_DIR ? join3(AGENT_DIR, "telegram-pending-inbound") : null;
-var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join3(AGENT_DIR, "telegram-recovery-outbox") : null;
+var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join4(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var PENDING_INBOUND_DIR = AGENT_DIR ? join4(AGENT_DIR, "telegram-pending-inbound") : null;
+var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join4(AGENT_DIR, "telegram-recovery-outbox") : null;
 function safeMarkerName(chatId, messageId) {
   const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
   return `${safe(chatId)}__${safe(messageId)}.json`;
 }
 function pendingInboundPath(chatId, messageId) {
   if (!PENDING_INBOUND_DIR) return null;
-  return join3(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
+  return join4(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
 }
-function writePendingInboundMarker(chatId, messageId, chatType) {
+function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false, payload) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !PENDING_INBOUND_DIR) return;
   const marker = {
     chat_id: chatId,
     message_id: messageId,
     chat_type: chatType,
-    received_at: (/* @__PURE__ */ new Date()).toISOString()
+    received_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Only persist the flag when set — keeps healthy-path markers byte-identical.
+    ...undeliverable ? { undeliverable: true } : {},
+    // ENG-5969: carry the replay payload only when provided (the durable-replay
+    // path). Absent ⇒ the marker can't be replayed (older / ack-only callers).
+    ...payload ? { payload } : {}
   };
   try {
     mkdirSync3(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
@@ -16238,14 +16608,28 @@ function writePendingInboundMarker(chatId, messageId, chatType) {
     );
   }
 }
-function clearPendingInboundMarker(chatId, messageId) {
-  const path = pendingInboundPath(chatId, messageId);
-  if (!path) return;
+function clearTelegramMarkerFileWithHeal(fullPath) {
+  let marker = null;
+  try {
+    marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+  } catch {
+  }
+  if (marker && decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.chat_id)
+  }) === "heal") {
+    notifyBackOnline(marker.chat_id);
+  }
   try {
-    if (existsSync2(path)) unlinkSync3(path);
+    if (existsSync2(fullPath)) unlinkSync3(fullPath);
   } catch {
   }
 }
+function clearPendingInboundMarker(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path) return;
+  clearTelegramMarkerFileWithHeal(path);
+}
 var MAX_RECOVERY_ATTEMPTS = 3;
 function nextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
@@ -16261,10 +16645,10 @@ function nextRetryName(filename) {
 async function processRecoveryOutboxFile(filename) {
   if (!RECOVERY_OUTBOX_DIR) return;
   if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
-  const fullPath = join3(RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join4(RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    const raw = readFileSync2(fullPath, "utf-8");
+    const raw = readFileSync3(fullPath, "utf-8");
     payload = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
@@ -16327,7 +16711,7 @@ async function processRecoveryOutboxFile(filename) {
   const next = nextRetryName(filename);
   if (next) {
     try {
-      renameSync3(fullPath, join3(RECOVERY_OUTBOX_DIR, next.next));
+      renameSync3(fullPath, join4(RECOVERY_OUTBOX_DIR, next.next));
       if (next.attempt >= MAX_RECOVERY_ATTEMPTS) {
         process.stderr.write(
           `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
@@ -16358,7 +16742,7 @@ function scanRecoveryRetries() {
   if (!RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync(RECOVERY_OUTBOX_DIR);
+    entries = readdirSync2(RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -16367,7 +16751,7 @@ function scanRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync(join3(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync(join4(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -16388,7 +16772,7 @@ function startRecoveryOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync(RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync2(RECOVERY_OUTBOX_DIR)) {
       if (isFirstAttemptOutboxFile(f)) void processRecoveryOutboxFile(f);
     }
   } catch {
@@ -16397,7 +16781,7 @@ function startRecoveryOutboxWatcher() {
     const watcher = watch(RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptOutboxFile(filename)) return;
-      if (existsSync2(join3(RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync2(join4(RECOVERY_OUTBOX_DIR, filename))) {
         void processRecoveryOutboxFile(filename);
       }
     });
@@ -16413,15 +16797,15 @@ function startRecoveryOutboxWatcher() {
 }
 startRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function trackPendingMessage(chatId, messageId, chatType) {
-  writePendingInboundMarker(chatId, messageId, chatType);
+function trackPendingMessage(chatId, messageId, chatType, undeliverable = false, payload) {
+  writePendingInboundMarker(chatId, messageId, chatType, undeliverable, payload);
 }
-function sweepTelegramStaleMarkersOnBoot() {
+function sweepTelegramStaleMarkers(thresholdMs) {
   if (!PENDING_INBOUND_DIR) return;
   if (!existsSync2(PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
-    filenames = readdirSync(PENDING_INBOUND_DIR);
+    filenames = readdirSync2(PENDING_INBOUND_DIR);
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): stale-marker readdir failed: ${err.message}
@@ -16434,10 +16818,10 @@ function sweepTelegramStaleMarkersOnBoot() {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join3(PENDING_INBOUND_DIR, filename);
+    const fullPath = join4(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync2(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactId(filename)}: ${err.message}
@@ -16451,31 +16835,152 @@ function sweepTelegramStaleMarkersOnBoot() {
       continue;
     }
     const { chat_id, message_id, received_at } = marker;
-    if (!chat_id || !message_id || !received_at) {
+    if (!chat_id || !message_id || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
         unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
-      continue;
     }
-    const receivedAtMs = Date.parse(received_at);
-    if (!Number.isFinite(receivedAtMs) || receivedAtMs > now || now - receivedAtMs > STALE_MARKER_MS) {
+  }
+  if (cleared > 0) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): stale-marker sweep cleared=${cleared}
+`
+    );
+  }
+}
+sweepTelegramStaleMarkers(STALE_MARKER_MS);
+var orphanSweepTimer = setInterval(() => {
+  const probe = process.env.TMUX && AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
+  const sessionAlive = probe.tmux === "alive" && probe.claude === "alive";
+  sweepTelegramStaleMarkers(sessionAlive ? channelOrphanMarkerMs() : STALE_MARKER_MS);
+  checkWatchdogGiveUpNotice();
+}, orphanSweepIntervalMs());
+orphanSweepTimer.unref?.();
+var lastGiveUpHandledAtMs = null;
+function listPendingInboundChatIds() {
+  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return [];
+  const chats = /* @__PURE__ */ new Set();
+  try {
+    for (const name of readdirSync2(PENDING_INBOUND_DIR)) {
+      if (!name.endsWith(".json")) continue;
       try {
-        unlinkSync3(fullPath);
+        const marker = JSON.parse(
+          readFileSync3(join4(PENDING_INBOUND_DIR, name), "utf8")
+        );
+        if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
       } catch {
       }
-      cleared++;
     }
+  } catch {
+    return [];
   }
-  if (cleared > 0) {
+  return [...chats];
+}
+async function notifyWatchdogGiveUp(chatId) {
+  const now = Date.now();
+  if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(chatId), now)) return;
+  lastUndeliverableNoticeAt.set(chatId, now);
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      { chat_id: chatId, text: giveUpNoticeText() },
+      1e4
+    );
+    if (!resp.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): give-up notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+      );
+      return;
+    }
     process.stderr.write(
-      `telegram-channel(${AGENT_CODE_NAME}): stale-marker sweep cleared=${cleared}
+      `telegram-channel(${AGENT_CODE_NAME}): give-up notice posted chat=${redactId(chatId)}
+`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): give-up notice error: ${err.message}
+`
+    );
+  }
+}
+function checkWatchdogGiveUpNotice() {
+  if (!AGENT_DIR) return;
+  const signalAtMs = readGiveUpSignalAtMs(join4(AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
+  const act = decideGiveUpNotice({
+    signalAtMs,
+    lastHandledAtMs: lastGiveUpHandledAtMs,
+    nowMs: Date.now()
+  });
+  if (signalAtMs != null) {
+    lastGiveUpHandledAtMs = Math.max(lastGiveUpHandledAtMs ?? 0, signalAtMs);
+  }
+  if (!act) return;
+  const chats = listPendingInboundChatIds();
+  if (chats.length === 0) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): give-up signal seen but no pending markers \u2014 nothing to notice
+`
+    );
+    return;
+  }
+  for (const chatId of chats) {
+    void notifyWatchdogGiveUp(chatId);
+  }
+}
+function __resetGiveUpNoticeStateForTests() {
+  lastGiveUpHandledAtMs = null;
+}
+var queuedReplyCounts = /* @__PURE__ */ new Map();
+function _resetQueuedReplyCountsForTests() {
+  queuedReplyCounts.clear();
+}
+async function deliverQueuedReply(p) {
+  const remaining = (queuedReplyCounts.get(p.chatId) ?? 1) - 1;
+  if (remaining <= 0) queuedReplyCounts.delete(p.chatId);
+  else queuedReplyCounts.set(p.chatId, remaining);
+  try {
+    const killed = await isThreadKilled({
+      channelType: "telegram",
+      channelId: p.chatId,
+      threadTs: "",
+      agtHost: AGT_HOST,
+      agtApiKey: AGT_API_KEY
+    });
+    if (killed) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): reply_queue_dropped reason=killed chat=${redactId(p.chatId)}
+`
+      );
+      return;
+    }
+    const body = { chat_id: p.chatId, text: p.text };
+    if (p.replyToMessageId) body.reply_to_message_id = Number(p.replyToMessageId);
+    const data = await telegramApiCall("sendMessage", body, 15e3);
+    if (!data.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): reply_queue_failed chat=${redactId(p.chatId)} error=${data.description ?? "unknown"}
+`
+      );
+      return;
+    }
+    recordReply(p.chatId, "", Date.now(), p.throttleCfg);
+    if (p.isReplyTool) {
+      clearPendingMessage(p.chatId, p.replyToMessageId);
+    }
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): reply_queue_delivered chat=${redactId(p.chatId)}
+`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): reply_queue_failed chat=${redactId(p.chatId)} error=${err.message}
 `
     );
   }
 }
-sweepTelegramStaleMarkersOnBoot();
 function clearPendingMessage(chatId, messageId) {
   if (messageId) {
     clearPendingInboundMarker(chatId, messageId);
@@ -16486,17 +16991,14 @@ function clearPendingMessage(chatId, messageId) {
   const prefix = `${safeChatId}__`;
   let filenames;
   try {
-    filenames = readdirSync(PENDING_INBOUND_DIR);
+    filenames = readdirSync2(PENDING_INBOUND_DIR);
   } catch {
     return;
   }
   for (const filename of filenames) {
     if (!filename.startsWith(prefix)) continue;
     if (!filename.endsWith(".json")) continue;
-    try {
-      unlinkSync3(join3(PENDING_INBOUND_DIR, filename));
-    } catch {
-    }
+    clearTelegramMarkerFileWithHeal(join4(PENDING_INBOUND_DIR, filename));
   }
 }
 function noteThreadActivity(chatId, messageId) {
@@ -16519,48 +17021,14 @@ var mcp = new Server(
       "CRITICAL: every response to a Telegram <channel> tag MUST go through telegram.reply with the chat_id from the tag. Text in your session WITHOUT a telegram.reply call never reaches the user.",
       'Messages from Telegram arrive as <channel source="telegram" chat_id="..." user="..." user_name="..." message_id="...">. Pass reply_to_message_id from the tag so the response lands as a quote-reply in busy chats.',
       "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call telegram.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, voice, audio, video, animations): pass file_id + chat_id verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Caption arrives as channel content. Don't surface internal file-handling errors that don't affect the answer.",
-      'For work >30s follow CLAUDE.md kanban flow: kanban.add \u2192 reply "On it \u2014 tracking here: <kanban URL>" \u2192 move to in_progress \u2192 do the work \u2192 reply with the result. Simple lookups skip kanban but still reply.',
+      'For work >30s follow CLAUDE.md kanban flow: kanban_add \u2192 reply "On it \u2014 tracking here: <kanban URL>" \u2192 move to in_progress \u2192 do the work \u2192 reply with the result. Simple lookups skip kanban but still reply.',
       "Address users by user_name; user is the numeric Telegram ID. Resolve ambiguous times against your own Timezone from CLAUDE.md \u2014 do not ask.",
-      "Reaction taxonomy (use telegram.react sparingly \u2014 prefer telegram.reply): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u{1F44D} or \u{1F389} = success. NEVER react to signal failure. On failure, telegram.reply with one sentence explaining what went wrong. Free-tier emoji: \u{1F44D} \u{1F44E} \u2764 \u{1F525} \u{1F389} \u{1F914} \u{1F92F} \u{1F64F} \u{1F44C} \u{1F440} \u{1F4AF} \u270D \u{1FAE1} \u{1F192} \u{1F973} \u{1F494}."
+      `Reaction taxonomy (use telegram.react sparingly \u2014 prefer telegram.reply): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u{1F44D} or \u{1F389} = success. NEVER react to signal failure of YOUR work. On failure, telegram.reply with one sentence explaining what went wrong. Free-tier emoji: \u{1F44D} \u{1F44E} \u2764 \u{1F525} \u{1F389} \u{1F914} \u{1F92F} \u{1F64F} \u{1F44C} \u{1F440} \u{1F4AF} \u270D \u{1FAE1} \u{1F192} \u{1F973} \u{1F494}. (If a message arrived while you were offline you may see a system-posted "can't respond right now" notice \u2014 that's the runtime, not you; don't repeat or apologise for it.)`
     ].join(" ")
   }
 );
-var TELEGRAM_PROGRESS_TIMEOUT_MS = 5e3;
-var progressRegistry = new ProgressToolRegistry({
-  prefix: "telegram",
-  surfaceDescription: "a Telegram chat",
-  startArgsSchema: {
-    properties: {
-      chat_id: {
-        type: "string",
-        description: "Telegram chat id (from the `chat_id` attribute on the inbound <channel> tag). Numeric ids are passed as strings; the API accepts both."
-      },
-      message_thread_id: {
-        type: "string",
-        description: "Forum topic id (`message_thread_id`) \u2014 pass this if the inbound arrived in a forum topic so the anchor lands in the same topic. Omit for normal chats."
-      },
-      reply_to_message_id: {
-        type: "string",
-        description: "Optional message id to thread the anchor under (typically the inbound message_id from the <channel> tag)."
-      }
-    },
-    required: ["chat_id"]
-  },
-  createFlush: (args) => {
-    const chatId = args.chat_id;
-    const threadId = typeof args.message_thread_id === "string" && args.message_thread_id.length > 0 ? Number(args.message_thread_id) : void 0;
-    const replyTo = typeof args.reply_to_message_id === "string" && args.reply_to_message_id.length > 0 ? Number(args.reply_to_message_id) : void 0;
-    return createTelegramProgressFlush({
-      chatId,
-      messageThreadId: Number.isFinite(threadId) ? threadId : void 0,
-      replyToMessageId: Number.isFinite(replyTo) ? replyTo : void 0,
-      callImpl: (method, body) => telegramApiCall(method, body, TELEGRAM_PROGRESS_TIMEOUT_MS)
-    });
-  }
-});
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
-    ...progressRegistry.getDefinitions(),
     {
       name: "channel_request_input",
       description: "Generic Yes/No or multi-choice picker. Renders as a Telegram inline keyboard; the tool blocks until the user taps an option (or the timeout elapses) and returns the resolved value. Use this when you need a structured pick rather than freeform text \u2014 e.g. confirming a draft action or disambiguating an ambiguous fork.",
@@ -16652,7 +17120,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "telegram.react",
-      description: "Add an emoji reaction to a Telegram message. Use sparingly \u2014 prefer a text reply via telegram.reply. Reaction taxonomy: \u{1F44D} or \u{1F389} = action completed successfully. NEVER react to signal failure \u2014 users can't tell why it failed from a reaction. On failure, call telegram.reply with one sentence explaining what went wrong instead. \u{1F440} is already auto-applied on inbound; do not duplicate. Only free-tier emoji reactions are available to bots (Premium-only emoji fail silently). Pass an empty string or omit emoji to clear the bot's reaction on that message.",
+      description: `Add an emoji reaction to a Telegram message. Use sparingly \u2014 prefer a text reply via telegram.reply. Reaction taxonomy: \u{1F44D} or \u{1F389} = action completed successfully. NEVER react to signal failure of your work \u2014 users can't tell why it failed from a reaction. On failure, call telegram.reply with one sentence explaining what went wrong instead. \u{1F440} is already auto-applied on inbound; do not duplicate. Only free-tier emoji reactions are available to bots (Premium-only emoji fail silently). Pass an empty string or omit emoji to clear the bot's reaction on that message. (Note: when a message arrives while the agent is offline/wedged, the runtime \u2014 not you \u2014 posts a brief "can't respond right now" notice; you never need to add a failure reaction for that.)`,
       inputSchema: {
         type: "object",
         properties: {
@@ -16676,8 +17144,9 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name, arguments: args } = req.params;
-  const progressResult = await progressRegistry.handle(name, args ?? {});
-  if (progressResult !== void 0) return progressResult;
+  if (isImpersonating() && !channelsEnabledOverride() && TELEGRAM_EGRESS_TOOLS.has(name)) {
+    return buildImpersonationRefusal(name);
+  }
   if (name === "channel_request_input") {
     return handleChannelRequestInput(args ?? {});
   }
@@ -16745,28 +17214,56 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
-    const tgThrottleCfg = configFromEnv();
+    const isPrivateChat = !chat_id.startsWith("-");
+    const tgThrottleCfg = isPrivateChat ? relaxedThrottleConfig(configFromEnv()) : configFromEnv();
     const tgThrottleNow = Date.now();
-    const tgThrottleDecision = decideReplyThrottle({
+    const tgPlan = planReplyDelivery({
       recentReplyTimestamps: getRecentReplies(chat_id, "", tgThrottleNow, tgThrottleCfg),
+      queuedCount: queuedReplyCounts.get(chat_id) ?? 0,
       now: tgThrottleNow,
       config: tgThrottleCfg
     });
-    if (!tgThrottleDecision.allow) {
+    if (tgPlan.action === "refuse") {
       process.stderr.write(
-        `telegram-channel(${AGENT_CODE_NAME}): reply_throttled chat=${redactId(chat_id)} count=${tgThrottleDecision.recentCount} window_ms=${tgThrottleCfg.windowMs} threshold=${tgThrottleCfg.threshold}
+        `telegram-channel(${AGENT_CODE_NAME}): reply_throttled chat=${redactId(chat_id)} count=${tgPlan.recentCount} queued=${queuedReplyCounts.get(chat_id) ?? 0} window_ms=${tgThrottleCfg.windowMs} threshold=${tgThrottleCfg.threshold}
 `
       );
       return {
         content: [
           {
             type: "text",
-            text: `Reply throttled: ${tgThrottleDecision.recentCount} replies from this agent to this chat within the last ${Math.round(tgThrottleCfg.windowMs / 1e3)}s (threshold ${tgThrottleCfg.threshold}). The chat is paused for this agent until a human posts in it. Stop attempting to reply.`
+            text: `Reply throttled: ${tgPlan.recentCount} replies from this agent to this chat within the last ${Math.round(tgThrottleCfg.windowMs / 1e3)}s (threshold ${tgThrottleCfg.threshold}) and the delivery queue is full. The chat is paused for this agent until a human posts in it. Stop attempting to reply.`
           }
         ],
         isError: true
       };
     }
+    if (tgPlan.action === "queue" && tgPlan.deliverAtMs !== void 0) {
+      const delayMs = Math.max(0, tgPlan.deliverAtMs - tgThrottleNow);
+      queuedReplyCounts.set(chat_id, (queuedReplyCounts.get(chat_id) ?? 0) + 1);
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): reply_queued chat=${redactId(chat_id)} delay_ms=${delayMs} count=${tgPlan.recentCount} threshold=${tgThrottleCfg.threshold}
+`
+      );
+      const timer = setTimeout(() => {
+        void deliverQueuedReply({
+          chatId: chat_id,
+          text,
+          replyToMessageId: reply_to_message_id,
+          isReplyTool: name === "telegram.reply",
+          throttleCfg: tgThrottleCfg
+        });
+      }, delayMs);
+      timer.unref();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Reply queued, not yet sent: the reply-rate window is full (${tgPlan.recentCount} recent sends, threshold ${tgThrottleCfg.threshold}). It will be delivered automatically in ~${Math.ceil(delayMs / 1e3)}s. Do not re-send this message; avoid further sends to this chat until it delivers.`
+          }
+        ]
+      };
+    }
     try {
       const body = { chat_id, text };
       if (reply_to_message_id) body.reply_to_message_id = Number(reply_to_message_id);
@@ -16877,12 +17374,12 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
 function channelRequestInputAvailable() {
   return Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
 }
-function errResult2(text) {
+function errResult(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
 async function handleChannelRequestInput(args) {
   if (!channelRequestInputAvailable()) {
-    return errResult2(
+    return errResult(
       "channel_request_input is disabled \u2014 missing AGT_HOST / AGT_API_KEY / AGT_AGENT_ID env wiring."
     );
   }
@@ -16890,12 +17387,12 @@ async function handleChannelRequestInput(args) {
   const { apiCall: apiCall2, waitForResolution: waitForResolution2, validateAskUserOptions: validateAskUserOptions2 } = runtime;
   const { thread_id, prompt_text, options, schema, request_id, timeout_seconds } = args;
   if (typeof thread_id !== "string" || !thread_id) {
-    return errResult2(
+    return errResult(
       "thread_id is required (Telegram shape: `<chat_id>` or `<chat_id>:<reply_to_message_id>`)"
     );
   }
   if (typeof prompt_text !== "string" || !prompt_text) {
-    return errResult2("prompt_text is required");
+    return errResult("prompt_text is required");
   }
   const optsValidation = validateAskUserOptions2(options, {
     maxOptions: 4,
@@ -16903,27 +17400,27 @@ async function handleChannelRequestInput(args) {
     maxValueChars: 2e3
   });
   if (!optsValidation.ok) {
-    return errResult2(
+    return errResult(
       `Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
     );
   }
   const optionsArr = options;
   if (optionsArr.length < 2) {
-    return errResult2(
+    return errResult(
       "options must contain at least 2 entries (this is a picker, not a notification)"
     );
   }
   if (!schema || typeof schema.type !== "string") {
-    return errResult2("schema is required with shape { type: 'yes_no' | 'choice' }");
+    return errResult("schema is required with shape { type: 'yes_no' | 'choice' }");
   }
   if (schema.type !== "yes_no" && schema.type !== "choice") {
-    return errResult2("schema.type must be 'yes_no' or 'choice'");
+    return errResult("schema.type must be 'yes_no' or 'choice'");
   }
   if (schema.type === "yes_no" && optionsArr.length !== 2) {
-    return errResult2("schema.type='yes_no' requires exactly 2 options");
+    return errResult("schema.type='yes_no' requires exactly 2 options");
   }
   if (request_id !== void 0 && (typeof request_id !== "string" || !request_id)) {
-    return errResult2("request_id must be a non-empty string when provided");
+    return errResult("request_id must be a non-empty string when provided");
   }
   const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
   const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
@@ -16945,10 +17442,10 @@ async function handleChannelRequestInput(args) {
     dispatchPayload = await res.json().catch(() => ({}));
     if (!res.ok || !dispatchPayload.ok || !dispatchPayload.callback_id) {
       const reason = dispatchPayload.reason ?? `http_${res.status}`;
-      return errResult2(`channel_request_input dispatch failed: ${reason}`);
+      return errResult(`channel_request_input dispatch failed: ${reason}`);
     }
   } catch (err) {
-    return errResult2(
+    return errResult(
       `channel_request_input dispatch failed: ${err.message}`
     );
   }
@@ -17097,6 +17594,73 @@ async function ackCallbackQuery(callbackQueryId, text) {
   }
 }
 await mcp.connect(new StdioServerTransport());
+var REPLAY_SCAN_INTERVAL_MS = 6e4;
+async function replayPendingTelegramMarkers() {
+  if (!channelReplayEnabled()) return;
+  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return;
+  const probe = process.env.TMUX && AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
+  const sessionAlive = probe.tmux === "alive" && probe.claude === "alive";
+  if (!sessionAlive) return;
+  let filenames;
+  try {
+    filenames = readdirSync2(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 = join4(PENDING_INBOUND_DIR, name);
+    let marker;
+    try {
+      marker = JSON.parse(readFileSync3(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;
+    }
+    try {
+      await mcp.notification({
+        method: "notifications/claude/channel",
+        params: marker.payload
+      });
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): replay push failed: ${err.message}
+`
+      );
+      continue;
+    }
+    try {
+      if (existsSync2(path)) {
+        const updated = {
+          ...marker,
+          replay_count: (marker.replay_count ?? 0) + 1
+        };
+        writeFileSync3(path, JSON.stringify(updated), { mode: 384 });
+      }
+    } catch {
+    }
+  }
+}
+var replayTimer = setInterval(() => {
+  void replayPendingTelegramMarkers();
+}, REPLAY_SCAN_INTERVAL_MS);
+replayTimer.unref?.();
 var LONG_POLL_SECONDS = 50;
 var POLL_HTTP_TIMEOUT_MS = (LONG_POLL_SECONDS + 10) * 1e3;
 var TELEGRAM_DOWNLOAD_TIMEOUT_MS = 15e3;
@@ -17262,6 +17826,35 @@ async function pollLoop() {
             } catch (err) {
               process.stderr.write(
                 `telegram-channel(${AGENT_CODE_NAME}): /restart verification-failed ack send failed: ${redactAugmentedPaths(err.message)}
+`
+              );
+            }
+          }
+          continue;
+        }
+        if (isInvestigateSyntax(trimmedContent)) {
+          const disposition = await classifyInvestigateCommand(trimmedContent);
+          if (disposition === "act") {
+            await handleInvestigateCommand({
+              chatId,
+              messageId: String(msg.message_id),
+              chatType: msg.chat.type ?? null,
+              senderId: msg.from?.id != null ? String(msg.from.id) : null
+            });
+          } else if (disposition === "verification_failed") {
+            try {
+              await telegramApiCall(
+                "sendMessage",
+                {
+                  chat_id: chatId,
+                  text: `\u274C Couldn't verify the investigate target. Please retry in a few seconds.`,
+                  reply_to_message_id: Number(msg.message_id)
+                },
+                1e4
+              );
+            } catch (err) {
+              process.stderr.write(
+                `telegram-channel(${AGENT_CODE_NAME}): /investigate verification-failed ack send failed: ${redactAugmentedPaths(err.message)}
 `
               );
             }
@@ -17370,8 +17963,29 @@ async function pollLoop() {
           }
         }
         const messageId = String(msg.message_id);
-        void setMessageReaction(chatId, messageId, ACK_EMOJI);
-        trackPendingMessage(chatId, messageId, msg.chat.type);
+        const ackProbe = process.env.TMUX && AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
+        let paneLogFreshAgeMs = null;
+        if (AGENT_DIR) {
+          try {
+            const paneMtimeMs = statSync(join4(AGENT_DIR, "pane.log")).mtimeMs;
+            paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
+          } catch {
+          }
+        }
+        const ackDecision = decideAckReaction({
+          hasTarget: Boolean(chatId && messageId),
+          integrationReady: Boolean(BOT_TOKEN),
+          tmux: ackProbe.tmux,
+          claude: ackProbe.claude,
+          withinStartupGrace: process.uptime() * 1e3 < ACK_STARTUP_GRACE_MS,
+          oldestPendingAgeMs: oldestPendingMarkerAgeMs(PENDING_INBOUND_DIR),
+          paneLogFreshAgeMs
+        });
+        if (ackDecision === "ack") {
+          void setMessageReaction(chatId, messageId, ACK_EMOJI);
+        } else if (ackDecision === "undeliverable") {
+          void notifyUndeliverable(chatId, messageId);
+        }
         const fileMeta = [];
         for (const attachment of classifiedAttachments) {
           if (attachment.kind === "image") {
@@ -17399,30 +18013,38 @@ async function pollLoop() {
         }
         const downloadedImages = fileMeta.filter((f) => f.kind === "image" && typeof f.path === "string");
         const imagePath = downloadedImages.length === 1 ? downloadedImages[0].path : void 0;
+        const channelPayload = {
+          content,
+          meta: {
+            source: "telegram",
+            chat_id: chatId,
+            chat_type: msg.chat.type,
+            message_id: messageId,
+            user: userId,
+            user_name: userName,
+            ts: String(msg.date),
+            ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
+            ...imagePath ? { image_path: imagePath } : {},
+            // ENG-4902: peer-agent ingress carries distinct framing so the
+            // runtime (MVP #5) can apply the peer-agent system preamble
+            // and store the turn under a peer_agent memory role.
+            ...peerAgentMeta ? {
+              source_role: "agent",
+              peer_code_name: peerAgentMeta.code_name,
+              peer_agent_id: peerAgentMeta.agent_id
+            } : {}
+          }
+        };
+        trackPendingMessage(
+          chatId,
+          messageId,
+          msg.chat.type,
+          ackDecision === "undeliverable",
+          channelPayload
+        );
         await mcp.notification({
           method: "notifications/claude/channel",
-          params: {
-            content,
-            meta: {
-              source: "telegram",
-              chat_id: chatId,
-              chat_type: msg.chat.type,
-              message_id: messageId,
-              user: userId,
-              user_name: userName,
-              ts: String(msg.date),
-              ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
-              ...imagePath ? { image_path: imagePath } : {},
-              // ENG-4902: peer-agent ingress carries distinct framing so the
-              // runtime (MVP #5) can apply the peer-agent system preamble
-              // and store the turn under a peer_agent memory role.
-              ...peerAgentMeta ? {
-                source_role: "agent",
-                peer_code_name: peerAgentMeta.code_name,
-                peer_agent_id: peerAgentMeta.agent_id
-              } : {}
-            }
-          }
+          params: channelPayload
         });
         conversationIngestClient?.ingest({
           channel: "telegram",
@@ -17490,6 +18112,24 @@ process.stderr.write(
   `telegram-channel(${AGENT_CODE_NAME}): started, long-polling getUpdates
 `
 );
+void (async () => {
+  for (const registration of buildCommandRegistrations()) {
+    try {
+      const resp = await telegramApiCall("setMyCommands", registration, 1e4);
+      if (!resp.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): setMyCommands(${registration.scope.type}) rejected: ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): setMyCommands(${registration.scope.type}) failed: ${redactAugmentedPaths(err.message)}
+`
+      );
+    }
+  }
+})();
 pollLoop().catch((err) => {
   process.stderr.write(
     `telegram-channel(${AGENT_CODE_NAME}): poll loop died: ${err.message}
@@ -17497,3 +18137,9 @@ pollLoop().catch((err) => {
   );
   process.exit(1);
 });
+export {
+  __resetBackOnlineNoticeThrottle,
+  __resetGiveUpNoticeStateForTests,
+  __resetUndeliverableNoticeThrottle,
+  _resetQueuedReplyCountsForTests
+};