@integrity-labs/agt-cli 0.27.7-test.6 → 0.27.8-test.8

package/dist/mcp/telegram-channel.js

@@ -14293,13 +14293,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 +14307,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";
@@ -15386,430 +15386,6 @@ 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());
-  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;
-      }
-      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
-  };
-}
-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)}`);
-    }
-  }
-  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)}`);
-    }
-  }
-  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/impersonation.ts
 var ENV_VAR = "AGT_ACT_AS_AGENT_ID";
 var OVERRIDE_ENV_VAR = "ENABLE_IMPERSONATION_CHANNELS";
@@ -15925,13 +15501,112 @@ 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;
+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) {
+    return "undeliverable";
+  }
+  return "ack";
+}
+function decideRecoveryHeal(i) {
+  return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
+}
+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;
+}
+
+// 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/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;
@@ -16015,9 +15690,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
     });
@@ -16098,7 +15773,76 @@ async function setMessageReaction(chatId, messageId, emoji2) {
     );
   }
 }
-var RESTART_FLAGS_DIR = join3(homedir2(), ".augmented", "restart-flags");
+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;
+  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.",
+        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();
+  const last = lastBackOnlineNoticeAt.get(key2);
+  if (last != null && now - last < UNDELIVERABLE_NOTICE_THROTTLE_MS) 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}\`*`,
@@ -16138,14 +15882,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(
@@ -16254,25 +15998,27 @@ 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) {
   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 } : {}
   };
   try {
     mkdirSync3(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
@@ -16284,14 +16030,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$/);
@@ -16307,10 +16067,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(
@@ -16373,7 +16133,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}
@@ -16404,7 +16164,7 @@ function scanRecoveryRetries() {
   if (!RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync(RECOVERY_OUTBOX_DIR);
+    entries = readdirSync2(RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -16413,7 +16173,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;
     }
@@ -16434,7 +16194,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 {
@@ -16443,7 +16203,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);
       }
     });
@@ -16459,15 +16219,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) {
+  writePendingInboundMarker(chatId, messageId, chatType, undeliverable);
 }
 function sweepTelegramStaleMarkersOnBoot() {
   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}
@@ -16480,10 +16240,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}
@@ -16532,17 +16292,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) {
@@ -16567,46 +16324,12 @@ var mcp = new Server(
       "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.',
       "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.",
@@ -16698,7 +16421,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: {
@@ -16725,8 +16448,6 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   if (isImpersonating() && !channelsEnabledOverride() && TELEGRAM_EGRESS_TOOLS.has(name)) {
     return buildImpersonationRefusal(name);
   }
-  const progressResult = await progressRegistry.handle(name, args ?? {});
-  if (progressResult !== void 0) return progressResult;
   if (name === "channel_request_input") {
     return handleChannelRequestInput(args ?? {});
   }
@@ -16926,12 +16647,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."
     );
   }
@@ -16939,12 +16660,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,
@@ -16952,27 +16673,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));
@@ -16994,10 +16715,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}`
     );
   }
@@ -17419,8 +17140,21 @@ 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" };
+        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)
+        });
+        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") {
@@ -17546,3 +17280,7 @@ pollLoop().catch((err) => {
   );
   process.exit(1);
 });
+export {
+  __resetBackOnlineNoticeThrottle,
+  __resetUndeliverableNoticeThrottle
+};