@integrity-labs/agt-cli 0.28.77 → 0.28.79

package/dist/mcp/slack-channel.js

@@ -14618,6 +14618,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
     try {
       const raw = JSON.parse(readFileSync2(join2(dir, name), "utf-8"));
       if (raw.discretionary === true) continue;
+      if (typeof raw.seen_at === "string" && raw.seen_at) continue;
       receivedAt = raw.received_at;
     } catch {
       continue;
@@ -15261,34 +15262,36 @@ var defaultClearMarkerFile = (fullPath) => {
   } catch {
   }
 };
-function clearAllSlackPendingMarkersForThread(dir, channel, threadTs, clear = defaultClearMarkerFile) {
+function applyToMatchingMarkers(dir, prefix, suffix, op) {
   if (!dir) return 0;
-  const prefix = `${sanitizeMarkerSegment(channel)}__${sanitizeMarkerSegment(threadTs)}__`;
-  let cleared = 0;
+  let applied = 0;
   try {
     for (const f of readdirSync2(dir)) {
-      if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
-      clear(join5(dir, f));
-      cleared += 1;
+      if (!f.startsWith(prefix) || !f.endsWith(suffix)) continue;
+      op(join5(dir, f));
+      applied += 1;
     }
   } catch {
   }
-  return cleared;
+  return applied;
+}
+function clearAllSlackPendingMarkersForThread(dir, channel, threadTs, clear = defaultClearMarkerFile) {
+  const prefix = `${sanitizeMarkerSegment(channel)}__${sanitizeMarkerSegment(threadTs)}__`;
+  return applyToMatchingMarkers(dir, prefix, ".json", clear);
+}
+function markSeenAllSlackPendingMarkersForThread(dir, channel, threadTs, markSeen) {
+  const prefix = `${sanitizeMarkerSegment(channel)}__${sanitizeMarkerSegment(threadTs)}__`;
+  return applyToMatchingMarkers(dir, prefix, ".json", markSeen);
 }
 function clearSlackPendingMarkerByMessageTs(dir, channel, messageTs, clear = defaultClearMarkerFile) {
-  if (!dir) return 0;
   const channelPrefix = `${sanitizeMarkerSegment(channel)}__`;
   const messageSuffix = `__${sanitizeMarkerSegment(messageTs)}.json`;
-  let cleared = 0;
-  try {
-    for (const f of readdirSync2(dir)) {
-      if (!f.startsWith(channelPrefix) || !f.endsWith(messageSuffix)) continue;
-      clear(join5(dir, f));
-      cleared += 1;
-    }
-  } catch {
-  }
-  return cleared;
+  return applyToMatchingMarkers(dir, channelPrefix, messageSuffix, clear);
+}
+function markSeenSlackPendingMarkerByMessageTs(dir, channel, messageTs, markSeen) {
+  const channelPrefix = `${sanitizeMarkerSegment(channel)}__`;
+  const messageSuffix = `__${sanitizeMarkerSegment(messageTs)}.json`;
+  return applyToMatchingMarkers(dir, channelPrefix, messageSuffix, markSeen);
 }
 function clearOldestSlackPendingMarkerInChannel(dir, channel, clear = defaultClearMarkerFile) {
   if (!dir) return null;
@@ -15312,6 +15315,59 @@ function clearOldestSlackPendingMarkerInChannel(dir, channel, clear = defaultCle
   }
 }
 
+// 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;
+  }
+}
+
 // src/slack-reply-threading.ts
 function isSlackDmChannel(channel) {
   return typeof channel === "string" && channel.startsWith("D");
@@ -16953,6 +17009,18 @@ function rewriteSlackMarkerInPlace(path, marker) {
     }
   }
 }
+function markSlackMarkerSeenInPlace(fullPath) {
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (marker.seen_at) return;
+  marker.seen_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (marker.undeliverable) delete marker.undeliverable;
+  rewriteSlackMarkerInPlace(fullPath, marker);
+}
 function attachSlackReplayPayload(channel, threadTs, messageTs, payload) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path) return;
@@ -17111,6 +17179,21 @@ function clearSlackMarkerFileWithHeal(fullPath) {
   } catch {
   }
 }
