@integrity-labs/agt-cli 0.28.79 → 0.28.81

package/dist/mcp/telegram-channel.js

@@ -16232,6 +16232,12 @@ function markerArrivalMs(fullPath) {
   }
 }
 function clearAllTelegramPendingMarkersForChat(pendingDir, chatId, clearMarkerFile, cutoffMs = Number.POSITIVE_INFINITY) {
+  return applyToChatMarkers(pendingDir, chatId, clearMarkerFile, cutoffMs);
+}
+function markSeenAllTelegramPendingMarkersForChat(pendingDir, chatId, markSeen, cutoffMs = Number.POSITIVE_INFINITY) {
+  return applyToChatMarkers(pendingDir, chatId, markSeen, cutoffMs);
+}
+function applyToChatMarkers(pendingDir, chatId, op, cutoffMs) {
   const prefix = `${chatId.replace(/[^A-Za-z0-9_-]/g, "_")}__`;
   const bounded = Number.isFinite(cutoffMs);
   let filenames;
@@ -16240,16 +16246,69 @@ function clearAllTelegramPendingMarkersForChat(pendingDir, chatId, clearMarkerFi
   } catch {
     return 0;
   }
-  let cleared = 0;
+  let applied = 0;
   for (const filename of filenames) {
     if (!filename.startsWith(prefix)) continue;
     if (!filename.endsWith(".json")) continue;
     const fullPath = join4(pendingDir, filename);
     if (bounded && markerArrivalMs(fullPath) > cutoffMs) continue;
-    clearMarkerFile(fullPath);
-    cleared++;
+    op(fullPath);
+    applied++;
+  }
+  return applied;
+}
+
+// src/channel-progress.ts
+function channelLiveProgressEnabled() {
+  return resolveHostBooleanFlag({
+    key: "channel-live-progress",
+    envVar: "AGT_CHANNEL_PROGRESS_ENABLED",
+    defaultValue: false
+  });
+}
+function decideProgressAction(input) {
+  const { now, heartbeat, target, tracked, freshnessMs, minPendingMs } = input;
+  const fresh = heartbeat != null && now - heartbeat.updatedAtMs <= freshnessMs;
+  const active = target != null && fresh;
+  if (!active) {
+    if (tracked) {
+      return { type: "delete", channel: tracked.channel, threadTs: tracked.threadTs, ts: tracked.ts };
+    }
+    return { type: "none" };
+  }
+  const t = target;
+  const hb = heartbeat;
+  if (tracked && (tracked.threadTs !== t.threadTs || tracked.channel !== t.channel)) {
+    return { type: "delete", channel: tracked.channel, threadTs: tracked.threadTs, ts: tracked.ts };
+  }
+  if (!tracked) {
+    if (now - t.receivedAtMs < minPendingMs) return { type: "none" };
+    return { type: "post", channel: t.channel, threadTs: t.threadTs, step: hb.step };
+  }
+  if (hb.step !== tracked.lastStep) {
+    return { type: "update", channel: t.channel, threadTs: t.threadTs, ts: tracked.ts, step: hb.step };
+  }
+  return { type: "none" };
+}
+function progressHeartbeatFreshMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_FRESH_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 45e3;
+}
+function progressMinPendingMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_MIN_PENDING_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 12e3;
+}
+function parseProgressHeartbeat(raw) {
+  if (!raw) return null;
+  try {
+    const obj = JSON.parse(raw);
+    const step = typeof obj.step === "string" ? obj.step.trim() : "";
+    const updatedAtMs = typeof obj.updated_at_ms === "number" ? obj.updated_at_ms : NaN;
+    if (!step || !Number.isFinite(updatedAtMs)) return null;
+    return { step, updatedAtMs };
+  } catch {
+    return null;
   }
-  return cleared;
 }
 
 // src/mcp-spawn-lock.ts
@@ -17666,6 +17725,33 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
   } catch {
   }
 }
+function markTelegramMarkerSeenInPlace(fullPath) {
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (marker.seen_at) return;
+  marker.seen_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (marker.undeliverable) delete marker.undeliverable;
+  rewriteTelegramMarkerInPlace(fullPath, marker);
+}
+function markTelegramMarkerSeenWithHeal(fullPath) {
+  let marker = null;
+  try {
+    marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.chat_id)
+  }) === "heal") {
+    notifyBackOnline(marker.chat_id);
+  }
+  markTelegramMarkerSeenInPlace(fullPath);
+}
 function readPendingInboundMarker(chatId, messageId) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !existsSync5(path)) return null;
@@ -17911,6 +17997,143 @@ var orphanSweepTimer = setInterval(() => {
   checkWatchdogGiveUpNotice();
 }, orphanSweepIntervalMs());
 orphanSweepTimer.unref?.();
