@integrity-labs/agt-cli 0.14.12 → 0.14.14

package/mcp/telegram-channel.js

@@ -2980,7 +2980,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3007,7 +3007,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3582,7 +3582,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3809,7 +3809,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -12619,7 +12619,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -12636,7 +12636,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -12714,7 +12714,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -12975,12 +12975,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -13850,12 +13850,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -13864,6 +13864,238 @@ var StdioServerTransport = class {
 // src/telegram-channel.ts
 import https from "https";
 import { createHash } from "crypto";
+
+// src/channel-attachments.ts
+import { homedir } from "os";
+import { join, resolve, sep } from "path";
+function resolveChannelInboundDir(codeName, channelSlug) {
+  const base = join(homedir(), ".augmented");
+  const allowedSegment = /^[A-Za-z0-9_-]+$/;
+  if (!allowedSegment.test(codeName) || !allowedSegment.test(channelSlug)) {
+    throw new Error(
+      `Refusing to resolve inbound dir \u2014 invalid codeName/channelSlug (got ${JSON.stringify({ codeName, channelSlug })})`
+    );
+  }
+  const candidate = resolve(base, codeName, channelSlug);
+  if (!isPathInside(candidate, base)) {
+    throw new Error(`Refusing inbound dir outside ${base} (got ${candidate})`);
+  }
+  return candidate;
+}
+function classifyMimetype(mimetype) {
+  if (typeof mimetype === "string" && mimetype.startsWith("image/")) return "image";
+  return "attachment";
+}
+function buildSafeInboundPath(root, fileId, mimetype) {
+  const safeId = fileId.replace(/[^A-Za-z0-9_-]/g, "");
+  if (!safeId) throw new Error("Refusing to build inbound path for empty/invalid file id");
+  const ext = extensionForMimetype(mimetype);
+  const candidate = resolve(root, `${safeId}${ext}`);
+  if (!isPathInside(candidate, root)) {
+    throw new Error(`Refusing to build inbound path outside agent dir (got ${candidate})`);
+  }
+  return candidate;
+}
+function extensionForMimetype(mimetype) {
+  if (!mimetype) return ".bin";
+  switch (mimetype) {
+    // Images
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+    case "image/jpg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "image/svg+xml":
+      return ".svg";
+    // Docs
+    case "application/pdf":
+      return ".pdf";
+    case "text/plain":
+      return ".txt";
+    case "text/csv":
+      return ".csv";
+    case "application/json":
+      return ".json";
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+      return ".docx";
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      return ".xlsx";
+    // Audio (Telegram voice notes are typically audio/ogg; regular
+    // audio messages are audio/mpeg)
+    case "audio/ogg":
+      return ".ogg";
+    case "audio/mpeg":
+      return ".mp3";
+    case "audio/mp4":
+      return ".m4a";
+    // Video
+    case "video/mp4":
+      return ".mp4";
+    case "video/quicktime":
+      return ".mov";
+    default:
+      return ".bin";
+  }
+}
+function isPathInside(target, root) {
+  const normalizedRoot = resolve(root) + sep;
+  const normalizedTarget = resolve(target);
+  return normalizedTarget === resolve(root) || normalizedTarget.startsWith(normalizedRoot);
+}
+function createDownloadAllowlist(ttlMs) {
+  const store = /* @__PURE__ */ new Map();
+  function pruneExpired(now) {
+    for (const [fileId, scopes] of store) {
+      for (const [scope, expiresAt] of scopes) {
+        if (now > expiresAt) scopes.delete(scope);
+      }
+      if (scopes.size === 0) store.delete(fileId);
+    }
+  }
+  return {
+    register(fileId, scope) {
+      const now = Date.now();
+      pruneExpired(now);
+      const scopes = store.get(fileId) ?? /* @__PURE__ */ new Map();
+      scopes.set(scope, now + ttlMs);
+      store.set(fileId, scopes);
+    },
+    isAllowed(fileId, scope) {
+      const scopes = store.get(fileId);
+      if (!scopes) return false;
+      const expiresAt = scopes.get(scope);
+      if (!expiresAt) return false;
+      if (Date.now() > expiresAt) {
+        scopes.delete(scope);
+        if (scopes.size === 0) store.delete(fileId);
+        return false;
+      }
+      return true;
+    }
+  };
+}
+function redactAugmentedPaths(msg) {
+  const homePrefix = homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return msg.replaceAll(
+    new RegExp(`${homePrefix}[\\\\/]\\.augmented(?:[\\\\/][^\\s'"\`]*)*`, "g"),
+    "<augmented-path>"
+  );
+}
+
+// src/telegram-attachments.ts
+import { mkdirSync, writeFileSync, chmodSync, renameSync, unlinkSync } from "fs";
+function resolveTelegramInboundDir(codeName) {
+  return resolveChannelInboundDir(codeName, "telegram-inbound");
+}
+var MAX_TELEGRAM_INBOUND_BYTES = 25 * 1024 * 1024;
+function classifyTelegramAttachments(message) {
+  if (!message) return [];
+  const out = [];
+  if (Array.isArray(message.photo) && message.photo.length > 0) {
+    const largest = message.photo.reduce((acc, curr) => {
+      const accArea = (acc.width ?? 0) * (acc.height ?? 0);
+      const currArea = (curr.width ?? 0) * (curr.height ?? 0);
+      return currArea > accArea ? curr : acc;
+    }, message.photo[0]);
+    if (typeof largest.file_id === "string" && largest.file_id) {
+      out.push({
+        kind: "image",
+        id: largest.file_id,
+        filename: `photo-${largest.file_unique_id ?? largest.file_id}.jpg`,
+        mimetype: "image/jpeg"
+      });
+    }
+  }
+  if (message.document && typeof message.document.file_id === "string" && message.document.file_id) {
+    const mimetype = message.document.mime_type || "application/octet-stream";
+    out.push({
+      kind: classifyMimetype(mimetype),
+      id: message.document.file_id,
+      filename: message.document.file_name || message.document.file_id,
+      mimetype
+    });
+  }
+  if (message.voice && typeof message.voice.file_id === "string" && message.voice.file_id) {
+    out.push({
+      kind: "attachment",
+      id: message.voice.file_id,
+      filename: `voice-${message.voice.file_unique_id ?? message.voice.file_id}.ogg`,
+      mimetype: message.voice.mime_type || "audio/ogg"
+    });
+  }
+  if (message.video && typeof message.video.file_id === "string" && message.video.file_id) {
+    const mimetype = message.video.mime_type || "video/mp4";
+    out.push({
+      kind: "attachment",
+      id: message.video.file_id,
+      filename: message.video.file_name || `video-${message.video.file_unique_id ?? message.video.file_id}.mp4`,
+      mimetype
+    });
+  }
+  if (message.audio && typeof message.audio.file_id === "string" && message.audio.file_id) {
+    const mimetype = message.audio.mime_type || "audio/mpeg";
+    out.push({
+      kind: "attachment",
+      id: message.audio.file_id,
+      filename: message.audio.file_name || `audio-${message.audio.file_unique_id ?? message.audio.file_id}.mp3`,
+      mimetype
+    });
+  }
+  if (message.animation && typeof message.animation.file_id === "string" && message.animation.file_id) {
+    const mimetype = message.animation.mime_type || "video/mp4";
+    out.push({
+      kind: "attachment",
+      id: message.animation.file_id,
+      filename: message.animation.file_name || `animation-${message.animation.file_unique_id ?? message.animation.file_id}.mp4`,
+      mimetype
+    });
+  }
+  return out;
+}
+async function downloadTelegramFile(fileId, opts) {
+  const abortMeta = AbortSignal.timeout(opts.timeoutMs);
+  const metadata = await opts.http.getFilePath(fileId, abortMeta);
+  if (typeof metadata.file_size === "number" && metadata.file_size > opts.maxBytes) {
+    throw new Error(
+      `telegram file ${fileId} is ${metadata.file_size} bytes \u2014 exceeds the ${opts.maxBytes}-byte inbound cap`
+    );
+  }
+  const abortBody = AbortSignal.timeout(opts.timeoutMs);
+  const bytes = await opts.http.fetchBytes(metadata.file_path, abortBody, opts.maxBytes);
+  if (bytes.byteLength > opts.maxBytes) {
+    throw new Error(
+      `telegram file ${fileId} downloaded ${bytes.byteLength} bytes \u2014 exceeds the ${opts.maxBytes}-byte inbound cap`
+    );
+  }
+  const dir = resolveTelegramInboundDir(opts.codeName);
+  const savedPath = buildSafeInboundPath(dir, fileId, opts.mimetype);
+  if (!isPathInside(savedPath, dir)) {
+    throw new Error(`refusing to write ${savedPath} outside ${dir}`);
+  }
+  mkdirSync(dir, { recursive: true });
+  const tempPath = `${savedPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tempPath, bytes, { mode: 384, flag: "wx" });
+    try {
+      chmodSync(tempPath, 384);
+    } catch {
+    }
+    renameSync(tempPath, savedPath);
+  } catch (err) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+    }
+    throw err;
+  }
+  return savedPath;
+}
+
+// src/telegram-channel.ts
 function redactId(id) {
   return createHash("sha256").update(String(id)).digest("hex").slice(0, 8);
 }
@@ -13879,7 +14111,7 @@ if (!BOT_TOKEN) {
   process.exit(1);
 }
 function telegramApiCall(method, body, timeoutMs) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const postData = JSON.stringify(body);
     const req = https.request(
       {
@@ -13901,7 +14133,7 @@ function telegramApiCall(method, body, timeoutMs) {
         });
         res.on("end", () => {
           try {
-            resolve(JSON.parse(data));
+            resolve2(JSON.parse(data));
           } catch {
             reject(new Error("Invalid JSON from Telegram API"));
           }
@@ -13985,17 +14217,17 @@ var mcp = new Server(
       experimental: { "claude/channel": {} },
       tools: {}
     },
+    // NOTE: Claude Code truncates MCP server instructions at 2048 chars.
+    // Attachments rules live near the top because they get chopped otherwise
+    // and the agent silently loses attachment-handling guidance.
     instructions: [
       'Messages from Telegram arrive as <channel source="telegram" chat_id="..." user="..." user_name="..." message_id="...">.',
-      "The user reads Telegram, not this session. The ONLY way to reach them is the telegram.reply tool \u2014 anything you put in session output is invisible to them.",
-      `EVERY response to a Telegram message goes through telegram.reply, passing the chat_id from the tag. This includes clarifying questions, error messages, partial answers, "I don't understand", and status updates \u2014 no exceptions.`,
-      'For work that will take more than ~30 seconds, follow the standard kanban flow from CLAUDE.md: call kanban.add to track the task, then IMMEDIATELY reply via telegram.reply with "On it \u2014 tracking here: <kanban URL>" including the created task title, move the task to in_progress, do the work, and reply via telegram.reply with the result.',
-      "Simple lookups, one-line answers, and no-action acknowledgements do NOT need a kanban task \u2014 but still reply via telegram.reply every time.",
-      "When a user mentions a time without a timezone, interpret it in your Timezone from the Identity section of CLAUDE.md. Do NOT ask the user which timezone they meant \u2014 resolve it yourself against your own identity.",
-      "Address users by their user_name when possible; user is their numeric Telegram ID.",
-      "To quote-reply to a specific earlier message, pass its message_id as reply_to_message_id \u2014 otherwise omit it for a normal reply.",
-      "Telegram DMs are 1:1 \u2014 always reply to every inbound message unless it is obviously not addressed to you.",
-      'Every inbound message gets an automatic \u{1F440} reaction as a "seen, working on it" ack. Use the telegram.react tool to add your own reactions (e.g. \u270D while clarifying, \u{1FAE1} on task complete). Only free-tier emoji are available to bots \u2014 stick to: \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} and similar common reactions. Premium-only emoji fail silently.'
+      "Inbound attachments: the <channel> tag's `files` attribute is a JSON-serialised array \u2014 JSON.parse it before iterating. If a file entry has a `path`, the image is ALREADY DOWNLOADED locally \u2014 Read that path directly, do NOT call telegram.download_attachment. That tool is only for entries with `file_id` but NO `path` (PDF, docx, voice, audio, video, animations): pass file_id + chat_id verbatim (never paraphrase), then Read the returned path. Single-image messages also get a top-level `image_path` convenience attribute; multi-image messages omit it. Caption (no text) arrives as the channel content. Never tell the user about internal file-handling failures that don't affect the answer.",
+      "The user reads Telegram, not this session. Every response goes through telegram.reply with the chat_id from the tag \u2014 clarifying questions, errors, partial answers, status updates, all of it.",
+      'For work >30s follow CLAUDE.md kanban flow: kanban.add, reply with "On it \u2014 tracking here: <kanban URL>", move to in_progress, do the work, reply with the result. Simple lookups skip kanban but still reply.',
+      "Address users by user_name; user is the numeric Telegram ID. Reply-to a specific message with reply_to_message_id, otherwise omit.",
+      "Resolve ambiguous times against your own Timezone from CLAUDE.md \u2014 do not ask the user.",
+      "Every inbound message gets an automatic \u{1F440} ack. Use telegram.react for your own reactions: \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} (premium-only fail silently)."
     ].join(" ")
   }
 );
@@ -14035,6 +14267,24 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["chat_id", "text"]
       }
     },
+    {
+      name: "telegram.download_attachment",
+      description: "Download an inbound Telegram attachment on demand. Use this for non-image files (PDFs, docx, voice, video, audio, animations) that arrived via a <channel> tag \u2014 look for `file_id` in the `files` meta. Requires the `chat_id` from the same <channel> tag so the tool can verify the attachment was shared in the current conversation. Returns the local path where the file was written (inside ~/.augmented/<codeName>/telegram-inbound/). Images are auto-downloaded on receipt and don't need this tool.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_id: {
+            type: "string",
+            description: "Telegram file_id (from the `file_id` field on the `files` meta array of the inbound <channel> tag)"
+          },
+          chat_id: {
+            type: "string",
+            description: "Telegram chat_id from the `chat_id` attribute of the same inbound <channel> tag that surfaced the file. The tool only downloads attachments that were shared in this chat."
+          }
+        },
+        required: ["file_id", "chat_id"]
+      }
+    },
     {
       name: "telegram.react",
       description: "Add an emoji reaction to a Telegram message. 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.",
@@ -14122,11 +14372,141 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       };
     }
   }
+  if (name === "telegram.download_attachment") {
+    const { file_id, chat_id } = args;
+    if (typeof file_id !== "string" || !file_id.trim()) {
+      return {
+        content: [{ type: "text", text: "telegram.download_attachment requires a string `file_id`." }],
+        isError: true
+      };
+    }
+    if (typeof chat_id !== "string" || !chat_id.trim()) {
+      return {
+        content: [{ type: "text", text: "telegram.download_attachment requires a string `chat_id` (from the inbound <channel> tag)." }],
+        isError: true
+      };
+    }
+    const trimmedFileId = file_id.trim();
+    const trimmedChatId = chat_id.trim();
+    if (ALLOWED_CHATS.size > 0 && !ALLOWED_CHATS.has(trimmedChatId)) {
+      return {
+        content: [{ type: "text", text: `Chat ${trimmedChatId} is not in TELEGRAM_ALLOWED_CHATS` }],
+        isError: true
+      };
+    }
+    if (!downloadAllowlist.isAllowed(trimmedFileId, trimmedChatId)) {
+      return {
+        content: [{
+          type: "text",
+          text: "Download refused: file_id was not surfaced in a recent inbound `files` meta entry for this chat. You can only download attachments the originating conversation has shared with you."
+        }],
+        isError: true
+      };
+    }
+    try {
+      const savedPath = await downloadTelegramFile(trimmedFileId, {
+        codeName: AGENT_CODE_NAME,
+        mimetype: "application/octet-stream",
+        timeoutMs: TELEGRAM_DOWNLOAD_TIMEOUT_MS,
+        maxBytes: MAX_TELEGRAM_INBOUND_BYTES,
+        http: telegramHttp
+      });
+      return { content: [{ type: "text", text: `Downloaded to ${savedPath}` }] };
+    } catch (err) {
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to download attachment: ${redactAugmentedPaths(err.message)}`
+        }],
+        isError: true
+      };
+    }
+  }
   throw new Error(`Unknown tool: ${name}`);
 });
 await mcp.connect(new StdioServerTransport());
 var LONG_POLL_SECONDS = 50;
 var POLL_HTTP_TIMEOUT_MS = (LONG_POLL_SECONDS + 10) * 1e3;
