@integrity-labs/agt-cli 0.19.17 → 0.19.19

package/mcp/telegram-channel.js

@@ -14211,6 +14211,410 @@ async function isThreadKilled(opts) {
   }
 }
 
+// src/telegram-peer-classifier.ts
+function classifyPeerMessage(msg, cfg, self) {
+  if (!msg.from?.is_bot) return { kind: "human" };
+  if (self.bot_id !== null && msg.from.id === self.bot_id) {
+    return { kind: "self" };
+  }
+  if (cfg.peer_agent_mode === "off") {
+    return { kind: "drop", reason: "mode_off" };
+  }
+  const chatId = String(msg.chat.id);
+  if (cfg.peer_group_ids.length === 0) {
+    if (msg.chat.type !== "private") {
+      return { kind: "drop", reason: "chat_not_allowed" };
+    }
+  } else if (!cfg.peer_group_ids.includes(chatId)) {
+    return { kind: "drop", reason: "chat_not_allowed" };
+  }
+  const peer = cfg.peers.find((p) => p.bot_id === msg.from.id);
+  if (!peer) {
+    return { kind: "drop", reason: "unknown_peer" };
+  }
+  if (self.bot_id === null || self.bot_username === null) {
+    return { kind: "drop", reason: "self_resolution_pending" };
+  }
+  const addressing = classifyAddressing(msg, self.bot_id, self.bot_username);
+  if (!addressing.addressed) {
+    return { kind: "drop", reason: "not_addressed" };
+  }
+  if (addressing.viaReplyOnly) {
+    const inAllowedGroup = cfg.peer_group_ids.length > 0 && cfg.peer_group_ids.includes(chatId);
+    const respondMode = cfg.peer_agent_mode === "respond";
+    if (!(inAllowedGroup && respondMode)) {
+      return { kind: "drop", reason: "not_addressed" };
+    }
+  }
+  return { kind: "peer-ingress", peer };
+}
+function classifyAddressing(msg, ourBotId, ourBotUsername) {
+  let viaMentionOrCommand = false;
+  const text = msg.text ?? msg.caption ?? "";
+  const entities = msg.entities ?? msg.caption_entities ?? [];
+  const usAt = "@" + ourBotUsername;
+  for (const entity of entities) {
+    const slice = text.slice(entity.offset, entity.offset + entity.length).toLowerCase();
+    if (entity.type === "bot_command") {
+      const at = slice.indexOf("@");
+      if (at < 0 || slice.slice(at + 1) === ourBotUsername) {
+        viaMentionOrCommand = true;
+        break;
+      }
+    } else if (entity.type === "mention" && slice === usAt) {
+      viaMentionOrCommand = true;
+      break;
+    }
+  }
+  const viaReply = msg.reply_to_message?.from?.id === ourBotId;
+  if (viaMentionOrCommand) return { addressed: true, viaReplyOnly: false };
+  if (viaReply) return { addressed: true, viaReplyOnly: true };
+  return { addressed: false, viaReplyOnly: false };
+}
+var CODE_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function parsePeersEnv(raw) {
+  if (!raw || raw.trim().length === 0) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const entry of parsed) {
+    if (entry && typeof entry === "object" && typeof entry.code_name === "string" && CODE_NAME_RE.test(entry.code_name) && typeof entry.agent_id === "string" && typeof entry.bot_id === "number" && Number.isInteger(entry.bot_id) && entry.bot_id > 0) {
+      const e = entry;
+      out.push({ code_name: e.code_name, bot_id: e.bot_id, agent_id: e.agent_id });
+    }
+  }
+  return out;
+}
+function parsePeerGroupIdsEnv(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parsePeerAgentModeEnv(raw) {
+  if (raw === "listen" || raw === "respond") return raw;
+  return "off";
+}
+
+// src/telegram-peer-rate-limiter.ts
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var DEFAULT_RATE_LIMITER_CONFIG = Object.freeze({
+  pairBurstLimit: 1,
+  pairBurstWindowMs: 10 * SECOND_MS,
+  pairWindowLimit: 5,
+  pairWindowMs: 5 * MINUTE_MS,
+  chatLimit: 10,
+  chatWindowMs: 5 * MINUTE_MS,
+  agentDailyLimit: 200,
+  agentDailyWindowMs: DAY_MS,
+  dailyBudgetLimit: 500,
+  dailyBudgetWindowMs: DAY_MS
+});
+function readSliding(window, windowMs, now) {
+  if (!window) return 0;
+  const cutoff = now - windowMs;
+  let i = 0;
+  while (i < window.timestamps.length && window.timestamps[i] <= cutoff) i++;
+  if (i > 0) window.timestamps.splice(0, i);
+  return window.timestamps.length;
+}
+function bumpSliding(window, now) {
+  window.timestamps.push(now);
+}
+function createPeerRateLimiter(config2 = DEFAULT_RATE_LIMITER_CONFIG) {
+  const counters = {
+    pairBurst: /* @__PURE__ */ new Map(),
+    pairWindow: /* @__PURE__ */ new Map(),
+    chat: /* @__PURE__ */ new Map(),
+    agentDaily: { timestamps: [] },
+    dailyBudget: { timestamps: [] }
+  };
+  let humanInbound = 0;
+  function pairKey(chatId, peerBotId) {
+    return `${chatId}:${peerBotId}`;
+  }
+  function readMap(map, key2, windowMs, now) {
+    return readSliding(map.get(key2), windowMs, now);
+  }
+  function bumpMap(map, key2, now) {
+    let entry = map.get(key2);
+    if (!entry) {
+      entry = { timestamps: [] };
+      map.set(key2, entry);
+    }
+    bumpSliding(entry, now);
+  }
+  return {
+    recordInboundPeer(chatId, peerBotId, now) {
+      const pk = pairKey(chatId, peerBotId);
+      if (readMap(counters.pairBurst, pk, config2.pairBurstWindowMs, now) >= config2.pairBurstLimit) {
+        return { decision: "rate_limit_pair", dailyBudgetWarn: false };
+      }
+      if (readMap(counters.pairWindow, pk, config2.pairWindowMs, now) >= config2.pairWindowLimit) {
+        return { decision: "rate_limit_pair", dailyBudgetWarn: false };
+      }
+      if (readMap(counters.chat, chatId, config2.chatWindowMs, now) >= config2.chatLimit) {
+        return { decision: "rate_limit_chat", dailyBudgetWarn: false };
+      }
+      if (readSliding(counters.agentDaily, config2.agentDailyWindowMs, now) >= config2.agentDailyLimit) {
+        return { decision: "rate_limit_agent_daily", dailyBudgetWarn: false };
+      }
+      const budgetSoFar = readSliding(counters.dailyBudget, config2.dailyBudgetWindowMs, now);
+      if (budgetSoFar >= config2.dailyBudgetLimit) {
+        return { decision: "daily_budget_exhausted", dailyBudgetWarn: false };
+      }
+      bumpMap(counters.pairBurst, pk, now);
+      bumpMap(counters.pairWindow, pk, now);
+      bumpMap(counters.chat, chatId, now);
+      bumpSliding(counters.agentDaily, now);
+      bumpSliding(counters.dailyBudget, now);
+      const newBudget = budgetSoFar + 1;
+      const warn80 = newBudget >= Math.ceil(config2.dailyBudgetLimit * 0.8) && newBudget < config2.dailyBudgetLimit;
+      return { decision: "ok", dailyBudgetWarn: warn80 };
+    },
+    recordInboundHuman(_chatId, _now) {
+      humanInbound += 1;
+    },
+    snapshot(now) {
+      const perChat = /* @__PURE__ */ new Map();
+      for (const [k, v] of counters.chat) {
+        perChat.set(k, readSliding(v, config2.chatWindowMs, now));
+      }
+      const perPair = /* @__PURE__ */ new Map();
+      for (const [k, v] of counters.pairWindow) {
+        perPair.set(k, readSliding(v, config2.pairWindowMs, now));
+      }
+      return {
+        perAgentDaily: readSliding(counters.agentDaily, config2.agentDailyWindowMs, now),
+        dailyBudget: readSliding(counters.dailyBudget, config2.dailyBudgetWindowMs, now),
+        perChat,
+        perPair,
+        humanInbound
+      };
+    }
+  };
+}
+function createPresenceTracker() {
+  const lastHumanByChat = /* @__PURE__ */ new Map();
+  return {
+    noteInbound(chatId, kind, now) {
+      if (kind === "human") lastHumanByChat.set(chatId, now);
+    },
+    shouldDropOutgress(chatId, now, maxAgeMs = 30 * MINUTE_MS) {
+      const last = lastHumanByChat.get(chatId);
+      if (last === void 0) return "no_human_recent";
+      if (now - last >= maxAgeMs) return "no_human_recent";
+      return null;
+    }
+  };
+}
+
+// src/telegram-peer-rate-limiter-db.ts
+function createDbBackedPeerRateLimiter(deps) {
+  const config2 = deps.config ?? DEFAULT_RATE_LIMITER_CONFIG;
+  const readCacheMs = deps.readCacheMs ?? 2e3;
+  const log = deps.log ?? (() => {
+  });
+  const caches = /* @__PURE__ */ new Map();
+  let humanInbound = 0;
+  const pendingWrites = /* @__PURE__ */ new Set();
+  function trackPending(write) {
+    pendingWrites.add(write);
+    void write.finally(() => pendingWrites.delete(write));
+  }
+  function cacheKey2(layer, chatId, peerBotId) {
+    return `${layer}|${chatId}|${peerBotId ?? ""}`;
+  }
+  const localBumpTimes = /* @__PURE__ */ new Map();
+  function bumpLocal(layer, chatId, peerBotId, now) {
+    const key2 = cacheKey2(layer, chatId, peerBotId);
+    const list = localBumpTimes.get(key2);
+    if (list) list.push(now);
+    else localBumpTimes.set(key2, [now]);
+  }
+  function localBumpsSince(key2, fetchedAt) {
+    const list = localBumpTimes.get(key2);
+    if (!list) return 0;
+    let n = 0;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i] >= fetchedAt) n++;
+      else break;
+    }
+    return n;
+  }
+  function pruneLocalBumps(retentionMs, now) {
+    const cutoff = now - retentionMs;
+    for (const [key2, list] of localBumpTimes) {
+      let i = 0;
+      while (i < list.length && list[i] < cutoff) i++;
+      if (i > 0) list.splice(0, i);
+      if (list.length === 0) localBumpTimes.delete(key2);
+    }
+  }
+  async function readCount(layer, chatId, peerBotId, windowMs, now) {
+    const key2 = cacheKey2(layer, chatId, peerBotId);
+    const cached2 = caches.get(key2);
+    if (cached2 && now - cached2.fetchedAt < readCacheMs) {
+      return cached2.count + localBumpsSince(key2, cached2.fetchedAt);
+    }
+    const since = new Date(now - windowMs).toISOString();
+    let count;
+    try {
+      const args = {
+        since,
+        traffic_class: layer
+      };
+      if (layer === "pair_burst" || layer === "pair_window") {
+        args.chat_id = chatId;
+        args.peer_bot_id = peerBotId ?? void 0;
+      } else if (layer === "chat") {
+        args.chat_id = chatId;
+      }
+      count = await deps.api.countEvents(args);
+    } catch (err) {
+      log(`peer_rate_event read failed (layer=${layer}): ${err.message} \u2014 fail-open`);
+      count = 0;
+    }
+    const fetchedAt = now;
+    caches.set(key2, { fetchedAt, count });
+    return count + localBumpsSince(key2, fetchedAt);
+  }
+  async function decide(chatId, peerBotId, now) {
+    const layers = [
+      { layer: "pair_burst", chatId, peerBotId, limit: config2.pairBurstLimit, windowMs: config2.pairBurstWindowMs, reason: "rate_limit_pair" },
+      { layer: "pair_window", chatId, peerBotId, limit: config2.pairWindowLimit, windowMs: config2.pairWindowMs, reason: "rate_limit_pair" },
+      { layer: "chat", chatId, peerBotId: null, limit: config2.chatLimit, windowMs: config2.chatWindowMs, reason: "rate_limit_chat" },
+      { layer: "agent_daily", chatId: "", peerBotId: null, limit: config2.agentDailyLimit, windowMs: config2.agentDailyWindowMs, reason: "rate_limit_agent_daily" },
+      { layer: "daily_budget", chatId: "", peerBotId: null, limit: config2.dailyBudgetLimit, windowMs: config2.dailyBudgetWindowMs, reason: "daily_budget_exhausted" }
+    ];
+    for (const l of layers) {
+      const count = await readCount(l.layer, l.chatId, l.peerBotId, l.windowMs, now);
+      if (count >= l.limit) {
+        return { decision: l.reason, dailyBudgetWarn: false };
+      }
+    }
+    for (const l of layers) bumpLocal(l.layer, l.chatId, l.peerBotId, now);
+    pruneLocalBumps(Math.max(config2.pairBurstWindowMs, 6e4), now);
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: peerBotId, traffic_class: "pair_burst" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: peerBotId, traffic_class: "pair_window" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "chat" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "agent_daily" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "daily_budget" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    const dbKey = cacheKey2("daily_budget", "", null);
+    const dbCached = caches.get(dbKey);
+    const dbBudget = (dbCached?.count ?? 0) + localBumpsSince(dbKey, dbCached?.fetchedAt ?? 0);
+    const warn80 = dbBudget >= Math.ceil(config2.dailyBudgetLimit * 0.8) && dbBudget < config2.dailyBudgetLimit;
+    return { decision: "ok", dailyBudgetWarn: warn80 };
+  }
+  return {
+    recordInboundPeer(chatId, peerBotId, now) {
+      return decide(chatId, peerBotId, now);
+    },
+    recordInboundHuman(_chatId, _now) {
+      humanInbound += 1;
+    },
+    snapshot(now) {
+      const perChat = /* @__PURE__ */ new Map();
+      const perPair = /* @__PURE__ */ new Map();
+      let perAgentDaily = 0;
+      let dailyBudget = 0;
+      for (const [k, v] of caches) {
+        const local = localBumpsSince(k, v.fetchedAt);
+        const layer = k.split("|")[0];
+        if (layer === "pair_window") {
+          const chatId = k.split("|")[1];
+          const peerBotId = k.split("|")[2];
+          perPair.set(`${chatId}:${peerBotId}`, v.count + local);
+        } else if (layer === "chat") {
+          const chatId = k.split("|")[1];
+          perChat.set(chatId, v.count + local);
+        } else if (layer === "agent_daily") {
+          perAgentDaily = v.count + local;
+        } else if (layer === "daily_budget") {
+          dailyBudget = v.count + local;
+        }
+      }
+      void now;
+      return { perAgentDaily, dailyBudget, perChat, perPair, humanInbound };
+    },
+    async flushPending() {
+      await Promise.all([...pendingWrites]);
+    }
+  };
+}
+function createDefaultPeerRateApiClient(args) {
+  if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const base = args.agtHost.replace(/\/+$/, "");
+  let cachedToken = null;
+  let cachedTokenExpiresAt = 0;
+  async function getToken() {
+    if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;
+    const resp = await fetchImpl(`${base}/host/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_key: args.agtApiKey })
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`/host/exchange failed (${resp.status}): ${body.slice(0, 200)}`);
+    }
+    const data = await resp.json();
+    cachedToken = data.token;
+    cachedTokenExpiresAt = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : Date.now() + 55 * 6e4;
+    return cachedToken;
+  }
+  async function authedFetch(path, init) {
+    const headers = {
+      Authorization: `Bearer ${await getToken()}`
+    };
+    if (init.body !== void 0) headers["Content-Type"] = "application/json";
+    let resp = await fetchImpl(`${base}${path}`, { method: init.method, headers, body: init.body });
+    if (resp.status === 401) {
+      cachedToken = null;
+      cachedTokenExpiresAt = 0;
+      const retryHeaders = {
+        Authorization: `Bearer ${await getToken()}`
+      };
+      if (init.body !== void 0) retryHeaders["Content-Type"] = "application/json";
+      resp = await fetchImpl(`${base}${path}`, { method: init.method, headers: retryHeaders, body: init.body });
+    }
+    return resp;
+  }
+  return {
+    async recordEvent({ chat_id, peer_bot_id, traffic_class }) {
+      const resp = await authedFetch("/host/peer-rate-events", {
+        method: "POST",
+        body: JSON.stringify({ agent_id: args.agentId, chat_id, peer_bot_id, traffic_class })
+      });
+      if (!resp.ok) {
+        throw new Error(`POST /host/peer-rate-events failed: ${resp.status} ${await resp.text()}`);
+      }
+    },
+    async countEvents({ since, chat_id, peer_bot_id, traffic_class }) {
+      const params = new URLSearchParams({
+        agent_id: args.agentId,
+        since
+      });
+      if (chat_id !== void 0) params.set("chat_id", chat_id);
+      if (peer_bot_id !== void 0) params.set("peer_bot_id", String(peer_bot_id));
+      if (traffic_class !== void 0) params.set("traffic_class", traffic_class);
+      const resp = await authedFetch(`/host/peer-rate-events?${params}`, { method: "GET" });
+      if (!resp.ok) {
+        throw new Error(`GET /host/peer-rate-events failed: ${resp.status} ${await resp.text()}`);
+      }
+      const json = await resp.json();
+      return typeof json.count === "number" ? json.count : 0;
+    }
+  };
+}
+
 // src/telegram-channel.ts
 function redactId(id) {
   return createHash("sha256").update(String(id)).digest("hex").slice(0, 8);
@@ -14222,6 +14626,33 @@ var AGT_API_KEY = process.env.AGT_API_KEY ?? null;
 var ALLOWED_CHATS = new Set(
   (process.env.TELEGRAM_ALLOWED_CHATS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
 );
+var PEER_CLASSIFIER_CONFIG = {
+  peer_agent_mode: parsePeerAgentModeEnv(process.env.TELEGRAM_PEER_AGENT_MODE),
+  peer_group_ids: parsePeerGroupIdsEnv(process.env.TELEGRAM_PEER_GROUP_IDS),
+  peers: parsePeersEnv(process.env.TELEGRAM_PEERS)
+};
+var PEER_DISABLED_GLOBAL = (() => {
+  const v = (process.env.TELEGRAM_PEER_DISABLED ?? "").toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+})();
+if (PEER_DISABLED_GLOBAL) {
+  process.stderr.write(
+    `telegram-channel(${AGENT_CODE_NAME}): TELEGRAM_PEER_DISABLED=true \u2014 peer ingress + outgress short-circuited
+`
+  );
+}
+var peerRateApiClient = createDefaultPeerRateApiClient({
+  agtHost: AGT_HOST,
+  agtApiKey: AGT_API_KEY,
+  agentId: process.env.AGT_AGENT_ID ?? null
+});
+var peerRateLimiter = peerRateApiClient && parsePeerAgentModeEnv(process.env.TELEGRAM_PEER_AGENT_MODE) !== "off" ? createDbBackedPeerRateLimiter({
+  api: peerRateApiClient,
+  log: (line) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${line}
+`)
+}) : createPeerRateLimiter();
+var peerPresence = createPresenceTracker();
+var dailyBudgetWarned = false;
 if (!BOT_TOKEN) {
   process.stderr.write(
     "telegram-channel: Missing TELEGRAM_BOT_TOKEN. Cannot start.\n"
@@ -14418,25 +14849,41 @@ async function handleRestartCommand(opts) {
   }
 }
 var cachedBotUsername = null;
-async function resolveBotUsername() {
-  if (cachedBotUsername !== null) return cachedBotUsername;
+var cachedBotId = null;
+async function refreshBotIdentity() {
   try {
     const resp = await telegramApiCall("getMe", {}, 5e3);
-    if (resp.ok && resp.result && typeof resp.result.username === "string") {
-      cachedBotUsername = resp.result.username.toLowerCase();
-      return cachedBotUsername;
+    if (resp.ok && resp.result) {
+      const result = resp.result;
+      if (typeof result.username === "string") {
+        cachedBotUsername = result.username.toLowerCase();
+      }
+      if (typeof result.id === "number") {
+        cachedBotId = result.id;
+      }
+      if (cachedBotUsername !== null && cachedBotId !== null) return;
     }
     process.stderr.write(
-      `telegram-channel(${AGENT_CODE_NAME}): getMe rejected: ${resp.description ?? "unknown"} \u2014 will retry on next /restart@<bot>
+      `telegram-channel(${AGENT_CODE_NAME}): getMe rejected: ${resp.description ?? "unknown"} \u2014 will retry on next lookup
 `
     );
   } catch (err) {
     process.stderr.write(
-      `telegram-channel(${AGENT_CODE_NAME}): getMe failed: ${redactAugmentedPaths(err.message)} \u2014 will retry on next /restart@<bot>
+      `telegram-channel(${AGENT_CODE_NAME}): getMe failed: ${redactAugmentedPaths(err.message)} \u2014 will retry on next lookup
 `
     );
   }
-  return null;
+}
+async function resolveBotUsername() {
+  if (cachedBotUsername !== null) return cachedBotUsername;
+  await refreshBotIdentity();
+  return cachedBotUsername;
+}
+async function resolveBotIdentity() {
+  if (cachedBotId === null || cachedBotUsername === null) {
+    await refreshBotIdentity();
+  }
+  return { bot_id: cachedBotId, bot_username: cachedBotUsername };
 }
 var RESTART_SYNTAX_RE = /^\/restart(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
 var HELP_SYNTAX_RE = /^\/help(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
@@ -14842,6 +15289,40 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
+    const peerActiveOnChat = PEER_CLASSIFIER_CONFIG.peer_agent_mode !== "off" && PEER_CLASSIFIER_CONFIG.peer_group_ids.length > 0 && PEER_CLASSIFIER_CONFIG.peer_group_ids.includes(chat_id);
+    if (peerActiveOnChat) {
+      if (PEER_DISABLED_GLOBAL) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): outgress_blocked reason=peer_disabled_global chat=${redactId(chat_id)}
+`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Multi-agent collaboration is disabled (TELEGRAM_PEER_DISABLED). Stop attempting to reply on this chat."
+            }
+          ],
+          isError: true
+        };
+      }
+      const stale = peerPresence.shouldDropOutgress(chat_id, Date.now());
+      if (stale === "no_human_recent") {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): outgress_blocked reason=no_human_recent chat=${redactId(chat_id)}
+`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No human message in this chat in the last 30 minutes. Peer-agent collaboration is paused for this chat until a human posts."
+            }
+          ],
+          isError: true
+        };
+      }
+    }
     const killed = await isThreadKilled({
       channelType: "telegram",
       channelId: chat_id,
@@ -15148,9 +15629,74 @@ 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, "");
         }
