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

package/dist/mcp/telegram-channel.js

@@ -14180,6 +14180,47 @@ var Server = class extends Protocol {
   }
 };
 
+// src/restart-confirm.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+var RESTART_CONFIRM_MAX_AGE_MS = 10 * 60 * 1e3;
+function shouldPostRestartConfirm(marker, processBootMs, nowMs) {
+  if (!marker) return false;
+  const requestedAt = marker.requested_at;
+  if (typeof requestedAt !== "number" || !Number.isFinite(requestedAt)) return false;
+  if (requestedAt >= processBootMs) return false;
+  if (nowMs - requestedAt > RESTART_CONFIRM_MAX_AGE_MS) return false;
+  return true;
+}
+function buildBackOnlineText(name) {
+  const trimmed = typeof name === "string" ? name.trim() : "";
+  return trimmed ? `Hey ${trimmed}, I'm back online after my restart. \u{1F7E2}` : `I'm back online after my restart. \u{1F7E2}`;
+}
+function writeRestartConfirmMarker(filePath, marker) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(marker) + "\n", { encoding: "utf8", mode: 384 });
+  renameSync(tmpPath, filePath);
+}
+function readRestartConfirmMarker(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearRestartConfirmMarker(filePath) {
+  try {
+    if (existsSync(filePath)) unlinkSync(filePath);
+  } catch {
+  }
+}
+
 // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "process";
 
@@ -14274,21 +14315,21 @@ var StdioServerTransport = class {
 
 // src/telegram-channel.ts
 import https from "https";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import {
   createWriteStream,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync2,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   statSync,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   watch,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/channel-attachments.ts
 import { homedir } from "os";
@@ -14412,7 +14453,7 @@ function redactAugmentedPaths(msg) {
 }
 
 // src/telegram-attachments.ts
-import { mkdirSync, writeFileSync, chmodSync, renameSync, unlinkSync } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
 function resolveTelegramInboundDir(codeName) {
   return resolveChannelInboundDir(codeName, "telegram-inbound");
 }
@@ -14501,18 +14542,18 @@ async function downloadTelegramFile(fileId, opts) {
   if (!isPathInside(savedPath, dir)) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
-  mkdirSync(dir, { recursive: true });
+  mkdirSync2(dir, { recursive: true });
   const tempPath = `${savedPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync(tempPath, bytes, { mode: 384, flag: "wx" });
+    writeFileSync2(tempPath, bytes, { mode: 384, flag: "wx" });
     try {
       chmodSync(tempPath, 384);
     } catch {
     }
-    renameSync(tempPath, savedPath);
+    renameSync2(tempPath, savedPath);
   } catch (err) {
     try {
-      unlinkSync(tempPath);
+      unlinkSync2(tempPath);
     } catch {
     }
     throw err;
@@ -14772,6 +14813,61 @@ function parsePeerAgentModeEnv(raw) {
   return "off";
 }
 
+// src/sender-policy-decline.ts
+function politeDeclineCopy(reason) {
+  switch (reason) {
+    case "internal_only":
+      return "Sorry, I can only respond to people inside our organisation. This conversation appears to be from outside.";
+    case "mode_manager_only":
+      return "Sorry, I only respond to my manager in this channel.";
+    case "mode_team_only":
+      return "Sorry, this agent only replies to its team members.";
+    case "mode_team_agents_only":
+      return "Sorry, I only respond to agents on my team in this channel.";
+    case "mode_agents_only":
+      return "Sorry, I only respond to other agents in this channel.";
+  }
+}
+
+// src/inbound-access.ts
+function decideInboundAccess(input) {
+  if (!input.content.forward) {
+    return { kind: "drop", reason: `content:${input.content.reason}` };
+  }
+  if (input.isSelf) {
+    return { kind: "drop", reason: "self" };
+  }
+  if (input.orgBoundary && !input.orgBoundary.forward) {
+    return { kind: "drop", reason: "org_boundary" };
+  }
+  if (input.senderPolicy && !input.senderPolicy.forward) {
+    const reason = input.senderPolicy.reason;
+    const declineWorthy = input.sameOrg && reason !== "internal_only";
+    return {
+      kind: "drop",
+      reason: `sender_policy:${reason}`,
+      decline: declineWorthy ? politeDeclineCopy(reason) : void 0
+    };
+  }
+  if (input.command && !input.isBot) {
+    return {
+      kind: "command",
+      command: input.command.command,
+      authorized: input.command.authorized
+    };
+  }
+  if (input.isBot) {
+    const peer = input.peer;
+    if (!peer || peer.kind === "self") {
+      return { kind: "drop", reason: peer?.kind === "self" ? "self" : "peer:unclassified" };
+    }
+    if (peer.kind === "drop") {
+      return { kind: "drop", reason: `peer:${peer.reason ?? "unspecified"}` };
+    }
+  }
+  return { kind: "admit" };
+}
+
 // src/telegram-peer-rate-limiter.ts
 var SECOND_MS = 1e3;
 var MINUTE_MS = 60 * SECOND_MS;
@@ -15269,6 +15365,10 @@ var HELP = {
   command: "help",
   description: "Show available commands"
 };
+var STATUS = {
+  command: "status",
+  description: "Show this agent\u2019s model, session origin + uptime"
+};
 var RESTART = {
   command: "restart",
   description: "Restart this agent"
@@ -15279,11 +15379,86 @@ var INVESTIGATE = {
 };
 function buildCommandRegistrations() {
   return [
-    { scope: { type: "default" }, commands: [HELP, RESTART] },
-    { scope: { type: "all_private_chats" }, commands: [HELP, RESTART, INVESTIGATE] }
+    { scope: { type: "default" }, commands: [HELP, STATUS, RESTART] },
+    { scope: { type: "all_private_chats" }, commands: [HELP, STATUS, RESTART, INVESTIGATE] }
   ];
 }
 
+// src/agent-config-state.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var SESSION_STATE_FILENAME = "session-state.json";
+function readAgentSessionState(stateDir) {
+  if (!stateDir) return null;
+  const path = join2(stateDir, SESSION_STATE_FILENAME);
+  if (!existsSync2(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function describeSessionOrigin(source) {
+  switch (source) {
+    case "startup":
+      return "fresh start";
+    case "resume":
+      return "resumed";
+    case "clear":
+      return "cleared (/clear)";
+    case "compact":
+      return "compacted";
+    default:
+      return "unknown";
+  }
+}
+function formatModelLabel(model) {
+  const trimmed = model?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : "unknown";
+}
+function shortSessionId(id) {
+  const trimmed = id?.trim();
+  if (!trimmed) return "unknown";
+  return trimmed.length > 8 ? trimmed.slice(0, 8) : trimmed;
+}
+function formatRelativeAge(ts, now = Date.now()) {
+  if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) return "unknown";
+  const seconds = Math.floor((now - ts) / 1e3);
+  if (seconds < 0) return "unknown";
+  if (seconds < 5) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+function formatChannels(channels) {
+  if (!Array.isArray(channels) || channels.length === 0) return "unknown";
+  const cleaned = channels.map((c) => String(c).trim()).filter((c) => c.length > 0);
+  return cleaned.length > 0 ? cleaned.join(", ") : "unknown";
+}
+function buildAgentConfigReport(opts) {
+  const { codeName, connectivityLine, state, now = Date.now() } = opts;
+  const lines = [`\u{1F916} *Config for \`${codeName}\`*`, connectivityLine];
+  if (!state) {
+    lines.push("\u2022 *Model:* unknown \u2014 session state not recorded yet");
+    lines.push("\u2022 *Session:* unknown");
+    return lines.join("\n");
+  }
+  lines.push(`\u2022 *Model:* \`${formatModelLabel(state.model)}\``);
+  const origin = describeSessionOrigin(state.source);
+  const age = formatRelativeAge(state.recorded_at, now);
+  const sessionLine = age === "unknown" ? `\u2022 *Session:* ${origin}` : `\u2022 *Session:* ${origin} \xB7 started ${age}`;
+  lines.push(sessionLine);
+  lines.push(`\u2022 *Session ID:* \`${shortSessionId(state.session_id)}\``);
+  if (state.environment && state.environment.trim().length > 0) {
+    lines.push(`\u2022 *Environment:* ${state.environment.trim()}`);
+  }
+  lines.push(`\u2022 *Channels:* ${formatChannels(state.channels)}`);
+  return lines.join("\n");
+}
+
 // src/pane-tail.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -15733,14 +15908,14 @@ var TELEGRAM_EGRESS_TOOLS = /* @__PURE__ */ new Set([
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync,
-  mkdirSync as mkdirSync2,
-  readFileSync,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function defaultIsPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -15758,7 +15933,7 @@ function acquireMcpSpawnLock(args) {
   const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
   const selfPid = options.selfPid ?? process.pid;
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const path = join2(agentDir, basename);
+  const path = join3(agentDir, basename);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -15768,11 +15943,11 @@ function acquireMcpSpawnLock(args) {
       return { kind: "blocked", path, holder: existing };
     }
   }
-  mkdirSync2(agentDir, { recursive: true, mode: 448 });
+  mkdirSync3(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync2(tmpPath, JSON.stringify(payload), { mode: 384 });
-  renameSync2(tmpPath, path);
+  writeFileSync3(tmpPath, JSON.stringify(payload), { mode: 384 });
+  renameSync3(tmpPath, path);
   return { kind: "acquired", path };
 }
 function releaseMcpSpawnLock(lockPath, opts = {}) {
@@ -15782,14 +15957,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync2(lockPath);
+    unlinkSync3(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
-  if (!existsSync(path)) return null;
+  if (!existsSync3(path)) return null;
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
     const pid = typeof parsed.pid === "number" ? parsed.pid : Number(parsed.pid);
     if (!Number.isFinite(pid) || pid <= 0) return null;
@@ -15801,8 +15976,8 @@ function readLockHolder(path) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
 var ACK_STARTUP_GRACE_MS = 6e4;
 var ACK_PANE_FRESH_THRESHOLD_MS = 6e4;
@@ -15832,12 +16007,35 @@ function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDEL
 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 BUSY_ACK_THRESHOLD_MS = 9e4;
+var BUSY_ACK_NOTICE_THROTTLE_MS = 10 * 60 * 1e3;
+function channelBusyAckEnabled() {
+  const v = process.env.AGT_CHANNEL_BUSY_ACK_ENABLED;
+  return v === "1" || v === "true";
+}
+function channelBusyAckThresholdMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_BUSY_ACK_THRESHOLD_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : BUSY_ACK_THRESHOLD_MS;
+}
+function decideBusyAck(i) {
+  if (!i.hasTarget) return false;
+  if (!i.stillPending) return false;
+  if (!Number.isFinite(i.pendingAgeMs)) return false;
+  const threshold = i.thresholdMs ?? channelBusyAckThresholdMs();
+  if (i.pendingAgeMs < threshold) return false;
+  if (!i.sessionAlive) return false;
+  const paneFreshThreshold = i.paneFreshThresholdMs ?? ACK_PANE_FRESH_THRESHOLD_MS;
+  return i.paneLogFreshAgeMs != null && i.paneLogFreshAgeMs <= paneFreshThreshold;
+}
+function busyAckNoticeText() {
+  return "\u{1F6E0}\uFE0F I'm in the middle of something right now \u2014 I'll follow up on this as soon as I'm free.";
+}
 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"));
+    const raw = JSON.parse(readFileSync4(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;
@@ -15869,7 +16067,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
     if (!name.endsWith(".json")) continue;
     let receivedAt;
     try {
-      const raw = JSON.parse(readFileSync2(join3(dir, name), "utf-8"));
+      const raw = JSON.parse(readFileSync4(join4(dir, name), "utf-8"));
       receivedAt = raw.received_at;
     } catch {
       continue;
@@ -15917,7 +16115,7 @@ function redactId(id) {
 }
 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" ? join4(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var TELEGRAM_AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join5(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;
@@ -16011,9 +16209,9 @@ if (!BOT_TOKEN) {
 var stderrLogStream = null;
 if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
   try {
-    const logDir = join4(homedir2(), ".augmented", AGENT_CODE_NAME);
-    mkdirSync3(logDir, { recursive: true });
-    stderrLogStream = createWriteStream(join4(logDir, "telegram-channel-stderr.log"), {
+    const logDir = join5(homedir2(), ".augmented", AGENT_CODE_NAME);
+    mkdirSync4(logDir, { recursive: true });
+    stderrLogStream = createWriteStream(join5(logDir, "telegram-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -16161,13 +16359,138 @@ function notifyBackOnline(chatId) {
 function __resetBackOnlineNoticeThrottle() {
   lastBackOnlineNoticeAt.clear();
 }
-var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
+var lastBusyAckNoticeAt = /* @__PURE__ */ new Map();
+function postBusyAckNotice(chatId, messageId) {
+  const key2 = String(chatId);
+  const now = Date.now();
+  if (!shouldPostUndeliverableNotice(lastBusyAckNoticeAt.get(key2), now, BUSY_ACK_NOTICE_THROTTLE_MS)) {
+    return;
+  }
+  lastBusyAckNoticeAt.set(key2, now);
+  void (async () => {
+    try {
+      const resp = await telegramApiCall(
+        "sendMessage",
+        {
+          chat_id: chatId,
+          text: busyAckNoticeText(),
+          reply_to_message_id: Number(messageId),
+          allow_sending_without_reply: true
+        },
+        1e4
+      );
+      if (!resp.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): busy-ack notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): busy-ack notice error: ${err.message}
+`
+      );
+    }
+  })();
+}
+function scheduleBusyAck(chatId, messageId) {
+  if (!channelBusyAckEnabled()) return;
+  const thresholdMs = channelBusyAckThresholdMs();
+  const timer = setTimeout(() => {
+    const probe = 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(join5(AGENT_DIR, "pane.log")).mtimeMs;
+        paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
+      } catch {
+      }
+    }
+    const marker = readPendingInboundMarker(chatId, messageId);
+    if (!marker) return;
+    const post = decideBusyAck({
+      hasTarget: Boolean(chatId && messageId),
+      stillPending: true,
+      pendingAgeMs: Math.max(0, Date.now() - Date.parse(marker.received_at)),
+      sessionAlive: probe.tmux === "alive" && probe.claude === "alive",
+      paneLogFreshAgeMs,
+      thresholdMs
+    });
+    if (post) postBusyAckNotice(chatId, messageId);
+  }, thresholdMs);
+  timer.unref();
+}
+function __resetBusyAckNoticeThrottle() {
+  lastBusyAckNoticeAt.clear();
+}
+var RESTART_FLAGS_DIR = join5(homedir2(), ".augmented", "restart-flags");
+function writeTelegramRestartConfirm(reply, requesterName) {
+  if (!RESTART_CONFIRM_FILE) return;
+  const marker = {
+    source: "telegram",
+    requested_at: Date.now(),
+    ...requesterName ? { requester_name: requesterName } : {},
+    reply
+  };
+  try {
+    writeRestartConfirmMarker(RESTART_CONFIRM_FILE, marker);
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): restart-confirm marker write failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+  }
+}
+async function notifyRestartCompleteOnBoot() {
+  if (!RESTART_CONFIRM_FILE) return;
+  const marker = readRestartConfirmMarker(RESTART_CONFIRM_FILE);
+  if (!shouldPostRestartConfirm(marker, TELEGRAM_PROCESS_BOOT_MS, Date.now())) {
+    if (marker) clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+    return;
+  }
+  const chatId = marker.reply["chat_id"];
+  if (chatId == null) {
+    clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+    return;
+  }
+  const messageId = marker.reply["message_id"];
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: chatId,
+        text: buildBackOnlineText(marker.requester_name),
+        // Thread under the original /restart command when we have its id.
+        ...messageId != null ? { reply_to_message_id: Number(messageId), allow_sending_without_reply: true } : {}
+      },
+      1e4
+    );
+    if (resp.ok) {
+      clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): posted back-online confirmation after restart
+`
+      );
+    } else {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): back-online confirmation rejected (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): back-online confirmation send failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+  }
+}
 function buildTelegramHelpMessage(codeName) {
   return [
     `\u{1F916} *Available commands for \`${codeName}\`*`,
     "",
     `_Type these in any chat where the bot is present (intercepted by the agent):_`,
     `\u2022 /help \u2014 show this help`,
+    `\u2022 /status \u2014 this agent's model, session origin, uptime + connectivity`,
     `\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");
@@ -16197,21 +16520,58 @@ async function handleHelpCommand(opts) {
     );
   }
 }
+function buildTelegramStatusReply() {
+  const state = readAgentSessionState(TELEGRAM_AGENT_DIR);
+  return buildAgentConfigReport({
+    codeName: AGENT_CODE_NAME,
+    connectivityLine: "\u{1F7E2} *online* \u2014 Telegram channel connected.",
+    state
+  });
+}
+async function handleStatusCommand(opts) {
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: opts.chatId,
+        text: buildTelegramStatusReply(),
+        parse_mode: "Markdown",
+        reply_to_message_id: Number(opts.messageId)
+      },
+      1e4
+    );
+    if (!resp.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): /status reply rejected by Telegram (chat ${redactId(opts.chatId)}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): /status reply send failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+  }
+}
 async function handleRestartCommand(opts) {
   try {
-    if (!existsSync2(RESTART_FLAGS_DIR)) {
-      mkdirSync3(RESTART_FLAGS_DIR, { recursive: true });
+    if (!existsSync4(RESTART_FLAGS_DIR)) {
+      mkdirSync4(RESTART_FLAGS_DIR, { recursive: true });
     }
-    const flagPath = join4(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+    const flagPath = join5(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+    writeTelegramRestartConfirm(
+      { chat_id: opts.chatId, message_id: opts.messageId },
+      opts.requesterName
+    );
     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}.${randomUUID()}.tmp`;
-    writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
-    renameSync3(tmpPath, flagPath);
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    writeFileSync4(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    renameSync4(tmpPath, flagPath);
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): /restart queued from chat ${redactId(opts.chatId)}
 `
@@ -16561,6 +16921,10 @@ var HELP_SYNTAX_RE = /^\/help(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
 function isHelpSyntax(text) {
   return HELP_SYNTAX_RE.test(text);
 }
+var STATUS_SYNTAX_RE = /^\/status(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
+function isStatusSyntax(text) {
+  return STATUS_SYNTAX_RE.test(text);
+}
 function isRestartSyntax(text) {
   return RESTART_SYNTAX_RE.test(text);
 }
@@ -16573,16 +16937,18 @@ async function classifyRestartCommand(text) {
   if (!ours) return "verification_failed";
   return target === ours ? "act" : "ignore";
 }
-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;
+var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join5(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var PENDING_INBOUND_DIR = AGENT_DIR ? join5(AGENT_DIR, "telegram-pending-inbound") : null;
+var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join5(AGENT_DIR, "telegram-recovery-outbox") : null;
+var RESTART_CONFIRM_FILE = AGENT_DIR ? join5(AGENT_DIR, "telegram-restart-confirm.json") : null;
+var TELEGRAM_PROCESS_BOOT_MS = Date.now();
 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 join4(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
+  return join5(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
 }
 function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false, payload) {
   const path = pendingInboundPath(chatId, messageId);
@@ -16599,8 +16965,8 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
     ...payload ? { payload } : {}
   };
   try {
-    mkdirSync3(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync3(path, JSON.stringify(marker), { mode: 384 });
+    mkdirSync4(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync4(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -16611,7 +16977,7 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
 function clearTelegramMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -16621,7 +16987,7 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
     notifyBackOnline(marker.chat_id);
   }
   try {
-    if (existsSync2(fullPath)) unlinkSync3(fullPath);
+    if (existsSync4(fullPath)) unlinkSync4(fullPath);
   } catch {
   }
 }
@@ -16630,6 +16996,15 @@ function clearPendingInboundMarker(chatId, messageId) {
   if (!path) return;
   clearTelegramMarkerFileWithHeal(path);
 }
+function readPendingInboundMarker(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path || !existsSync4(path)) return null;
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
 var MAX_RECOVERY_ATTEMPTS = 3;
 function nextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
@@ -16645,10 +17020,10 @@ function nextRetryName(filename) {
 async function processRecoveryOutboxFile(filename) {
   if (!RECOVERY_OUTBOX_DIR) return;
   if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
-  const fullPath = join4(RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join5(RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    const raw = readFileSync3(fullPath, "utf-8");
+    const raw = readFileSync5(fullPath, "utf-8");
     payload = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
@@ -16656,7 +17031,7 @@ async function processRecoveryOutboxFile(filename) {
 `
     );
     try {
-      renameSync3(fullPath, `${fullPath}.parse-error.poison`);
+      renameSync4(fullPath, `${fullPath}.parse-error.poison`);
     } catch {
     }
     return;
@@ -16667,7 +17042,7 @@ async function processRecoveryOutboxFile(filename) {
 `
     );
     try {
-      renameSync3(fullPath, `${fullPath}.malformed.poison`);
+      renameSync4(fullPath, `${fullPath}.malformed.poison`);
     } catch {
     }
     return;
@@ -16703,7 +17078,7 @@ async function processRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync3(fullPath);
+      unlinkSync4(fullPath);
     } catch {
     }
     return;
@@ -16711,7 +17086,7 @@ async function processRecoveryOutboxFile(filename) {
   const next = nextRetryName(filename);
   if (next) {
     try {
-      renameSync3(fullPath, join4(RECOVERY_OUTBOX_DIR, next.next));
+      renameSync4(fullPath, join5(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}
@@ -16751,7 +17126,7 @@ function scanRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync(join4(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync(join5(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -16763,7 +17138,7 @@ function scanRecoveryRetries() {
 function startRecoveryOutboxWatcher() {
   if (!RECOVERY_OUTBOX_DIR) return;
   try {
-    mkdirSync3(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+    mkdirSync4(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
@@ -16781,7 +17156,7 @@ function startRecoveryOutboxWatcher() {
     const watcher = watch(RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptOutboxFile(filename)) return;
-      if (existsSync2(join4(RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync4(join5(RECOVERY_OUTBOX_DIR, filename))) {
         void processRecoveryOutboxFile(filename);
       }
     });
@@ -16802,7 +17177,7 @@ function trackPendingMessage(chatId, messageId, chatType, undeliverable = false,
 }
 function sweepTelegramStaleMarkers(thresholdMs) {
   if (!PENDING_INBOUND_DIR) return;
-  if (!existsSync2(PENDING_INBOUND_DIR)) return;
+  if (!existsSync4(PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
     filenames = readdirSync2(PENDING_INBOUND_DIR);
@@ -16818,17 +17193,17 @@ function sweepTelegramStaleMarkers(thresholdMs) {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join4(PENDING_INBOUND_DIR, filename);
+    const fullPath = join5(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16837,7 +17212,7 @@ function sweepTelegramStaleMarkers(thresholdMs) {
     const { chat_id, message_id, received_at } = marker;
     if (!chat_id || !message_id || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16860,14 +17235,14 @@ var orphanSweepTimer = setInterval(() => {
 orphanSweepTimer.unref?.();
 var lastGiveUpHandledAtMs = null;
 function listPendingInboundChatIds() {
-  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return [];
+  if (!PENDING_INBOUND_DIR || !existsSync4(PENDING_INBOUND_DIR)) return [];
   const chats = /* @__PURE__ */ new Set();
   try {
     for (const name of readdirSync2(PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync3(join4(PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync5(join5(PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
       } catch {
@@ -16908,7 +17283,7 @@ async function notifyWatchdogGiveUp(chatId) {
 }
 function checkWatchdogGiveUpNotice() {
   if (!AGENT_DIR) return;
-  const signalAtMs = readGiveUpSignalAtMs(join4(AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
+  const signalAtMs = readGiveUpSignalAtMs(join5(AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
   const act = decideGiveUpNotice({
     signalAtMs,
     lastHandledAtMs: lastGiveUpHandledAtMs,
@@ -16986,7 +17361,7 @@ function clearPendingMessage(chatId, messageId) {
     clearPendingInboundMarker(chatId, messageId);
     return;
   }
-  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return;
+  if (!PENDING_INBOUND_DIR || !existsSync4(PENDING_INBOUND_DIR)) return;
   const safeChatId = chatId.replace(/[^A-Za-z0-9_-]/g, "_");
   const prefix = `${safeChatId}__`;
   let filenames;
@@ -16998,7 +17373,7 @@ function clearPendingMessage(chatId, messageId) {
   for (const filename of filenames) {
     if (!filename.startsWith(prefix)) continue;
     if (!filename.endsWith(".json")) continue;
-    clearTelegramMarkerFileWithHeal(join4(PENDING_INBOUND_DIR, filename));
+    clearTelegramMarkerFileWithHeal(join5(PENDING_INBOUND_DIR, filename));
   }
 }
 function noteThreadActivity(chatId, messageId) {
@@ -17597,7 +17972,7 @@ 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;
+  if (!PENDING_INBOUND_DIR || !existsSync4(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;
@@ -17611,10 +17986,10 @@ async function replayPendingTelegramMarkers() {
   const entries = [];
   for (const name of filenames) {
     if (!name.endsWith(".json") || name.endsWith(".tmp")) continue;
-    const fullPath = join4(PENDING_INBOUND_DIR, name);
+    const fullPath = join5(PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -17646,12 +18021,12 @@ async function replayPendingTelegramMarkers() {
       continue;
     }
     try {
-      if (existsSync2(path)) {
+      if (existsSync4(path)) {
         const updated = {
           ...marker,
           replay_count: (marker.replay_count ?? 0) + 1
         };
-        writeFileSync3(path, JSON.stringify(updated), { mode: 384 });
+        writeFileSync4(path, JSON.stringify(updated), { mode: 384 });
       }
     } catch {
     }
@@ -17788,14 +18163,68 @@ async function pollLoop() {
         const content = typeof msg.text === "string" && msg.text.length > 0 ? msg.text : typeof msg.caption === "string" && msg.caption.length > 0 ? msg.caption : "";
         if (content.length === 0 && classifiedAttachments.length === 0) continue;
         const chatId = String(msg.chat.id);
-        if (ALLOWED_CHATS.size > 0 && !ALLOWED_CHATS.has(chatId)) continue;
+        const trimmedContent = content.trim();
+        const isFromBot = !!msg.from?.is_bot;
+        const nowMs = Date.now();
+        const telegramCommand = isHelpSyntax(trimmedContent) ? "help" : isStatusSyntax(trimmedContent) ? "status" : isRestartSyntax(trimmedContent) ? "restart" : isInvestigateSyntax(trimmedContent) ? "investigate" : void 0;
+        let classification;
+        let peerLeaf;
+        if (isFromBot) {
+          if (PEER_DISABLED_GLOBAL) {
+            peerLeaf = { kind: "drop", reason: "peer_disabled_global" };
+          } else {
+            const classifierMsg = {
+              message_id: msg.message_id,
+              text: msg.text,
+              caption: msg.caption,
+              from: msg.from ? { id: msg.from.id, username: msg.from.username, is_bot: msg.from.is_bot } : void 0,
+              chat: { id: msg.chat.id, type: msg.chat.type },
+              reply_to_message: msg.reply_to_message ? {
+                message_id: msg.reply_to_message.message_id,
+                from: msg.reply_to_message.from ? { id: msg.reply_to_message.from.id, is_bot: msg.reply_to_message.from.is_bot } : void 0
+              } : void 0,
+              entities: msg.entities,
+              caption_entities: msg.caption_entities
+            };
+            const self = await resolveBotIdentity();
+            classification = classifyPeerMessage(classifierMsg, PEER_CLASSIFIER_CONFIG, self);
+            peerLeaf = {
+              kind: classification.kind,
+              reason: classification.kind === "drop" ? classification.reason : void 0
+            };
+          }
+        }
+        const access = decideInboundAccess({
+          content: { forward: true },
+          // empty content already filtered above
+          // CodeRabbit: derive self from the peer classification so an echo of
+          // our own outbound is dropped at the self step — BEFORE command
+          // routing — instead of slipping through as a command. (Slack catches
+          // self at evt.user===botUserId and Teams inside its activity filter;
+          // Telegram's only self signal is the peer classifier.)
+          isSelf: peerLeaf?.kind === "self",
+          isBot: isFromBot,
+          peer: peerLeaf,
+          // TELEGRAM_ALLOWED_CHATS is Telegram's org-boundary axis (the drift
+          // the consolidation names). An unlisted chat is external ⇒ silent.
+          orgBoundary: ALLOWED_CHATS.size > 0 && !ALLOWED_CHATS.has(chatId) ? { forward: false } : { forward: true },
+          command: telegramCommand ? { command: telegramCommand, authorized: true } : void 0,
+          // No sender-policy mode system on Telegram, so no same-org decline.
+          sameOrg: false
+        });
+        if (access.kind === "drop" && (access.reason === "org_boundary" || access.reason.startsWith("content:"))) {
+          process.stderr.write(
+            `telegram-channel(${AGENT_CODE_NAME}): inbound drop reason=${access.reason} chat=${redactId(chatId)}
+`
+          );
+          continue;
+        }
         observedChatClient?.observe({
           chat_id: chatId,
           chat_title: msg.chat.title ?? msg.chat.username ?? msg.chat.first_name ?? null,
           chat_type: msg.chat.type ?? null
         });
-        const trimmedContent = content.trim();
-        if (isHelpSyntax(trimmedContent)) {
+        if (access.kind === "command" && access.command === "help") {
           const disposition = await classifyRestartCommand(trimmedContent.replace(/^\/help/, "/restart"));
           if (disposition === "act") {
             await handleHelpCommand({
@@ -17805,12 +18234,26 @@ async function pollLoop() {
           }
           continue;
         }
-        if (isRestartSyntax(trimmedContent)) {
+        if (access.kind === "command" && access.command === "status") {
+          const disposition = await classifyRestartCommand(
+            trimmedContent.replace(/^\/status/, "/restart")
+          );
+          if (disposition === "act") {
+            await handleStatusCommand({
+              chatId,
+              messageId: String(msg.message_id)
+            });
+          }
+          continue;
+        }
+        if (access.kind === "command" && access.command === "restart") {
           const disposition = await classifyRestartCommand(trimmedContent);
           if (disposition === "act") {
             await handleRestartCommand({
               chatId,
-              messageId: String(msg.message_id)
+              messageId: String(msg.message_id),
+              // ENG-6194: first_name personalises the back-online confirmation.
+              requesterName: msg.from?.first_name?.trim() || void 0
             });
           } else if (disposition === "verification_failed") {
             try {
@@ -17832,7 +18275,7 @@ async function pollLoop() {
           }
           continue;
         }
-        if (isInvestigateSyntax(trimmedContent)) {
+        if (access.kind === "command" && access.command === "investigate") {
           const disposition = await classifyInvestigateCommand(trimmedContent);
           if (disposition === "act") {
             await handleInvestigateCommand({
@@ -17863,8 +18306,6 @@ async function pollLoop() {
         }
         const userId = msg.from?.id != null ? String(msg.from.id) : "unknown";
         const userName = msg.from?.username || [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" ").trim() || userId;
-        const isFromBot = !!msg.from?.is_bot;
-        const nowMs = Date.now();
         if (chatId && !isFromBot) {
           resetThread(chatId, "");
         }
@@ -17873,38 +18314,14 @@ async function pollLoop() {
           peerRateLimiter.recordInboundHuman(chatId, nowMs);
         }
         let peerAgentMeta = null;
-        if (isFromBot) {
-          if (PEER_DISABLED_GLOBAL) {
+        if (access.kind === "drop") {
+          if (access.reason !== "self") {
+            const peerReason = access.reason.startsWith("peer:") ? access.reason.slice("peer:".length) : access.reason;
             process.stderr.write(
-              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=peer_disabled_global chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
+              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=${peerReason} chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
 `
             );
-            continue;
-          }
-          const classifierMsg = {
-            message_id: msg.message_id,
-            text: msg.text,
-            caption: msg.caption,
-            from: msg.from ? { id: msg.from.id, username: msg.from.username, is_bot: msg.from.is_bot } : void 0,
-            chat: { id: msg.chat.id, type: msg.chat.type },
-            reply_to_message: msg.reply_to_message ? {
-              message_id: msg.reply_to_message.message_id,
-              from: msg.reply_to_message.from ? { id: msg.reply_to_message.from.id, is_bot: msg.reply_to_message.from.is_bot } : void 0
-            } : void 0,
-            entities: msg.entities,
-            caption_entities: msg.caption_entities
-          };
-          const self = await resolveBotIdentity();
-          const classification = classifyPeerMessage(classifierMsg, PEER_CLASSIFIER_CONFIG, self);
-          if (classification.kind === "self") {
-            continue;
-          }
-          if (classification.kind === "drop") {
-            process.stderr.write(
-              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=${classification.reason} chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
-`
-            );
-            if (classification.reason === "cross_team_grant_missing") {
+            if (classification?.kind === "drop" && classification.reason === "cross_team_grant_missing") {
               crossTeamPeerAuditClient?.emit({
                 event_type: "telegram.peer.drop.cross_team_grant_missing",
                 peer_agent_id: null,
@@ -17914,52 +18331,52 @@ async function pollLoop() {
                 message_id: String(msg.message_id)
               });
             }
-            continue;
           }
-          if (classification.kind === "peer-ingress") {
-            const limit = await peerRateLimiter.recordInboundPeer(
-              chatId,
-              classification.peer.bot_id,
-              nowMs
-            );
-            if (limit.decision !== "ok") {
-              process.stderr.write(
-                `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=${limit.decision} chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
+          continue;
+        }
+        if (isFromBot && classification?.kind === "peer-ingress") {
+          const limit = await peerRateLimiter.recordInboundPeer(
+            chatId,
+            classification.peer.bot_id,
+            nowMs
+          );
+          if (limit.decision !== "ok") {
+            process.stderr.write(
+              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=${limit.decision} chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
 `
-              );
-              continue;
-            }
-            if (limit.dailyBudgetWarn && !dailyBudgetWarned) {
-              dailyBudgetWarned = true;
-              process.stderr.write(
-                `telegram-channel(${AGENT_CODE_NAME}): peer_warn reason=daily_budget_80pct
+            );
+            continue;
+          }
+          if (limit.dailyBudgetWarn && !dailyBudgetWarned) {
+            dailyBudgetWarned = true;
+            process.stderr.write(
+              `telegram-channel(${AGENT_CODE_NAME}): peer_warn reason=daily_budget_80pct
 `
-              );
-            }
-            peerAgentMeta = {
-              code_name: classification.peer.code_name,
-              agent_id: classification.peer.agent_id
-            };
-            const gate = classification.peer.gate_path;
-            if (gate && gate !== "same_team" && gate !== "intra_org_unrestricted" && gate.startsWith("grant:")) {
-              crossTeamPeerAuditClient?.emit({
-                event_type: "telegram.peer.ingress.cross_team",
-                peer_agent_id: classification.peer.agent_id || null,
-                gate_path: gate,
-                grant_id: gate.slice("grant:".length),
-                chat_id: String(chatId),
-                message_id: String(msg.message_id)
-              });
-            } else if (gate === "intra_org_unrestricted") {
-              crossTeamPeerAuditClient?.emit({
-                event_type: "telegram.peer.ingress.cross_team",
-                peer_agent_id: classification.peer.agent_id || null,
-                gate_path: gate,
-                grant_id: null,
-                chat_id: String(chatId),
-                message_id: String(msg.message_id)
-              });
-            }
+            );
+          }
+          peerAgentMeta = {
+            code_name: classification.peer.code_name,
+            agent_id: classification.peer.agent_id
+          };
+          const gate = classification.peer.gate_path;
+          if (gate && gate !== "same_team" && gate !== "intra_org_unrestricted" && gate.startsWith("grant:")) {
+            crossTeamPeerAuditClient?.emit({
+              event_type: "telegram.peer.ingress.cross_team",
+              peer_agent_id: classification.peer.agent_id || null,
+              gate_path: gate,
+              grant_id: gate.slice("grant:".length),
+              chat_id: String(chatId),
+              message_id: String(msg.message_id)
+            });
+          } else if (gate === "intra_org_unrestricted") {
+            crossTeamPeerAuditClient?.emit({
+              event_type: "telegram.peer.ingress.cross_team",
+              peer_agent_id: classification.peer.agent_id || null,
+              gate_path: gate,
+              grant_id: null,
+              chat_id: String(chatId),
+              message_id: String(msg.message_id)
+            });
           }
         }
         const messageId = String(msg.message_id);
@@ -17967,7 +18384,7 @@ async function pollLoop() {
         let paneLogFreshAgeMs = null;
         if (AGENT_DIR) {
           try {
-            const paneMtimeMs = statSync(join4(AGENT_DIR, "pane.log")).mtimeMs;
+            const paneMtimeMs = statSync(join5(AGENT_DIR, "pane.log")).mtimeMs;
             paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
           } catch {
           }
@@ -18042,6 +18459,9 @@ async function pollLoop() {
           ackDecision === "undeliverable",
           channelPayload
         );
+        if (ackDecision === "ack") {
+          scheduleBusyAck(chatId, messageId);
+        }
         await mcp.notification({
           method: "notifications/claude/channel",
           params: channelPayload
@@ -18130,6 +18550,7 @@ void (async () => {
     }
   }
 })();
+void notifyRestartCompleteOnBoot();
 pollLoop().catch((err) => {
   process.stderr.write(
     `telegram-channel(${AGENT_CODE_NAME}): poll loop died: ${err.message}
@@ -18139,6 +18560,7 @@ pollLoop().catch((err) => {
 });
 export {
   __resetBackOnlineNoticeThrottle,
+  __resetBusyAckNoticeThrottle,
   __resetGiveUpNoticeStateForTests,
   __resetUndeliverableNoticeThrottle,
   _resetQueuedReplyCountsForTests