+function markSlackMarkerSeenWithHeal(fullPath) {
+  let marker = null;
+  try {
+    marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.channel && marker.message_ts)
+  }) === "heal") {
+    healSlackUndeliverable(marker.channel, marker.message_ts);
+  }
+  markSlackMarkerSeenInPlace(fullPath);
+}
 function clearAllSlackPendingMarkersForThread2(channel, threadTs) {
   clearAllSlackPendingMarkersForThread(
     SLACK_PENDING_INBOUND_DIR,
@@ -17134,6 +17217,22 @@ function clearOldestSlackPendingMarkerInChannel2(channel) {
     clearSlackMarkerFileWithHeal
   );
 }
+function markSeenAllSlackPendingMarkersForThread2(channel, threadTs) {
+  markSeenAllSlackPendingMarkersForThread(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    threadTs,
+    markSlackMarkerSeenWithHeal
+  );
+}
+function markSeenSlackPendingMarkerByMessageTs2(channel, messageTs) {
+  markSeenSlackPendingMarkerByMessageTs(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    messageTs,
+    markSlackMarkerSeenWithHeal
+  );
+}
 function slackNextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
   if (!match) return null;
@@ -17380,6 +17479,160 @@ var slackOrphanSweepTimer = setInterval(() => {
   checkSlackWatchdogGiveUpNotice();
 }, orphanSweepIntervalMs());
 slackOrphanSweepTimer.unref?.();
+var SLACK_PROGRESS_HEARTBEAT_PATH = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "channel-progress-heartbeat.json") : null;
+var slackTrackedProgress = null;
+var slackProgressTickRunning = false;
+function readSlackProgressHeartbeat() {
+  if (!SLACK_PROGRESS_HEARTBEAT_PATH || !existsSync7(SLACK_PROGRESS_HEARTBEAT_PATH)) return null;
+  try {
+    return parseProgressHeartbeat(readFileSync9(SLACK_PROGRESS_HEARTBEAT_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findSlackProgressTarget() {
+  if (!SLACK_PENDING_INBOUND_DIR || !existsSync7(SLACK_PENDING_INBOUND_DIR)) return null;
+  let best = null;
+  let bestMs = Infinity;
+  try {
+    for (const name of readdirSync3(SLACK_PENDING_INBOUND_DIR)) {
+      if (!name.endsWith(".json")) continue;
+      let m;
+      try {
+        m = JSON.parse(readFileSync9(join7(SLACK_PENDING_INBOUND_DIR, name), "utf-8"));
+      } catch {
+        continue;
+      }
+      if (!m.channel || !m.thread_ts) continue;
+      if (m.discretionary === true || m.undeliverable === true) continue;
+      const ms = Date.parse(m.received_at ?? "");
+      if (!Number.isFinite(ms)) continue;
+      if (ms < bestMs) {
+        bestMs = ms;
+        best = { channel: m.channel, threadTs: m.thread_ts, receivedAtMs: ms };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return best;
+}
+var SLACK_PROGRESS_PREFIX = "\u23F3";
+function slackProgressBlocks(step) {
+  const text = `${SLACK_PROGRESS_PREFIX} _Working\u2026 \xB7 ${step}_`;
+  return [{ type: "context", elements: [{ type: "mrkdwn", text }] }];
+}
+async function postSlackProgress(channel, threadTs, step) {
+  if (!BOT_TOKEN) return null;
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({
+        channel,
+        thread_ts: threadTs,
+        text: `${SLACK_PROGRESS_PREFIX} Working\u2026 \xB7 ${step}`,
+        blocks: slackProgressBlocks(step)
+      }),
+      signal: AbortSignal.timeout(8e3)
+    });
+    const data = await res.json();
+    return data.ok && data.ts ? data.ts : null;
+  } catch {
+    return null;
+  }
+}
+async function updateSlackProgress(channel, ts, step) {
+  if (!BOT_TOKEN) return false;
+  try {
+    const res = await fetch("https://slack.com/api/chat.update", {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({
+        channel,
+        ts,
+        text: `${SLACK_PROGRESS_PREFIX} Working\u2026 \xB7 ${step}`,
+        blocks: slackProgressBlocks(step)
+      }),
+      signal: AbortSignal.timeout(8e3)
+    });
+    const data = await res.json();
+    return data.ok === true;
+  } catch {
+    return false;
+  }
+}
+async function deleteSlackProgress(channel, ts) {
+  if (!BOT_TOKEN) return false;
+  try {
+    const res = await fetch("https://slack.com/api/chat.delete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({ channel, ts }),
+      signal: AbortSignal.timeout(8e3)
+    });
+    const data = await res.json();
+    return data.ok === true || data.error === "message_not_found";
+  } catch {
+    return false;
+  }
+}
+async function slackProgressTick() {
+  if (slackProgressTickRunning) return;
+  slackProgressTickRunning = true;
+  try {
+    if (!channelLiveProgressEnabled()) {
+      if (slackTrackedProgress) {
+        if (await deleteSlackProgress(slackTrackedProgress.channel, slackTrackedProgress.ts)) {
+          slackTrackedProgress = null;
+        }
+      }
+      return;
+    }
+    const action = decideProgressAction({
+      now: Date.now(),
+      heartbeat: readSlackProgressHeartbeat(),
+      target: findSlackProgressTarget(),
+      tracked: slackTrackedProgress,
+      freshnessMs: progressHeartbeatFreshMs(),
+      minPendingMs: progressMinPendingMs()
+    });
+    switch (action.type) {
+      case "post": {
+        const ts = await postSlackProgress(action.channel, action.threadTs, action.step);
+        if (ts) slackTrackedProgress = { channel: action.channel, threadTs: action.threadTs, ts, lastStep: action.step };
+        break;
+      }
+      case "update": {
+        if (await updateSlackProgress(action.channel, action.ts, action.step)) {
+          if (slackTrackedProgress) slackTrackedProgress.lastStep = action.step;
+        }
+        break;
+      }
+      case "delete": {
+        if (await deleteSlackProgress(action.channel, action.ts)) {
+          slackTrackedProgress = null;
+        }
+        break;
+      }
+      case "none":
+        break;
+    }
+  } catch {
+  } finally {
+    slackProgressTickRunning = false;
+  }
+}
+function slackProgressPollMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_POLL_MS ?? "", 10);
+  return Number.isFinite(raw) && raw >= 2e3 ? raw : 8e3;
+}
+if (BOT_TOKEN && SLACK_PENDING_INBOUND_DIR) {
+  const slackProgressTimer = setInterval(() => {
+    void slackProgressTick();
+  }, slackProgressPollMs());
+  slackProgressTimer.unref?.();
+}
 var lastSlackGiveUpHandledAtMs = null;
 function listPendingSlackConversations() {
   if (!SLACK_PENDING_INBOUND_DIR || !existsSync7(SLACK_PENDING_INBOUND_DIR)) return [];
@@ -17394,6 +17647,7 @@ function listPendingSlackConversations() {
         if (typeof marker.channel !== "string" || !marker.channel) continue;
         if (typeof marker.thread_ts !== "string" || !marker.thread_ts) continue;
         if (marker.discretionary === true) continue;
+        if (typeof marker.seen_at === "string" && marker.seen_at) continue;
         const isThreadReply = typeof marker.message_ts === "string" && marker.message_ts !== marker.thread_ts;
         const key2 = isThreadReply ? `${marker.channel}:${marker.thread_ts}` : marker.channel;
         if (!byKey.has(key2)) {
@@ -17647,28 +17901,12 @@ function clearPendingMessage(channel, threadTs) {
 }
 function noteThreadActivity(channel, threadTs) {
   if (!channel || !threadTs) return;
-  clearPendingMessage(channel, threadTs);
+  markSeenAllSlackPendingMarkersForThread2(channel, threadTs);
 }
 function noteThreadActivityByMessageTs(channel, messageTs) {
   if (!channel || !messageTs) return;
-  clearPendingMessage(channel, messageTs);
-  if (!SLACK_PENDING_INBOUND_DIR) return;
-  if (!existsSync7(SLACK_PENDING_INBOUND_DIR)) return;
-  let filenames;
-  try {
-    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
-  } catch {
-    return;
-  }
-  const safeChannel = channel.replace(/[^A-Za-z0-9_-]/g, "_");
-  const safeMessageTs = messageTs.replace(/[^A-Za-z0-9_-]/g, "_");
-  const channelPrefix = `${safeChannel}__`;
-  const messageSuffix = `__${safeMessageTs}.json`;
-  for (const filename of filenames) {
-    if (!filename.startsWith(channelPrefix)) continue;
-    if (!filename.endsWith(messageSuffix)) continue;
-    clearSlackMarkerFileWithHeal(join7(SLACK_PENDING_INBOUND_DIR, filename));
-  }
+  markSeenAllSlackPendingMarkersForThread2(channel, messageTs);
+  markSeenSlackPendingMarkerByMessageTs2(channel, messageTs);
 }
 var RESTART_FLAGS_DIR = join7(homedir3(), ".augmented", "restart-flags");
 function buildAugmentedSlackMetadata() {
@@ -18490,7 +18728,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 Slack <channel> tag MUST go through slack.reply. Text in your session WITHOUT a slack.reply call never reaches the user \u2014 the message dies inside the agent process.",
+      "CRITICAL: every response to a Slack <channel> tag MUST go through slack.reply \u2014 typed text never reaches the user. Slow work: interim ack (slack.reply interim:true), then your FINAL answer as a separate slack.reply (interim omitted). An ack is not the answer.",
       `Inbound: <channel ... thread_ts="..." message_ts="..." [thread_context="..."]>. Pass channel + message_ts to slack.reply (and thread_ts on threads). thread_context = thread pre-loaded; ground replies ONLY in it, never another channel's.`,
       "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 slack.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, csv): pass file_id + channel verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Don't surface internal file-handling errors that don't affect the answer.",
       "Address users by user_name, never by raw user ID. In multi-participant threads the CURRENT speaker is the one on the latest <channel> tag.",
@@ -18528,6 +18766,12 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           message_ts: {
             type: "string",
             description: "The message_ts of the specific inbound this reply addresses (from the message_ts attribute on the <channel> tag). Used by the pending-inbound cleanup gate so the marker is reliably cleared even for top-level DMs that have no thread_ts."
+          },
+          // ENG-6567: explicit interim/final distinction so the system knows
+          // whether the agent still owes a substantive answer.
+          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 conversation as awaiting your final reply. Your eventual substantive answer MUST be a separate slack.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: ["channel", "text"]
@@ -18754,7 +18998,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     return buildImpersonationRefusal(name);
   }
   if (name === "slack.reply") {
-    const { channel, text, thread_ts, message_ts } = args;
+    const { channel, text, thread_ts, message_ts, interim } = args;
     const effectiveThreadTs = resolveReplyThreadTs({
       channel,
       threadTs: thread_ts,
@@ -18818,16 +19062,23 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
-    if (channel) {
+    const settlePendingMarker = () => {
+      if (!channel) return;
       if (message_ts) {
-        clearSlackPendingMarkerByMessageTs2(channel, message_ts);
-        if (thread_ts) clearPendingMessage(channel, thread_ts);
+        if (interim) {
+          markSeenSlackPendingMarkerByMessageTs2(channel, message_ts);
+          if (thread_ts) markSeenAllSlackPendingMarkersForThread2(channel, thread_ts);
+        } else {
+          clearSlackPendingMarkerByMessageTs2(channel, message_ts);
+          if (thread_ts) clearPendingMessage(channel, thread_ts);
+        }
       } else if (thread_ts) {
-        clearPendingMessage(channel, thread_ts);
-      } else {
+        if (interim) markSeenAllSlackPendingMarkersForThread2(channel, thread_ts);
+        else clearPendingMessage(channel, thread_ts);
+      } else if (!interim) {
         clearOldestSlackPendingMarkerInChannel2(channel);
       }
-    }
+    };
     try {
       const res = await fetch("https://slack.com/api/chat.postMessage", {
         method: "POST",
@@ -18851,6 +19102,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           isError: true
         };
       }
+      settlePendingMarker();
       recordReply(channel, throttleKey, throttleNow, throttleCfg);
       recordActivity("reply");
       if (THREAD_AUTO_FOLLOW !== "off") {
@@ -19290,7 +19542,6 @@ async function handleSendStructured(args) {
   if (typeof text !== "string" || !text) {
     return errResult("text is required (used as fallback for push notifications and unfurls)");
   }
-  noteThreadActivity(channel, thread_ts);
   const validation = validateSlackBlocks2(blocks);
   if (!validation.ok) {
     return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
@@ -19304,6 +19555,7 @@ async function handleSendStructured(args) {
   if (!result.ok || !result.ts) {
     return errResult(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
   }
+  if (thread_ts) clearPendingMessage(channel, thread_ts);
   if (interactiveHostAvailable()) {
     const cfg = {
       apiHost: AGT_HOST,

package/dist/mcp/telegram-channel.js

@@ -16430,6 +16430,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
     try {
       const raw = JSON.parse(readFileSync7(join6(dir, name), "utf-8"));
       if (raw.discretionary === true) continue;
+      if (typeof raw.seen_at === "string" && raw.seen_at) continue;
       receivedAt = raw.received_at;
     } catch {
       continue;

package/dist/{persistent-session-Z3RHQRVC.js → persistent-session-U6P5I6TT.js}

@@ -25,8 +25,8 @@ import {
   takeZombieDetection,
   writeDirectChatSessionState,
   writePersistentClaudeWrapper
-} from "./chunk-PEVDRQJA.js";
-import "./chunk-XHKMS4UY.js";
+} from "./chunk-XDZFMTY5.js";
+import "./chunk-3KLQA3SC.js";
 import "./chunk-XWVM4KPK.js";
 export {
   SEND_KEYS_ENTER_DELAY_MS,
@@ -56,4 +56,4 @@ export {
   writeDirectChatSessionState,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-Z3RHQRVC.js.map
+//# sourceMappingURL=persistent-session-U6P5I6TT.js.map

package/dist/{responsiveness-probe-QWO75M34.js → responsiveness-probe-VKIJY4IC.js}

@@ -1,7 +1,7 @@
 import {
   paneLogPath
-} from "./chunk-PEVDRQJA.js";
-import "./chunk-XHKMS4UY.js";
+} from "./chunk-XDZFMTY5.js";
+import "./chunk-3KLQA3SC.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -250,4 +250,4 @@ export {
   parkPendingInbound,
   readAndResetChannelDeflections
 };
-//# sourceMappingURL=responsiveness-probe-QWO75M34.js.map
+//# sourceMappingURL=responsiveness-probe-VKIJY4IC.js.map

package/package.json

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