+        peerPresence.noteInbound(chatId, isFromBot ? "bot" : "human", nowMs);
+        if (!isFromBot) {
+          peerRateLimiter.recordInboundHuman(chatId, nowMs);
+        }
+        let peerAgentMeta = null;
+        if (isFromBot) {
+          if (PEER_DISABLED_GLOBAL) {
+            process.stderr.write(
+              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=peer_disabled_global 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"))}
+`
+            );
+            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 (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 messageId = String(msg.message_id);
         void setMessageReaction(chatId, messageId, ACK_EMOJI);
         trackPendingMessage(chatId, messageId, msg.chat.type);
@@ -15194,7 +15740,15 @@ async function pollLoop() {
               user_name: userName,
               ts: String(msg.date),
               ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
-              ...imagePath ? { image_path: imagePath } : {}
+              ...imagePath ? { image_path: imagePath } : {},
+              // ENG-4902: peer-agent ingress carries distinct framing so the
+              // runtime (MVP #5) can apply the peer-agent system preamble
+              // and store the turn under a peer_agent memory role.
+              ...peerAgentMeta ? {
+                source_role: "agent",
+                peer_code_name: peerAgentMeta.code_name,
+                peer_agent_id: peerAgentMeta.agent_id
+              } : {}
             }
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.19.17",
+  "version": "0.19.19",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {