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

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,
@@ -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) {
@@ -15506,6 +15805,7 @@ 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";
@@ -15513,6 +15813,11 @@ function decideAckReaction(i) {
   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";
@@ -15520,6 +15825,37 @@ function decideAckReaction(i) {
 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;
@@ -15547,57 +15883,32 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
   }
   return oldest;
 }
-
-// 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;
+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
@@ -15613,6 +15924,9 @@ 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),
@@ -15648,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,
@@ -15773,20 +16094,19 @@ async function setMessageReaction(chatId, messageId, emoji2) {
     );
   }
 }
-var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
 var lastUndeliverableNoticeAt = /* @__PURE__ */ new Map();
 async function notifyUndeliverable(chatId, messageId) {
   const key2 = String(chatId);
   const now = Date.now();
-  const last = lastUndeliverableNoticeAt.get(key2);
-  if (last != null && now - last < UNDELIVERABLE_NOTICE_THROTTLE_MS) return;
+  if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(key2), now)) return;
   lastUndeliverableNoticeAt.set(key2, now);
   try {
     const resp = await telegramApiCall(
       "sendMessage",
       {
         chat_id: chatId,
-        text: "\u26A0\uFE0F I can't respond right now \u2014 I'll follow up once I'm back.",
+        // ENG-6025: shared copy with the Slack undeliverable notice.
+        text: undeliverableNoticeText(),
         reply_to_message_id: Number(messageId),
         allow_sending_without_reply: true
       },
@@ -15812,8 +16132,7 @@ var lastBackOnlineNoticeAt = /* @__PURE__ */ new Map();
 function notifyBackOnline(chatId) {
   const key2 = String(chatId);
   const now = Date.now();
-  const last = lastBackOnlineNoticeAt.get(key2);
-  if (last != null && now - last < UNDELIVERABLE_NOTICE_THROTTLE_MS) return;
+  if (!shouldPostUndeliverableNotice(lastBackOnlineNoticeAt.get(key2), now)) return;
   lastBackOnlineNoticeAt.set(key2, now);
   void (async () => {
     try {
@@ -15849,7 +16168,8 @@ function buildTelegramHelpMessage(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) {
@@ -15944,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() {
@@ -16009,7 +16584,7 @@ function pendingInboundPath(chatId, messageId) {
   if (!PENDING_INBOUND_DIR) return null;
   return join4(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
 }
-function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false) {
+function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false, payload) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !PENDING_INBOUND_DIR) return;
   const marker = {
@@ -16018,7 +16593,10 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
     chat_type: chatType,
     received_at: (/* @__PURE__ */ new Date()).toISOString(),
     // Only persist the flag when set — keeps healthy-path markers byte-identical.
-    ...undeliverable ? { undeliverable: true } : {}
+    ...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 });
@@ -16219,10 +16797,10 @@ function startRecoveryOutboxWatcher() {
 }
 startRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function trackPendingMessage(chatId, messageId, chatType, undeliverable = false) {
-  writePendingInboundMarker(chatId, messageId, chatType, undeliverable);
+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;
@@ -16257,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);
@@ -16515,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);
@@ -16867,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;
@@ -17032,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)}
 `
               );
             }
@@ -17141,20 +17964,28 @@ async function pollLoop() {
         }
         const messageId = String(msg.message_id);
         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)
+          oldestPendingAgeMs: oldestPendingMarkerAgeMs(PENDING_INBOUND_DIR),
+          paneLogFreshAgeMs
         });
         if (ackDecision === "ack") {
           void setMessageReaction(chatId, messageId, ACK_EMOJI);
         } else if (ackDecision === "undeliverable") {
           void notifyUndeliverable(chatId, messageId);
         }
-        trackPendingMessage(chatId, messageId, msg.chat.type, ackDecision === "undeliverable");
         const fileMeta = [];
         for (const attachment of classifiedAttachments) {
           if (attachment.kind === "image") {
@@ -17182,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",
@@ -17273,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}
@@ -17282,5 +18139,7 @@ pollLoop().catch((err) => {
 });
 export {
   __resetBackOnlineNoticeThrottle,
-  __resetUndeliverableNoticeThrottle
+  __resetGiveUpNoticeStateForTests,
+  __resetUndeliverableNoticeThrottle,
+  _resetQueuedReplyCountsForTests
 };