+var TELEGRAM_PROGRESS_HEARTBEAT_PATH = AGENT_DIR ? join7(AGENT_DIR, "channel-progress-heartbeat.json") : null;
+var telegramTrackedProgress = null;
+var telegramProgressTickRunning = false;
+function readTelegramProgressHeartbeat() {
+  if (!TELEGRAM_PROGRESS_HEARTBEAT_PATH || !existsSync5(TELEGRAM_PROGRESS_HEARTBEAT_PATH)) return null;
+  try {
+    return parseProgressHeartbeat(readFileSync8(TELEGRAM_PROGRESS_HEARTBEAT_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findTelegramProgressTarget() {
+  if (!PENDING_INBOUND_DIR || !existsSync5(PENDING_INBOUND_DIR)) return null;
+  let best = null;
+  let bestMs = Infinity;
+  try {
+    for (const name of readdirSync3(PENDING_INBOUND_DIR)) {
+      if (!name.endsWith(".json")) continue;
+      let m;
+      try {
+        m = JSON.parse(readFileSync8(join7(PENDING_INBOUND_DIR, name), "utf-8"));
+      } catch {
+        continue;
+      }
+      if (!m.chat_id) continue;
+      if (m.undeliverable === true) continue;
+      const ms = Date.parse(m.received_at ?? "");
+      if (!Number.isFinite(ms)) continue;
+      if (ms < bestMs) {
+        bestMs = ms;
+        best = { channel: m.chat_id, threadTs: m.chat_id, receivedAtMs: ms };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return best;
+}
+var TELEGRAM_PROGRESS_PREFIX = "\u23F3";
+function telegramProgressText(step) {
+  return `${TELEGRAM_PROGRESS_PREFIX} Working\u2026 \xB7 ${step}`;
+}
+async function postTelegramProgress(chatId, step) {
+  if (!BOT_TOKEN) return null;
+  try {
+    const data = await telegramApiCall(
+      "sendMessage",
+      { chat_id: chatId, text: telegramProgressText(step), disable_notification: true },
+      8e3
+    );
+    return data.ok && data.result?.message_id != null ? String(data.result.message_id) : null;
+  } catch {
+    return null;
+  }
+}
+async function updateTelegramProgress(chatId, messageId, step) {
+  if (!BOT_TOKEN) return false;
+  try {
+    const data = await telegramApiCall(
+      "editMessageText",
+      { chat_id: chatId, message_id: Number(messageId), text: telegramProgressText(step) },
+      8e3
+    );
+    return data.ok === true || /not modified/i.test(data.description ?? "");
+  } catch {
+    return false;
+  }
+}
+async function deleteTelegramProgress(chatId, messageId) {
+  if (!BOT_TOKEN) return false;
+  try {
+    const data = await telegramApiCall(
+      "deleteMessage",
+      { chat_id: chatId, message_id: Number(messageId) },
+      8e3
+    );
+    return data.ok === true || /message to delete not found|message can't be deleted/i.test(data.description ?? "");
+  } catch {
+    return false;
+  }
+}
+async function telegramProgressTick() {
+  if (telegramProgressTickRunning) return;
+  telegramProgressTickRunning = true;
+  try {
+    if (!channelLiveProgressEnabled()) {
+      if (telegramTrackedProgress) {
+        if (await deleteTelegramProgress(telegramTrackedProgress.channel, telegramTrackedProgress.ts)) {
+          telegramTrackedProgress = null;
+        }
+      }
+      return;
+    }
+    const action = decideProgressAction({
+      now: Date.now(),
+      heartbeat: readTelegramProgressHeartbeat(),
+      target: findTelegramProgressTarget(),
+      tracked: telegramTrackedProgress,
+      freshnessMs: progressHeartbeatFreshMs(),
+      minPendingMs: progressMinPendingMs()
+    });
+    switch (action.type) {
+      case "post": {
+        const id = await postTelegramProgress(action.channel, action.step);
+        if (id) telegramTrackedProgress = { channel: action.channel, threadTs: action.threadTs, ts: id, lastStep: action.step };
+        break;
+      }
+      case "update": {
+        if (await updateTelegramProgress(action.channel, action.ts, action.step)) {
+          if (telegramTrackedProgress) telegramTrackedProgress.lastStep = action.step;
+        }
+        break;
+      }
+      case "delete": {
+        if (await deleteTelegramProgress(action.channel, action.ts)) {
+          telegramTrackedProgress = null;
+        }
+        break;
+      }
+      case "none":
+        break;
+    }
+  } catch {
+  } finally {
+    telegramProgressTickRunning = false;
+  }
+}
+function telegramProgressPollMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_POLL_MS ?? "", 10);
+  return Number.isFinite(raw) && raw >= 2e3 ? raw : 8e3;
+}
+if (BOT_TOKEN && PENDING_INBOUND_DIR) {
+  const telegramProgressTimer = setInterval(() => {
+    void telegramProgressTick();
+  }, telegramProgressPollMs());
+  telegramProgressTimer.unref?.();
+}
 var lastGiveUpHandledAtMs = null;
 function listPendingInboundChatIds() {
   if (!PENDING_INBOUND_DIR || !existsSync5(PENDING_INBOUND_DIR)) return [];
@@ -17922,6 +18145,7 @@ function listPendingInboundChatIds() {
         const marker = JSON.parse(
           readFileSync8(join7(PENDING_INBOUND_DIR, name), "utf8")
         );
+        if (typeof marker.seen_at === "string" && marker.seen_at) continue;
         if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
       } catch {
       }
@@ -18044,9 +18268,18 @@ function clearPendingMessage(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
     cutoffMs
   );
 }
+function markSeenPendingMessage(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
+  if (!PENDING_INBOUND_DIR || !existsSync5(PENDING_INBOUND_DIR)) return;
+  markSeenAllTelegramPendingMarkersForChat(
+    PENDING_INBOUND_DIR,
+    chatId,
+    markTelegramMarkerSeenWithHeal,
+    cutoffMs
+  );
+}
 function noteThreadActivity(chatId, cutoffMs = Number.POSITIVE_INFINITY) {
   if (!chatId) return;
-  clearPendingMessage(chatId, cutoffMs);
+  markSeenPendingMessage(chatId, cutoffMs);
 }
 var SKIP_REACTION_ON = channelSkipReactionEnabled() && TELEGRAM_SKIP_REACTION.length > 0;
 var mcp = new Server(
@@ -18062,7 +18295,7 @@ var mcp = new Server(
     instructions: [
       // Highest-priority lines first — Claude Code truncates this string at
       // 2048 chars, so anything appended late silently disappears.
-      "CRITICAL: every response to a Telegram <channel> tag MUST go through telegram.reply with the chat_id from the tag. Text in your session WITHOUT a telegram.reply call never reaches the user.",
+      "CRITICAL: every response to a Telegram <channel> tag MUST go through telegram.reply with the chat_id from the tag \u2014 typed text never reaches the user. Slow work: interim ack (telegram.reply interim:true), then your FINAL answer as a separate telegram.reply (interim omitted). An ack is not the answer.",
       'Messages from Telegram arrive as <channel source="telegram" chat_id="..." user="..." user_name="..." message_id="...">. Pass reply_to_message_id from the tag so the response lands as a quote-reply in busy chats.',
       "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call telegram.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, voice, audio, video, animations): pass file_id + chat_id verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Caption arrives as channel content. Don't surface internal file-handling errors that don't affect the answer.",
       'For work >30s follow CLAUDE.md kanban flow: kanban_add \u2192 reply "On it \u2014 tracking here: <kanban URL>" \u2192 move to in_progress \u2192 do the work \u2192 reply with the result. Simple lookups skip kanban but still reply.',
@@ -18125,6 +18358,10 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           reply_to_message_id: {
             type: "string",
             description: "Optional Telegram message_id to quote-reply to"
+          },
+          interim: {
+            type: "boolean",
+            description: 'Set true ONLY when this is an interim acknowledgement (e.g. "On it \u2014 checking now\u2026") and the real answer is still coming. The system keeps tracking this chat as awaiting your final reply. Your eventual substantive answer MUST be a separate telegram.reply with interim omitted/false \u2014 that is what marks the request complete. Omit (default false) for any reply that fully answers the user.'
           }
         },
         required: ["chat_id", "text"]
@@ -18196,7 +18433,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     return handleChannelRequestInput(args ?? {});
   }
   if (name === "telegram.reply" || name === "telegram.send_message") {
-    const { chat_id, text, reply_to_message_id } = args;
+    const { chat_id, text, reply_to_message_id, interim } = args;
     if (ALLOWED_CHATS.size > 0 && !ALLOWED_CHATS.has(chat_id)) {
       return {
         content: [{ type: "text", text: `Chat ${chat_id} is not in TELEGRAM_ALLOWED_CHATS` }],
@@ -18322,7 +18559,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       }
       recordReply(chat_id, "", tgThrottleNow, tgThrottleCfg);
       if (name === "telegram.reply") {
-        clearPendingMessage(chat_id, drainCutoffMs);
+        if (interim) markSeenPendingMessage(chat_id, drainCutoffMs);
+        else clearPendingMessage(chat_id, drainCutoffMs);
       }
       return { content: [{ type: "text", text: "sent" }] };
     } catch (err) {

package/package.json

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