+var TELEGRAM_DOWNLOAD_TIMEOUT_MS = 15e3;
+var TELEGRAM_DOWNLOAD_ALLOWLIST_TTL_MS = 60 * 60 * 1e3;
+var downloadAllowlist = createDownloadAllowlist(
+  TELEGRAM_DOWNLOAD_ALLOWLIST_TTL_MS
+);
+var telegramHttp = {
+  async getFilePath(fileId, signal) {
+    const resp = await telegramApiCall(
+      "getFile",
+      { file_id: fileId },
+      TELEGRAM_DOWNLOAD_TIMEOUT_MS
+    );
+    if (signal.aborted) throw new Error("telegram getFile aborted");
+    if (!resp.ok || !resp.result?.file_path) {
+      throw new Error(`telegram getFile failed: ${resp.description ?? "unknown"}`);
+    }
+    return { file_path: resp.result.file_path, file_size: resp.result.file_size };
+  },
+  async fetchBytes(filePath, signal, maxBytes) {
+    return new Promise((resolve2, reject) => {
+      const req = https.request(
+        {
+          hostname: "api.telegram.org",
+          port: 443,
+          path: `/file/bot${BOT_TOKEN}/${filePath}`,
+          method: "GET",
+          family: 4,
+          timeout: TELEGRAM_DOWNLOAD_TIMEOUT_MS
+        },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`telegram file fetch returned HTTP ${res.statusCode}`));
+            res.resume();
+            return;
+          }
+          const contentLengthHeader = res.headers["content-length"];
+          if (contentLengthHeader) {
+            const contentLength = Number(contentLengthHeader);
+            if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+              reject(new Error(
+                `telegram file fetch: Content-Length ${contentLength} exceeds ${maxBytes}-byte cap`
+              ));
+              req.destroy();
+              return;
+            }
+          }
+          const chunks = [];
+          let total = 0;
+          let aborted2 = false;
+          res.on("data", (c) => {
+            if (aborted2) return;
+            total += c.length;
+            if (total > maxBytes) {
+              aborted2 = true;
+              req.destroy();
+              reject(new Error(
+                `telegram file fetch: realized size exceeded ${maxBytes}-byte cap (>${total} bytes)`
+              ));
+              return;
+            }
+            chunks.push(c);
+          });
+          res.on("end", () => {
+            if (!aborted2) resolve2(Buffer.concat(chunks));
+          });
+          res.on("error", reject);
+        }
+      );
+      signal.addEventListener("abort", () => {
+        req.destroy(new Error("telegram file fetch aborted"));
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("telegram file fetch timeout"));
+      });
+      req.end();
+    });
+  }
+};
 var nextOffset = 0;
 var isShuttingDown = false;
 async function pollLoop() {
@@ -14153,7 +14533,10 @@ async function pollLoop() {
       for (const update of resp.result ?? []) {
         nextOffset = Math.max(nextOffset, update.update_id + 1);
         const msg = update.message;
-        if (!msg || typeof msg.text !== "string" || msg.text.length === 0) continue;
+        if (!msg) continue;
+        const classifiedAttachments = classifyTelegramAttachments(msg);
+        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 userId = msg.from?.id != null ? String(msg.from.id) : "unknown";
@@ -14161,10 +14544,37 @@ async function pollLoop() {
         const messageId = String(msg.message_id);
         void setMessageReaction(chatId, messageId, ACK_EMOJI);
         trackPendingMessage(chatId, messageId, msg.chat.type);
+        const fileMeta = [];
+        for (const attachment of classifiedAttachments) {
+          if (attachment.kind === "image") {
+            try {
+              const path = await downloadTelegramFile(attachment.id, {
+                codeName: AGENT_CODE_NAME,
+                mimetype: attachment.mimetype,
+                timeoutMs: TELEGRAM_DOWNLOAD_TIMEOUT_MS,
+                maxBytes: MAX_TELEGRAM_INBOUND_BYTES,
+                http: telegramHttp
+              });
+              fileMeta.push({ kind: "image", file_id: attachment.id, filename: attachment.filename, mimetype: attachment.mimetype, path });
+            } catch (err) {
+              process.stderr.write(
+                `telegram-channel(${AGENT_CODE_NAME}): image auto-download failed for ${redactId(attachment.id)}: ${redactAugmentedPaths(err.message)}
+`
+              );
+              downloadAllowlist.register(attachment.id, chatId);
+              fileMeta.push({ kind: "attachment", file_id: attachment.id, filename: attachment.filename, mimetype: attachment.mimetype });
+            }
+          } else {
+            downloadAllowlist.register(attachment.id, chatId);
+            fileMeta.push({ kind: "attachment", file_id: attachment.id, filename: attachment.filename, mimetype: attachment.mimetype });
+          }
+        }
+        const downloadedImages = fileMeta.filter((f) => f.kind === "image" && typeof f.path === "string");
+        const imagePath = downloadedImages.length === 1 ? downloadedImages[0].path : void 0;
         await mcp.notification({
           method: "notifications/claude/channel",
           params: {
-            content: msg.text,
+            content,
             meta: {
               source: "telegram",
               chat_id: chatId,
@@ -14172,7 +14582,9 @@ async function pollLoop() {
               message_id: messageId,
               user: userId,
               user_name: userName,
-              ts: String(msg.date)
+              ts: String(msg.date),
+              ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
+              ...imagePath ? { image_path: imagePath } : {}
             }
           }
         });
@@ -14188,7 +14600,7 @@ async function pollLoop() {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms).unref());
+  return new Promise((resolve2) => setTimeout(resolve2, ms).unref());
 }
 function shutdown(reason) {
   if (isShuttingDown) return;

package/package.json

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