@integrity-labs/agt-cli 0.28.550 → 0.28.552

package/dist/mcp/slack-channel.js

@@ -37442,6 +37442,47 @@ var SLACK_EGRESS_TOOLS = /* @__PURE__ */ new Set([
   "slack.update"
 ]);
 
+// ../core/dist/channels/governance/slack-ingress-only-threads.js
+function buildIngressThreadKey(channel, threadTs) {
+  if (!channel || !threadTs)
+    return null;
+  return `${channel}:${threadTs}`;
+}
+function createIngressOnlyThreadRegistry(maxEntries = 500) {
+  const marked = /* @__PURE__ */ new Set();
+  return {
+    mark(channel, threadTs) {
+      const key2 = buildIngressThreadKey(channel, threadTs);
+      if (!key2)
+        return;
+      marked.delete(key2);
+      marked.add(key2);
+      while (marked.size > maxEntries) {
+        const oldest = marked.values().next();
+        if (oldest.done)
+          break;
+        marked.delete(oldest.value);
+      }
+    },
+    clear(channel, threadTs) {
+      const key2 = buildIngressThreadKey(channel, threadTs);
+      if (!key2)
+        return;
+      marked.delete(key2);
+    },
+    isIngressOnly(channel, threadTs) {
+      const key2 = buildIngressThreadKey(channel, threadTs);
+      if (!key2)
+        return false;
+      return marked.has(key2);
+    },
+    size() {
+      return marked.size;
+    }
+  };
+}
+var INGRESS_ONLY_REFUSAL = "This thread was opened by a third-party bot (an alert or issue card), which can wake you but is not someone you can talk to - replying would start a bot-to-bot exchange in a shared channel. Act on the content instead: work the issue, or raise it with a person in a thread they are in. If a human posts here, this thread becomes repliable.";
+
 // src/strip-repost-preamble.ts
 var PRIOR_ATTEMPT_CUE = /\b(a moment ago|just now|a second ago|earlier|moments ago|previously|last (?:time|attempt)|drafted|dialled|dialed|typed|composed|wrote|sent) (?:this|that|it)?\b|\b(?:drafted|dialled|dialed|typed|composed)\b/i;
 var FAILURE_CUE = /\b(?:did(?:n['’]t| not)|could(?:n['’]t| not)|would(?:n['’]t| not)|wasn['’]t|fail(?:ed)?|never)\b[^.!?\n]*?\b(?:parse[d]?|send|sent|go through|went through|land|deliver(?:ed)?|post(?:ed)?|come through|came through)\b/i;
@@ -39956,6 +39997,16 @@ function classifyPeerMessage(msg, cfg, self) {
   }
   const peer = cfg.peers.find((p2) => p2.bot_user_id === msg.user);
   if (!peer) {
+    const thirdParty = cfg.third_party_bots?.find((b) => b.bot_user_id === msg.user);
+    if (thirdParty) {
+      if (cfg.peer_disabled_mode === "cross_team_only") {
+        return { kind: "drop", reason: "peer_disabled_cross_team" };
+      }
+      if (thirdParty.channel_ids.includes(msg.channel)) {
+        return { kind: "bot-ingress", bot: thirdParty };
+      }
+      return { kind: "drop", reason: "third_party_channel_not_allowlisted" };
+    }
     return { kind: "drop", reason: "unknown_peer" };
   }
   if (peer.gate_path === null) {
@@ -40063,6 +40114,33 @@ function parsePeerGroupIdsEnv(raw) {
     return [];
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function parseThirdPartyBotsEnv(raw) {
+  if (!raw || !raw.trim())
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed))
+    return [];
+  const out = [];
+  for (const item of parsed) {
+    if (!item || typeof item !== "object")
+      continue;
+    const rec = item;
+    const botUserId2 = typeof rec["bot_user_id"] === "string" ? rec["bot_user_id"].trim() : "";
+    if (!botUserId2)
+      continue;
+    if (!Array.isArray(rec["channel_ids"]))
+      continue;
+    const channels = rec["channel_ids"].filter((c) => typeof c === "string" && c.trim() !== "").map((c) => c.trim());
+    const label = typeof rec["label"] === "string" && rec["label"].trim() ? rec["label"].trim() : void 0;
+    out.push({ bot_user_id: botUserId2, channel_ids: channels, ...label ? { label } : {} });
+  }
+  return out;
+}
 function parsePeerAgentModeEnv(raw) {
   if (raw === "listen" || raw === "respond")
     return raw;
@@ -41074,8 +41152,14 @@ var SLACK_PEER_CLASSIFIER_CONFIG = {
   peer_agent_mode: parsePeerAgentModeEnv(process.env.SLACK_PEER_AGENT_MODE),
   peer_group_ids: parsePeerGroupIdsEnv(process.env.SLACK_PEER_GROUP_IDS),
   peers: parsePeersEnv(process.env.SLACK_PEERS, process.env.SLACK_PEERS_GATE),
-  peer_disabled_mode: SLACK_PEER_DISABLED_MODE
+  peer_disabled_mode: SLACK_PEER_DISABLED_MODE,
+  // ENG-8669: third-party bots (Linear, Amazon Q, CloudWatch, PagerDuty) that
+  // may WAKE this agent, per channel. Absent env = empty = the pre-ENG-8669
+  // behaviour exactly, so this ships inert for every agent that has not opted
+  // in. Ingress-only by construction - see isReplyEligible in the classifier.
+  third_party_bots: parseThirdPartyBotsEnv(process.env.SLACK_THIRD_PARTY_BOTS)
 };
+var ingressOnlyThreads = createIngressOnlyThreadRegistry();
 var SLACK_TEAM_PEER_USER_IDS = parseTeamPeerUserIdsEnv(
   process.env.SLACK_TEAM_PEER_USER_IDS
 );
@@ -43815,6 +43899,16 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   if (isImpersonating() && !channelsEnabledOverride() && SLACK_EGRESS_TOOLS.has(name)) {
     return buildImpersonationRefusal(name);
   }
+  if (SLACK_EGRESS_TOOLS.has(name)) {
+    const egressArgs = args ?? {};
+    const targetThread = egressArgs.thread_ts ?? egressArgs.message_ts;
+    if (ingressOnlyThreads.isIngressOnly(egressArgs.channel, targetThread)) {
+      return {
+        content: [{ type: "text", text: INGRESS_ONLY_REFUSAL }],
+        isError: true
+      };
+    }
+  }
   if (name === "slack.reply") {
     const { channel, text, thread_ts, message_ts, interim, inbound_id, proactive, to_channel_root } = args;
     const bindingMode = slackReplyBindingMode();
@@ -45491,6 +45585,12 @@ async function connectSocketMode() {
       });
       const passedIdentity = access.kind !== "drop" || access.reason.startsWith("peer:");
       if (passedIdentity) recordActivity("inbound");
+      const ingressThreadTs = evt.thread_ts ?? evt.ts;
+      if (peerClassification?.kind === "bot-ingress" && access.kind !== "drop") {
+        ingressOnlyThreads.mark(evt.channel, ingressThreadTs);
+      } else if (!isBot) {
+        ingressOnlyThreads.clear(evt.channel, ingressThreadTs);
+      }
       if (access.kind === "drop") {
         const channelHash = createHash3("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
         const subtypeSuffix = access.reason === "content:subtype" ? ` subtype=${evt.subtype ?? "none"}` : "";

package/package.json

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