@integrity-labs/agt-cli 0.28.237 → 0.28.238

package/dist/mcp/slack-channel.js

@@ -16256,18 +16256,18 @@ import {
   ftruncateSync,
   mkdirSync as mkdirSync8,
   openSync,
-  readFileSync as readFileSync10,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync14,
+  readdirSync as readdirSync4,
   renameSync as renameSync4,
   statSync as statSync2,
   unlinkSync as unlinkSync5,
   watch,
-  writeFileSync as writeFileSync10,
+  writeFileSync as writeFileSync12,
   writeSync
 } from "fs";
-import { basename, join as join9, resolve as resolve2 } from "path";
+import { basename, join as join13, resolve as resolve2 } from "path";
 import { homedir as homedir4 } from "os";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 
 // src/slack-thread-store.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
@@ -16549,8 +16549,46 @@ async function runOrRetry(fn, opts) {
 }
 
 // src/turn-initiator-marker.ts
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, renameSync as renameSync2 } from "fs";
-import { dirname as dirname4 } from "path";
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync7, mkdirSync as mkdirSync5, renameSync as renameSync2 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+var TURN_INITIATOR_MAX_AGE_MS = 5 * 60 * 1e3;
+var TURN_INITIATOR_LEDGER_MAX_ENTRIES = 20;
+var TURN_INITIATOR_LEDGER_FILENAME = ".turn-initiator-ledger.json";
+function turnInitiatorLedgerPath(singleSlotFile) {
+  return join7(dirname4(singleSlotFile), TURN_INITIATOR_LEDGER_FILENAME);
+}
+function foldTurnInitiatorLedger(existing, marker, maxAgeMs = TURN_INITIATOR_MAX_AGE_MS, maxEntries = TURN_INITIATOR_LEDGER_MAX_ENTRIES) {
+  const now = marker.ts;
+  const key2 = (e) => `${e.channel}\0${e.channel_ref ?? ""}`;
+  const markerKey = key2(marker);
+  const prior = existing && Array.isArray(existing.entries) ? existing.entries : [];
+  const kept = prior.filter(
+    (e) => e && typeof e.ts === "number" && Number.isFinite(e.ts) && now - e.ts <= maxAgeMs && now - e.ts >= 0 && key2(e) !== markerKey
+    // the same thread is replaced by the new entry below
+  );
+  kept.push({
+    channel: marker.channel,
+    sender_id: marker.sender_id,
+    ...marker.sender_name ? { sender_name: marker.sender_name } : {},
+    ...marker.channel_ref ? { channel_ref: marker.channel_ref } : {},
+    ts: marker.ts
+  });
+  kept.sort((a, b) => b.ts - a.ts);
+  return { v: 1, entries: kept.slice(0, maxEntries) };
+}
+function updateTurnInitiatorLedger(singleSlotFile, marker) {
+  const ledgerFile = turnInitiatorLedgerPath(singleSlotFile);
+  let existing = null;
+  try {
+    const parsed = JSON.parse(readFileSync7(ledgerFile, "utf8"));
+    if (parsed && parsed.v === 1 && Array.isArray(parsed.entries)) existing = parsed;
+  } catch {
+  }
+  const next = foldTurnInitiatorLedger(existing, marker);
+  const tmp = `${ledgerFile}.tmp`;
+  writeFileSync6(tmp, JSON.stringify(next), "utf8");
+  renameSync2(tmp, ledgerFile);
+}
 function writeTurnInitiatorMarker(input) {
   const file = process.env["AGT_TURN_INITIATOR_FILE"];
   if (!file || !input.sender_id) return;
@@ -16560,12 +16598,16 @@ function writeTurnInitiatorMarker(input) {
     const tmp = `${file}.tmp`;
     writeFileSync6(tmp, JSON.stringify(marker), "utf8");
     renameSync2(tmp, file);
+    try {
+      updateTurnInitiatorLedger(file, marker);
+    } catch {
+    }
   } catch {
   }
 }
 
 // src/slack-bot-photo.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname5 } from "path";
 async function applyBotPhoto(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
@@ -16575,7 +16617,7 @@ async function applyBotPhoto(opts) {
   const { token, avatarUrl, markerPath } = opts;
   if (markerPath && existsSync6(markerPath)) {
     try {
-      if (readFileSync7(markerPath, "utf-8").trim() === avatarUrl) {
+      if (readFileSync8(markerPath, "utf-8").trim() === avatarUrl) {
         return { status: "skipped-unchanged" };
       }
     } catch {
@@ -16700,8 +16742,8 @@ function conversationalLaneMeta(expectsReply = true) {
 }
 
 // src/inbound-lane-telemetry.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { join as join8 } from "path";
 var LANE_CLASSIFICATION_COUNTER_SUFFIX = "-lane-classifications.json";
 var SUSPECTED_MISCLASSIFICATION_KEY = "suspected_misclassification";
 var HUMAN_CHANNEL_SOURCES = /* @__PURE__ */ new Set([
@@ -16718,10 +16760,10 @@ function isSuspectedMisclassification(lane, source) {
 }
 function recordLaneClassification(agentDir, channel, classification) {
   if (!agentDir) return;
-  const path = join7(agentDir, `${channel}${LANE_CLASSIFICATION_COUNTER_SUFFIX}`);
+  const path = join8(agentDir, `${channel}${LANE_CLASSIFICATION_COUNTER_SUFFIX}`);
   let counts = {};
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
     if (parsed && typeof parsed === "object") counts = parsed;
   } catch {
   }
@@ -16736,6 +16778,333 @@ function recordLaneClassification(agentDir, channel, classification) {
   }
 }
 
+// src/slack-inbound-registry.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
+import { join as join9 } from "path";
+var DEFAULT_MAX_ENTRIES = 500;
+var DEFAULT_CLEARED_TTL_MS = 6 * 60 * 60 * 1e3;
+function entryKey(channel, messageTs) {
+  return `${channel}\0${messageTs}`;
+}
+function createInboundRegistry(opts = {}) {
+  const maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const clearedTtlMs = opts.clearedTtlMs ?? DEFAULT_CLEARED_TTL_MS;
+  const now = opts.now ?? Date.now;
+  const entries = /* @__PURE__ */ new Map();
+  function prune() {
+    const cutoff = now() - clearedTtlMs;
+    for (const [key2, e] of entries) {
+      if (e.clearedAt !== void 0 && e.clearedAt < cutoff) entries.delete(key2);
+    }
+    if (entries.size <= maxEntries) return;
+    for (const [key2, e] of entries) {
+      if (entries.size <= maxEntries) break;
+      if (e.clearedAt !== void 0) entries.delete(key2);
+    }
+    for (const key2 of entries.keys()) {
+      if (entries.size <= maxEntries) break;
+      entries.delete(key2);
+    }
+  }
+  function record2(i) {
+    const key2 = entryKey(i.channel, i.messageTs);
+    entries.delete(key2);
+    entries.set(key2, { ...i });
+    prune();
+  }
+  function markCleared(channel, messageTs) {
+    const e = entries.get(entryKey(channel, messageTs));
+    if (e && e.clearedAt === void 0) e.clearedAt = now();
+  }
+  function markClearedThread(channel, threadTs) {
+    const t = now();
+    for (const e of entries.values()) {
+      if (e.channel === channel && e.threadTs === threadTs && e.clearedAt === void 0) {
+        e.clearedAt = t;
+      }
+    }
+  }
+  function markClearedOldestInChannel(channel) {
+    let oldest = null;
+    for (const e of entries.values()) {
+      if (e.channel !== channel || e.clearedAt !== void 0) continue;
+      if (oldest === null || e.receivedAt < oldest.receivedAt) oldest = e;
+    }
+    if (oldest) oldest.clearedAt = now();
+  }
+  function byInboundId(id) {
+    if (!id) return null;
+    for (const e of entries.values()) {
+      if (e.inboundId === id) return e;
+    }
+    return null;
+  }
+  function byCoords(channel, threadOrMessageTs) {
+    let best = null;
+    let bestExact = false;
+    for (const e of entries.values()) {
+      if (e.channel !== channel) continue;
+      const exact = e.messageTs === threadOrMessageTs;
+      const thread = e.threadTs === threadOrMessageTs;
+      if (!exact && !thread) continue;
+      if (best === null) {
+        best = e;
+        bestExact = exact;
+        continue;
+      }
+      if (exact && !bestExact) {
+        best = e;
+        bestExact = true;
+      } else if (exact === bestExact && e.receivedAt >= best.receivedAt) {
+        best = e;
+      }
+    }
+    return best;
+  }
+  function livePending() {
+    const out = [];
+    for (const e of entries.values()) {
+      if (e.clearedAt === void 0) out.push(e);
+    }
+    return out;
+  }
+  function seedFromMarkerDir(dir) {
+    let names;
+    try {
+      names = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json") || name.startsWith(".")) continue;
+      if (name.includes(".retry-") || name.includes(".poison")) continue;
+      let marker;
+      try {
+        marker = JSON.parse(readFileSync10(join9(dir, name), "utf-8"));
+      } catch {
+        continue;
+      }
+      const channel = typeof marker.channel === "string" ? marker.channel : "";
+      const threadTs = typeof marker.thread_ts === "string" ? marker.thread_ts : "";
+      const messageTs = typeof marker.message_ts === "string" ? marker.message_ts : "";
+      if (!channel || !messageTs) continue;
+      const receivedRaw = typeof marker.received_at === "string" ? Date.parse(marker.received_at) : NaN;
+      record2({
+        inboundId: typeof marker.inbound_id === "string" ? marker.inbound_id : "",
+        channel,
+        threadTs: threadTs || messageTs,
+        // top-level markers may omit thread_ts
+        messageTs,
+        user: "",
+        // markers don't persist the sender - unknown after restart
+        userName: "",
+        receivedAt: Number.isFinite(receivedRaw) ? receivedRaw : now()
+      });
+    }
+  }
+  return {
+    record: record2,
+    markCleared,
+    markClearedThread,
+    markClearedOldestInChannel,
+    byInboundId,
+    byCoords,
+    livePending,
+    seedFromMarkerDir,
+    size: () => entries.size
+  };
+}
+
+// src/slack-inbound-id.ts
+import { createHash } from "crypto";
+var INBOUND_ID_HEX_LEN = 12;
+function slackInboundId(channel, threadTs, messageTs) {
+  const digest = createHash("sha256").update(`${channel}|${threadTs}|${messageTs}`).digest("hex").slice(0, INBOUND_ID_HEX_LEN);
+  return `ib_${digest}`;
+}
+
+// src/slack-reply-binding.ts
+function matchByCoords(registry2, channel, messageTs, threadTs) {
+  if (!channel) return null;
+  return (messageTs ? registry2.byCoords(channel, messageTs) : null) ?? (threadTs ? registry2.byCoords(channel, threadTs) : null);
+}
+function describeLivePending(registry2, now) {
+  const live = registry2.livePending();
+  if (live.length === 0) return "none";
+  return live.slice(0, 8).map((i) => {
+    const ageS = Math.max(0, Math.floor((now - i.receivedAt) / 1e3));
+    const who = i.userName || i.user || "unknown";
+    const id = i.inboundId || "(no id)";
+    return `${id} (${who}, ${ageS}s ago)`;
+  }).join("; ");
+}
+function resolveReplyBinding(input) {
+  const { mode, args, registry: registry2 } = input;
+  const now = input.now ?? Date.now();
+  const modelChannel = args.channel;
+  const modelThread = args.thread_ts;
+  if (args.inbound_id) {
+    const known = registry2.byInboundId(args.inbound_id);
+    if (known) {
+      const conflict = !!modelChannel && modelChannel !== known.channel || !!modelThread && modelThread !== known.threadTs;
+      return {
+        channel: known.channel,
+        threadTs: known.threadTs,
+        classification: conflict ? "coords_corrected" : "bound",
+        unknownInboundId: false
+      };
+    }
+    if (args.proactive === true) {
+      return {
+        channel: modelChannel,
+        threadTs: modelThread,
+        classification: "proactive",
+        unknownInboundId: true
+      };
+    }
+    return classifyByCoords(mode, args, registry2, now, true);
+  }
+  if (args.proactive === true) {
+    return {
+      channel: modelChannel,
+      threadTs: modelThread,
+      classification: "proactive",
+      unknownInboundId: false
+    };
+  }
+  return classifyByCoords(mode, args, registry2, now, false);
+}
+function classifyByCoords(mode, args, registry2, now, unknownInboundId) {
+  const modelChannel = args.channel;
+  const modelThread = args.thread_ts;
+  const matched = matchByCoords(registry2, modelChannel, args.message_ts, modelThread);
+  if (matched) {
+    return {
+      channel: modelChannel ?? matched.channel,
+      threadTs: modelThread ?? matched.threadTs,
+      classification: "coords_match",
+      unknownInboundId
+    };
+  }
+  if (registry2.size() === 0) {
+    return {
+      channel: modelChannel,
+      threadTs: modelThread,
+      classification: "legacy",
+      unknownInboundId
+    };
+  }
+  const decision = {
+    channel: modelChannel,
+    threadTs: modelThread,
+    classification: "unknown_target",
+    unknownInboundId
+  };
+  if (mode === "warn") {
+    decision.agentFeedback = `Note: this reply does not match any message you received. If it is a self-initiated message set proactive:true; otherwise reply with the inbound_id of the message you are answering. Live inbounds awaiting a reply: ${describeLivePending(registry2, now)}.`;
+  } else if (mode === "enforce") {
+    decision.reject = `This reply was blocked: its target does not match any message you received, so it may be going to the wrong thread. Reply with the inbound_id of the message you are answering, or set proactive:true for a self-initiated message. Live inbounds: ${describeLivePending(registry2, now)}.`;
+  }
+  return decision;
+}
+
+// src/slack-mcp-instructions.ts
+function buildSlackMcpInstructions(opts) {
+  const { ackReaction, skipReactionOn, skipReaction } = opts;
+  return [
+    "CRITICAL: every response to a Slack <channel> tag MUST go through slack.reply - 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 ... inbound_id="ib_..." message_ts="..." [thread_context="..."]>. Reply with slack.reply passing inbound_id (copy it verbatim from the tag you are answering) + text; the server routes it to the right thread. Multiple <channel> tags = separate conversations: NEVER answer one user in another's inbound_id/thread. thread_context = pre-loaded thread; ground replies ONLY in it. For a self-initiated message (not a reply) set proactive:true.`,
+    "Attachments: <channel> `files` is a JSON string - JSON.parse it. Entry with `path` (or a top-level `image_path`) is already downloaded - Read it; do NOT call slack.download_attachment. Only entries with `file_id` and no `path` (PDF/docx/csv) need slack.download_attachment (pass file_id + channel), then Read the returned path. Don't surface file-handling errors that don't affect the answer.",
+    "Address users by user_name, never raw user ID. In multi-participant threads the CURRENT speaker is on the latest <channel> tag.",
+    `Reactions (slack.react sparingly - prefer a reply): :${ackReaction}: = ack (auto-added on inbound, don't duplicate); \u2705 = success.` + (skipReactionOn ? ` "${skipReaction}" = seen, not replying.` : "") + " NEVER react to signal failure of your work - on failure slack.reply one sentence explaining it (no stack traces/secrets). \u23F3 and \u274C are system-only; never add them.",
+    skipReactionOn ? `Decided NOT to reply to a DM or thread message (different @-mention, side chat, auto_followed catch-up, nothing useful)? slack.react with "${skipReaction}" so the sender knows you saw it - never post "this wasn't for me". Top-level channel messages you may skip silently.` : "A thread message NOT addressed to you (different @-mention, side chat, auto_followed catch-up): SILENTLY SKIP - no reaction, no reply.",
+    'auto_followed="true" \u2192 reply only if useful OR your bot user is @-mentioned. Deliver a file: save under your project dir, call slack.upload_file with path + channel + inbound_id.'
+  ].join(" ");
+}
+
+// src/slack-reply-binding-telemetry.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join10 } from "path";
+var REPLY_BINDING_CLASSIFICATION_COUNTER_SUFFIX = "-reply-binding-classifications.json";
+var UNKNOWN_INBOUND_ID_KEY = "unknown_inbound_id";
+var VALID_MODES = /* @__PURE__ */ new Set(["shadow", "warn", "enforce"]);
+function slackReplyBindingMode() {
+  const raw = process.env["AGT_SLACK_REPLY_BINDING"];
+  if (raw && VALID_MODES.has(raw)) return raw;
+  return "shadow";
+}
+function recordReplyBindingClassification(agentDir, channel, input) {
+  if (!agentDir) return;
+  const path = join10(agentDir, `${channel}${REPLY_BINDING_CLASSIFICATION_COUNTER_SUFFIX}`);
+  let counts = {};
+  try {
+    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    if (parsed && typeof parsed === "object") counts = parsed;
+  } catch {
+  }
+  counts[input.classification] = (counts[input.classification] ?? 0) + 1;
+  if (input.unknownInboundId) {
+    counts[UNKNOWN_INBOUND_ID_KEY] = (counts[UNKNOWN_INBOUND_ID_KEY] ?? 0) + 1;
+  }
+  try {
+    writeFileSync9(path, JSON.stringify(counts), { mode: 384 });
+  } catch {
+  }
+}
+
+// src/slack-reply-target-telemetry.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { join as join11 } from "path";
+var REPLY_TARGET_CLASSIFICATION_COUNTER_SUFFIX = "-reply-target-classifications.json";
+function pendingThreadsBucket(n) {
+  if (n <= 0) return "0";
+  if (n === 1) return "1";
+  if (n === 2) return "2";
+  return "3plus";
+}
+function replyTargetKey(result, bucket) {
+  return `${result}|${bucket}`;
+}
+function classifyReplyTarget(input) {
+  const { channel, threadTs, messageTs, registry: registry2 } = input;
+  const pending = registry2.livePending();
+  const pendingThreadKeys = new Set(pending.map((p) => `${p.channel} ${p.threadTs}`));
+  const pendingThreads = pendingThreadKeys.size;
+  const targetThread = threadTs ?? messageTs;
+  const targetThreadPending = targetThread !== void 0 && pendingThreadKeys.has(`${channel} ${targetThread}`);
+  const matched = (messageTs ? registry2.byCoords(channel, messageTs) : null) ?? (threadTs ? registry2.byCoords(channel, threadTs) : null);
+  let result;
+  if (!matched) {
+    result = "unknown_target";
+  } else if (matched.clearedAt === void 0 || targetThreadPending) {
+    result = "matched_pending";
+  } else if (pendingThreads > 0) {
+    result = "crossed_candidate";
+  } else {
+    result = "matched_recent";
+  }
+  return { result, pendingThreads };
+}
+function recordReplyTargetClassification(agentDir, channel, classification) {
+  if (!agentDir) return;
+  const path = join11(agentDir, `${channel}${REPLY_TARGET_CLASSIFICATION_COUNTER_SUFFIX}`);
+  let counts = {};
+  try {
+    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
+    if (parsed && typeof parsed === "object") counts = parsed;
+  } catch {
+  }
+  const key2 = replyTargetKey(
+    classification.result,
+    pendingThreadsBucket(classification.pendingThreads)
+  );
+  counts[key2] = (counts[key2] ?? 0) + 1;
+  try {
+    writeFileSync10(path, JSON.stringify(counts), { mode: 384 });
+  } catch {
+  }
+}
+
 // src/slack-allowlist-source.ts
 function parseAllowedUsersCsv(raw) {
   return new Set(
@@ -17402,12 +17771,12 @@ async function actuateHostRestart(opts) {
 import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync13,
   renameSync as renameSync3,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync11
 } from "fs";
-import { join as join8 } from "path";
+import { join as join12 } from "path";
 function defaultIsPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -17425,7 +17794,7 @@ function acquireMcpSpawnLock(args) {
   const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
   const selfPid = options.selfPid ?? process.pid;
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const path = join8(agentDir, basename2);
+  const path = join12(agentDir, basename2);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -17438,7 +17807,7 @@ function acquireMcpSpawnLock(args) {
   mkdirSync7(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync9(tmpPath, JSON.stringify(payload), { mode: 384 });
+  writeFileSync11(tmpPath, JSON.stringify(payload), { mode: 384 });
   renameSync3(tmpPath, path);
   return { kind: "acquired", path };
 }
@@ -17456,7 +17825,7 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
 function readLockHolder(path) {
   if (!existsSync7(path)) return null;
   try {
-    const raw = readFileSync9(path, "utf8");
+    const raw = readFileSync13(path, "utf8");
     const parsed = JSON.parse(raw);
     const pid = typeof parsed.pid === "number" ? parsed.pid : Number(parsed.pid);
     if (!Number.isFinite(pid) || pid <= 0) return null;
@@ -17690,8 +18059,8 @@ var SLACK_TEAM_PEER_USER_IDS = parseTeamPeerUserIdsEnv(
   process.env.SLACK_TEAM_PEER_USER_IDS
 );
 var PEER_HINT_SEEN = /* @__PURE__ */ new Set();
-var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join9(homedir4(), ".augmented", AGENT_CODE_NAME) : null;
-var SLACK_MCP_CONFIG_PATH = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "project", ".mcp.json") : null;
+var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join13(homedir4(), ".augmented", AGENT_CODE_NAME) : null;
+var SLACK_MCP_CONFIG_PATH = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "project", ".mcp.json") : null;
 var liveAllowedUsersCache = null;
 function readLiveAllowedUsers() {
   if (!SLACK_MCP_CONFIG_PATH) return null;
@@ -17701,7 +18070,7 @@ function readLiveAllowedUsers() {
       return liveAllowedUsersCache.value;
     }
     const value = extractAllowedUsersFromMcpJson(
-      readFileSync10(SLACK_MCP_CONFIG_PATH, "utf-8")
+      readFileSync14(SLACK_MCP_CONFIG_PATH, "utf-8")
     );
     if (value === null) return null;
     liveAllowedUsersCache = { mtimeMs, value };
@@ -17722,7 +18091,7 @@ function readLivePingAllowedUsers() {
       return livePingAllowedUsersCache.value;
     }
     const value = extractPingAllowedUsersFromMcpJson(
-      readFileSync10(SLACK_MCP_CONFIG_PATH, "utf-8")
+      readFileSync14(SLACK_MCP_CONFIG_PATH, "utf-8")
     );
     if (value === null) return null;
     livePingAllowedUsersCache = { mtimeMs, value };
@@ -17734,16 +18103,17 @@ function readLivePingAllowedUsers() {
 function getEffectivePingAllowedUsers() {
   return readLivePingAllowedUsers() ?? PING_ALLOWED_USERS;
 }
-var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
-var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
-var SLACK_RESTART_CONFIRM_FILE = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-restart-confirm.json") : null;
-var SLACK_RECENT_DMS_FILE = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-recent-dms.json") : null;
-var SLACK_CHANNEL_ADD_RESTART_FILE = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-channel-add-restart.json") : null;
+var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
+var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
+var slackInboundRegistry = createInboundRegistry();
+var SLACK_RESTART_CONFIRM_FILE = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-restart-confirm.json") : null;
+var SLACK_RECENT_DMS_FILE = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-recent-dms.json") : null;
+var SLACK_CHANNEL_ADD_RESTART_FILE = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-channel-add-restart.json") : null;
 var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
-var SLACK_AVATAR_MARKER_PATH = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-avatar-applied") : null;
+var SLACK_AVATAR_MARKER_PATH = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-avatar-applied") : null;
 function redactSlackId(id) {
   if (!id) return "<none>";
-  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(id).digest("hex").slice(0, 8);
 }
 function safeSlackMarkerName(channel, threadTs, messageTs) {
   const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
@@ -17751,7 +18121,7 @@ function safeSlackMarkerName(channel, threadTs, messageTs) {
 }
 function slackPendingInboundPath(channel, threadTs, messageTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return null;
-  return join9(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
+  return join13(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
 }
 function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false, discretionary = false, payload) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
@@ -17761,6 +18131,10 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
     thread_ts: threadTs,
     message_ts: messageTs,
     received_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // WS2: the deterministic inbound id. Always written (derivable from the
+    // coords, marker-semantics-neutral) so a marker recovered after a restart
+    // carries the same id the tag emitted.
+    inbound_id: slackInboundId(channel, threadTs, messageTs),
     // Only persist the flags when set — keeps healthy-path markers byte-identical.
     ...undeliverable ? { undeliverable: true } : {},
     ...discretionary ? { discretionary: true } : {},
@@ -17770,7 +18144,7 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
   };
   try {
     mkdirSync8(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync10(path, JSON.stringify(marker), { mode: 384 });
+    writeFileSync12(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -17798,7 +18172,7 @@ function rewriteSlackMarkerInPlace(path, marker) {
 function markSlackMarkerSeenInPlace(fullPath) {
   let marker;
   try {
-    marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
   } catch {
     return;
   }
@@ -17812,7 +18186,7 @@ function attachSlackReplayPayload(channel, threadTs, messageTs, payload) {
   if (!path) return;
   let marker;
   try {
-    marker = JSON.parse(readFileSync10(path, "utf-8"));
+    marker = JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return;
   }
@@ -17823,7 +18197,7 @@ function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !existsSync8(path)) return null;
   try {
-    return JSON.parse(readFileSync10(path, "utf-8"));
+    return JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return null;
   }
@@ -17918,7 +18292,7 @@ function scheduleBusyAck(channel, threadTs, messageTs, isThreadReply, arrivedWhi
     let paneLogFreshAgeMs = null;
     if (SLACK_AGENT_DIR) {
       try {
-        const paneMtimeMs = statSync2(join9(SLACK_AGENT_DIR, "pane.log")).mtimeMs;
+        const paneMtimeMs = statSync2(join13(SLACK_AGENT_DIR, "pane.log")).mtimeMs;
         paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
       } catch {
       }
@@ -17951,7 +18325,7 @@ function __resetSlackBusyAckNoticeThrottle() {
 function clearSlackMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -17968,7 +18342,7 @@ function clearSlackMarkerFileWithHeal(fullPath) {
 function markSlackMarkerSeenWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
   } catch {
     return;
   }
@@ -17987,6 +18361,7 @@ function clearAllSlackPendingMarkersForThread2(channel, threadTs) {
     threadTs,
     clearSlackMarkerFileWithHeal
   );
+  slackInboundRegistry.markClearedThread(channel, threadTs);
 }
 function clearSlackPendingMarkerByMessageTs2(channel, messageTs) {
   clearSlackPendingMarkerByMessageTs(
@@ -17995,6 +18370,7 @@ function clearSlackPendingMarkerByMessageTs2(channel, messageTs) {
     messageTs,
     clearSlackMarkerFileWithHeal
   );
+  slackInboundRegistry.markCleared(channel, messageTs);
 }
 function clearOldestSlackPendingMarkerInChannel2(channel) {
   clearOldestSlackPendingMarkerInChannel(
@@ -18002,6 +18378,7 @@ function clearOldestSlackPendingMarkerInChannel2(channel) {
     channel,
     clearSlackMarkerFileWithHeal
   );
+  slackInboundRegistry.markClearedOldestInChannel(channel);
 }
 function markSeenAllSlackPendingMarkersForThread2(channel, threadTs) {
   markSeenAllSlackPendingMarkersForThread(
@@ -18033,10 +18410,10 @@ function slackNextRetryName(filename) {
 async function processSlackRecoveryOutboxFile(filename) {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
-  const fullPath = join9(SLACK_RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join13(SLACK_RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    payload = JSON.parse(readFileSync10(fullPath, "utf-8"));
+    payload = JSON.parse(readFileSync14(fullPath, "utf-8"));
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
@@ -18136,7 +18513,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   const next = slackNextRetryName(filename);
   if (next) {
     try {
-      renameSync4(fullPath, join9(SLACK_RECOVERY_OUTBOX_DIR, next.next));
+      renameSync4(fullPath, join13(SLACK_RECOVERY_OUTBOX_DIR, next.next));
       if (next.attempt >= SLACK_MAX_RECOVERY_ATTEMPTS) {
         process.stderr.write(
           `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
@@ -18166,7 +18543,7 @@ function scanSlackRecoveryRetries() {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync3(SLACK_RECOVERY_OUTBOX_DIR);
+    entries = readdirSync4(SLACK_RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -18175,7 +18552,7 @@ function scanSlackRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync2(join9(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync2(join13(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -18196,7 +18573,7 @@ function startSlackRecoveryOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync3(SLACK_RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync4(SLACK_RECOVERY_OUTBOX_DIR)) {
       if (isFirstAttemptSlackOutboxFile(f)) void processSlackRecoveryOutboxFile(f);
     }
   } catch {
@@ -18205,7 +18582,7 @@ function startSlackRecoveryOutboxWatcher() {
     const watcher = watch(SLACK_RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptSlackOutboxFile(filename)) return;
-      if (existsSync8(join9(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync8(join13(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
         void processSlackRecoveryOutboxFile(filename);
       }
     });
@@ -18220,7 +18597,7 @@ function startSlackRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startSlackRecoveryOutboxWatcher();
-var SLACK_NOTICE_OUTBOX_DIR = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "slack-notice-outbox") : null;
+var SLACK_NOTICE_OUTBOX_DIR = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "slack-notice-outbox") : null;
 var SLACK_NOTICE_MAX_AGE_MS = 9e4;
 var SLACK_NOTICE_INFLIGHT = /* @__PURE__ */ new Set();
 async function processSlackNoticeOutboxFile(filename) {
@@ -18228,7 +18605,7 @@ async function processSlackNoticeOutboxFile(filename) {
   if (filename.startsWith(".") || filename.endsWith(".tmp") || !filename.endsWith(".json")) return;
   if (SLACK_NOTICE_INFLIGHT.has(filename)) return;
   SLACK_NOTICE_INFLIGHT.add(filename);
-  const fullPath = join9(SLACK_NOTICE_OUTBOX_DIR, filename);
+  const fullPath = join13(SLACK_NOTICE_OUTBOX_DIR, filename);
   try {
     let mtimeMs;
     try {
@@ -18245,7 +18622,7 @@ async function processSlackNoticeOutboxFile(filename) {
     }
     let payload;
     try {
-      const parsed = JSON.parse(readFileSync10(fullPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync14(fullPath, "utf-8"));
       if (!parsed || typeof parsed !== "object") throw new Error("not an object");
       payload = parsed;
     } catch {
@@ -18328,13 +18705,13 @@ function startSlackNoticeOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync3(SLACK_NOTICE_OUTBOX_DIR)) void processSlackNoticeOutboxFile(f);
+    for (const f of readdirSync4(SLACK_NOTICE_OUTBOX_DIR)) void processSlackNoticeOutboxFile(f);
   } catch {
   }
   try {
     const watcher = watch(SLACK_NOTICE_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
-      if (existsSync8(join9(SLACK_NOTICE_OUTBOX_DIR, filename))) {
+      if (existsSync8(join13(SLACK_NOTICE_OUTBOX_DIR, filename))) {
         void processSlackNoticeOutboxFile(filename);
       }
     });
@@ -18357,7 +18734,7 @@ function sweepSlackStaleMarkers(thresholdMs) {
   if (!existsSync8(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
-    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
+    filenames = readdirSync4(SLACK_PENDING_INBOUND_DIR);
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): stale-marker readdir failed: ${err.message}
@@ -18370,10 +18747,10 @@ function sweepSlackStaleMarkers(thresholdMs) {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join9(SLACK_PENDING_INBOUND_DIR, filename);
+    const fullPath = join13(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `slack-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactSlackId(filename)}: ${err.message}
@@ -18409,6 +18786,9 @@ function sweepSlackStaleMarkers(thresholdMs) {
   }
 }
 sweepSlackStaleMarkers(STALE_MARKER_MS);
+if (SLACK_PENDING_INBOUND_DIR) {
+  slackInboundRegistry.seedFromMarkerDir(SLACK_PENDING_INBOUND_DIR);
+}
 var slackOrphanSweepTimer = setInterval(() => {
   const probe = process.env.TMUX && AGENT_CODE_NAME ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
   const sessionAlive = probe.tmux === "alive" && probe.claude === "alive";
@@ -18416,13 +18796,13 @@ var slackOrphanSweepTimer = setInterval(() => {
   checkSlackWatchdogGiveUpNotice();
 }, orphanSweepIntervalMs());
 slackOrphanSweepTimer.unref?.();
-var SLACK_PROGRESS_HEARTBEAT_PATH = SLACK_AGENT_DIR ? join9(SLACK_AGENT_DIR, "channel-progress-heartbeat.json") : null;
+var SLACK_PROGRESS_HEARTBEAT_PATH = SLACK_AGENT_DIR ? join13(SLACK_AGENT_DIR, "channel-progress-heartbeat.json") : null;
 var slackTrackedProgress = null;
 var slackProgressTickRunning = false;
 function readSlackProgressHeartbeat() {
   if (!SLACK_PROGRESS_HEARTBEAT_PATH || !existsSync8(SLACK_PROGRESS_HEARTBEAT_PATH)) return null;
   try {
-    return parseProgressHeartbeat(readFileSync10(SLACK_PROGRESS_HEARTBEAT_PATH, "utf-8"));
+    return parseProgressHeartbeat(readFileSync14(SLACK_PROGRESS_HEARTBEAT_PATH, "utf-8"));
   } catch {
     return null;
   }
@@ -18431,7 +18811,7 @@ function seedSlackProgressHeartbeat() {
   if (!SLACK_PROGRESS_HEARTBEAT_PATH) return;
   const tmp = `${SLACK_PROGRESS_HEARTBEAT_PATH}.${process.pid}.tmp`;
   try {
-    writeFileSync10(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
+    writeFileSync12(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
     renameSync4(tmp, SLACK_PROGRESS_HEARTBEAT_PATH);
   } catch {
     try {
@@ -18445,11 +18825,11 @@ function findSlackProgressTarget() {
   let best = null;
   let bestMs = Infinity;
   try {
-    for (const name of readdirSync3(SLACK_PENDING_INBOUND_DIR)) {
+    for (const name of readdirSync4(SLACK_PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       let m;
       try {
-        m = JSON.parse(readFileSync10(join9(SLACK_PENDING_INBOUND_DIR, name), "utf-8"));
+        m = JSON.parse(readFileSync14(join13(SLACK_PENDING_INBOUND_DIR, name), "utf-8"));
       } catch {
         continue;
       }
@@ -18596,11 +18976,11 @@ function listPendingSlackConversations() {
   if (!SLACK_PENDING_INBOUND_DIR || !existsSync8(SLACK_PENDING_INBOUND_DIR)) return [];
   const byKey = /* @__PURE__ */ new Map();
   try {
-    for (const name of readdirSync3(SLACK_PENDING_INBOUND_DIR)) {
+    for (const name of readdirSync4(SLACK_PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync10(join9(SLACK_PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync14(join13(SLACK_PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.channel !== "string" || !marker.channel) continue;
         if (typeof marker.thread_ts !== "string" || !marker.thread_ts) continue;
@@ -18652,7 +19032,7 @@ function postSlackWatchdogGiveUpNotice(channel, threadTs, isThreadReply, reason)
 }
 function checkSlackWatchdogGiveUpNotice() {
   if (!SLACK_AGENT_DIR) return;
-  const signal = readGiveUpSignal(join9(SLACK_AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
+  const signal = readGiveUpSignal(join13(SLACK_AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
   const signalAtMs = signal?.atMs ?? null;
   const act = decideGiveUpNotice({
     signalAtMs,
@@ -18689,7 +19069,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
     if (!SLACK_PENDING_INBOUND_DIR || !existsSync8(SLACK_PENDING_INBOUND_DIR)) return;
     let filenames;
     try {
-      filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
+      filenames = readdirSync4(SLACK_PENDING_INBOUND_DIR);
     } catch {
       hadFailure = true;
       return;
@@ -18699,10 +19079,10 @@ async function notifyStrandedInboundsOnFirstConnect() {
     let notified = 0;
     for (const filename of filenames) {
       if (!filename.endsWith(".json")) continue;
-      const fullPath = join9(SLACK_PENDING_INBOUND_DIR, filename);
+      const fullPath = join13(SLACK_PENDING_INBOUND_DIR, filename);
       let marker;
       try {
-        marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+        marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
       } catch {
         continue;
       }
@@ -18873,7 +19253,7 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   markSeenAllSlackPendingMarkersForThread2(channel, messageTs);
   markSeenSlackPendingMarkerByMessageTs2(channel, messageTs);
 }
-var RESTART_FLAGS_DIR = join9(homedir4(), ".augmented", "restart-flags");
+var RESTART_FLAGS_DIR = join13(homedir4(), ".augmented", "restart-flags");
 function actuateHostRestartSlack() {
   return actuateHostRestart({
     agtHost: AGT_HOST,
@@ -18894,10 +19274,10 @@ function buildAugmentedSlackMetadata() {
   };
 }
 function hashChannelId(id) {
-  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(id).digest("hex").slice(0, 8);
 }
 function hashId(id) {
-  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(id).digest("hex").slice(0, 8);
 }
 async function postSlackMessage(body) {
   const augmentedMeta = buildAugmentedSlackMetadata();
@@ -19419,7 +19799,7 @@ async function handleSlashCommandEnvelope(payload) {
         if (!existsSync8(RESTART_FLAGS_DIR)) {
           mkdirSync8(RESTART_FLAGS_DIR, { recursive: true });
         }
-        const flagPath = join9(RESTART_FLAGS_DIR, `${codeName}.flag`);
+        const flagPath = join13(RESTART_FLAGS_DIR, `${codeName}.flag`);
         const flag = {
           codeName,
           source: "slack",
@@ -19427,7 +19807,7 @@ async function handleSlashCommandEnvelope(payload) {
           reply: confirmReply
         };
         const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-        writeFileSync10(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+        writeFileSync12(tmpPath, JSON.stringify(flag) + "\n", "utf8");
         renameSync4(tmpPath, flagPath);
       }
       process.stderr.write(
@@ -19562,7 +19942,7 @@ async function handleRestartCommand(opts) {
       if (!existsSync8(RESTART_FLAGS_DIR)) {
         mkdirSync8(RESTART_FLAGS_DIR, { recursive: true });
       }
-      const flagPath = join9(RESTART_FLAGS_DIR, `${codeName}.flag`);
+      const flagPath = join13(RESTART_FLAGS_DIR, `${codeName}.flag`);
       const flag = {
         codeName,
         source: "slack",
@@ -19570,7 +19950,7 @@ async function handleRestartCommand(opts) {
         reply: { ...confirmReply, message_ts: opts.ts }
       };
       const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-      writeFileSync10(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+      writeFileSync12(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync4(tmpPath, flagPath);
     }
     process.stderr.write(
@@ -19675,7 +20055,7 @@ var THREAD_STORE_TTL_DAYS = parseTtlDays(process.env.SLACK_THREAD_FOLLOW_TTL_DAY
 var threadPersister = null;
 function resolveThreadStorePath() {
   if (!AGENT_CODE_NAME) return null;
-  return join9(homedir4(), ".augmented", AGENT_CODE_NAME, "slack-tracked-threads.json");
+  return join13(homedir4(), ".augmented", AGENT_CODE_NAME, "slack-tracked-threads.json");
 }
 function parseTtlDays(raw) {
   if (!raw) return void 0;
@@ -19714,9 +20094,9 @@ if (!BOT_TOKEN || !APP_TOKEN) {
 var slackStderrLogStream = null;
 if (AGENT_CODE_NAME) {
   try {
-    const logDir = join9(homedir4(), ".augmented", AGENT_CODE_NAME);
+    const logDir = join13(homedir4(), ".augmented", AGENT_CODE_NAME);
     mkdirSync8(logDir, { recursive: true });
-    slackStderrLogStream = createWriteStream(join9(logDir, "slack-channel-stderr.log"), {
+    slackStderrLogStream = createWriteStream(join13(logDir, "slack-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -19795,20 +20175,13 @@ var mcp = new Server(
       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: [
-      // 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 \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.",
-      `Always reply in a thread \u2014 pass message_ts and the server threads your reply off it, for channels AND DMs (it creates the thread if one doesn't exist yet). auto_followed="true" \u2192 only reply if useful, OR if your own bot user is @-mentioned (counts even in auto_followed).`,
-      `Reaction taxonomy (use slack.react sparingly \u2014 prefer a reply): :${SLACK_ACK_REACTION}: = ack (already auto-added on inbound, do not duplicate); \u2705 = success.` + (SKIP_REACTION_ON ? ` "${SLACK_SKIP_REACTION}" = seen but not replying (see below).` : "") + " NEVER react to signal failure of YOUR work \u2014 users can't tell why something failed from an emoji. On failure, slack.reply with one sentence explaining what went wrong (no stack traces, no secrets). (The \u23F3 you may see on an inbound is applied by the system, not you \u2014 it marks a message that arrived while the agent couldn't reply; never add \u23F3 or \u274C yourself.)",
-      SKIP_REACTION_ON ? `When you read a DM or thread message and decide NOT to reply (different @-mention, side conversation, auto_followed catch-up, or simply nothing useful to add): call slack.react with emoji "${SLACK_SKIP_REACTION}" so the sender knows you saw it \u2014 never post a "this wasn't for me" message. Top-level channel messages (not a DM, not a thread reply) you may still skip silently.` : `When a thread message is NOT addressed to you (different @-mention, side conversation, auto_followed catch-up): SILENTLY SKIP \u2014 no reaction, no reply, no "this wasn't for me" message.`,
-      "To deliver a file: save under your project dir, call slack.upload_file with path + channel + thread_ts."
-    ].join(" ")
+    // Built by a pure, length-tested builder (slack-mcp-instructions.ts) so the
+    // routing guidance can't silently fall off the end (ENG-6296 regression).
+    instructions: buildSlackMcpInstructions({
+      ackReaction: SLACK_ACK_REACTION,
+      skipReactionOn: SKIP_REACTION_ON,
+      skipReaction: SLACK_SKIP_REACTION
+    })
   }
 );
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -19844,6 +20217,15 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           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.'
+          },
+          // WS2 (cross-thread reply routing): the preferred way to target a reply.
+          inbound_id: {
+            type: "string",
+            description: `The inbound_id attribute of the <channel> tag you are answering (e.g. "ib_a1b2c3d4e5f6"). PREFERRED over channel/thread_ts/message_ts: the server resolves the exact destination thread from it, so your reply can never land in another user's thread. Copy it verbatim from the tag of the message you are replying to.`
+          },
+          proactive: {
+            type: "boolean",
+            description: "Set true ONLY when this message is NOT a reply to any inbound <channel> tag - a self-initiated outreach or scheduled-task output. Leave it off (default) for every reply to a user message."
           }
         },
         required: ["channel", "text"]
@@ -20075,12 +20457,58 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     return buildImpersonationRefusal(name);
   }
   if (name === "slack.reply") {
-    const { channel, text, thread_ts, message_ts, interim } = args;
-    const effectiveThreadTs = resolveReplyThreadTs({
+    const { channel, text, thread_ts, message_ts, interim, inbound_id, proactive } = args;
+    const bindingMode = slackReplyBindingMode();
+    const binding = resolveReplyBinding({
+      mode: bindingMode,
+      args: { inbound_id, channel, thread_ts, message_ts, proactive },
+      registry: slackInboundRegistry
+    });
+    recordReplyBindingClassification(SLACK_AGENT_DIR, "slack", {
+      classification: binding.classification,
+      unknownInboundId: binding.unknownInboundId
+    });
+    if (bindingMode === "enforce" && binding.reject) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): reply_binding_rejected class=${binding.classification} channel=${redactSlackId(channel)}
+`
+      );
+      return { content: [{ type: "text", text: binding.reject }], isError: true };
+    }
+    const enforceBound = bindingMode === "enforce" && (binding.classification === "bound" || binding.classification === "coords_corrected");
+    if (enforceBound && binding.channel && binding.channel !== channel) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): reply_binding_channel_mismatch_rejected class=${binding.classification} model=${redactSlackId(channel)} registry=${redactSlackId(binding.channel)}
+`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: "This reply was blocked: the channel does not match the inbound_id you named, so it may go to the wrong place. Reply again using the channel from the <channel> tag whose inbound_id you are answering."
+          }
+        ],
+        isError: true
+      };
+    }
+    const bindingFeedback = bindingMode === "warn" ? binding.agentFeedback : void 0;
+    const effectiveThreadTs = enforceBound ? binding.threadTs : resolveReplyThreadTs({
       channel,
       threadTs: thread_ts,
       messageTs: message_ts
     });
+    if (channel) {
+      recordReplyTargetClassification(
+        SLACK_AGENT_DIR,
+        "slack",
+        classifyReplyTarget({
+          channel,
+          threadTs: effectiveThreadTs,
+          messageTs: message_ts,
+          registry: slackInboundRegistry
+        })
+      );
+    }
     const throttleCfg = configFromEnv();
     const throttleKey = effectiveThreadTs ?? channel;
     const throttleNow = Date.now();
@@ -20192,7 +20620,9 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           }
         })();
       }
-      return { content: [{ type: "text", text: "sent" }] };
+      return {
+        content: [{ type: "text", text: bindingFeedback ? `sent. ${bindingFeedback}` : "sent" }]
+      };
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed: ${err.message}` }],
@@ -20308,7 +20738,7 @@ ${result.formatted}` : "Thread is empty or not found."
         };
       }
       size = stat2.size;
-      bytes = readFileSync10(resolvedPath);
+      bytes = readFileSync14(resolvedPath);
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed to read file: ${err.message}` }],
@@ -20668,6 +21098,16 @@ async function handleSendStructured(args) {
     threadTs: thread_ts,
     messageTs: message_ts
   });
+  recordReplyTargetClassification(
+    SLACK_AGENT_DIR,
+    "slack",
+    classifyReplyTarget({
+      channel,
+      threadTs: effectiveThreadTs,
+      messageTs: message_ts,
+      registry: slackInboundRegistry
+    })
+  );
   const validation = validateSlackBlocks2(blocks);
   if (!validation.ok) {
     return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
@@ -21010,7 +21450,7 @@ async function downloadSlackFile(fileId, codeName) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
   mkdirSync8(dir, { recursive: true });
-  writeFileSync10(savedPath, bytes, { mode: 384 });
+  writeFileSync12(savedPath, bytes, { mode: 384 });
   try {
     chmodSync(savedPath, 384);
   } catch {
@@ -21071,7 +21511,7 @@ async function replayPendingSlackMarkers() {
   if (!sessionAlive) return;
   let filenames;
   try {
-    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
+    filenames = readdirSync4(SLACK_PENDING_INBOUND_DIR);
   } catch {
     return;
   }
@@ -21079,17 +21519,17 @@ async function replayPendingSlackMarkers() {
   let paneFreshAgeMs = null;
   if (SLACK_AGENT_DIR) {
     try {
-      paneFreshAgeMs = Math.max(0, now - statSync2(join9(SLACK_AGENT_DIR, "pane.log")).mtimeMs);
+      paneFreshAgeMs = Math.max(0, now - statSync2(join13(SLACK_AGENT_DIR, "pane.log")).mtimeMs);
     } catch {
     }
   }
   const entries = [];
   for (const name of filenames) {
     if (!name.endsWith(".json") || name.endsWith(".tmp")) continue;
-    const fullPath = join9(SLACK_PENDING_INBOUND_DIR, name);
+    const fullPath = join13(SLACK_PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync10(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -21392,7 +21832,7 @@ async function connectSocketMode() {
       const passedIdentity = access.kind !== "drop" || access.reason.startsWith("peer:");
       if (passedIdentity) recordActivity("inbound");
       if (access.kind === "drop") {
-        const channelHash = createHash("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
+        const channelHash = createHash2("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
         const subtypeSuffix = access.reason === "content:subtype" ? ` subtype=${evt.subtype ?? "none"}` : "";
         process.stderr.write(
           `slack-channel: inbound drop reason=${access.reason}${subtypeSuffix} channel=${channelHash} ts=${redactSlackId(evt.ts)}
@@ -21540,7 +21980,7 @@ async function connectSocketMode() {
       if (evt.type === "message" && evt.channel && !isDirectMessage) {
         if (isThreadReply) {
           const logThreadDrop = (reason) => {
-            const channelHash = createHash("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
+            const channelHash = createHash2("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
             process.stderr.write(
               `slack-channel(${AGENT_CODE_NAME}): thread-reply drop reason=${reason} auto_follow=${THREAD_AUTO_FOLLOW} channel=${channelHash} ts=${redactSlackId(evt.ts)}
 `
@@ -21586,7 +22026,7 @@ async function connectSocketMode() {
       let paneLogFreshAgeMs = null;
       if (SLACK_AGENT_DIR) {
         try {
-          const paneMtimeMs = statSync2(join9(SLACK_AGENT_DIR, "pane.log")).mtimeMs;
+          const paneMtimeMs = statSync2(join13(SLACK_AGENT_DIR, "pane.log")).mtimeMs;
           paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
         } catch {
         }
@@ -21688,6 +22128,7 @@ ${forwarded.text}` : forwarded.text;
 `
         );
       }
+      const inboundId = channel && ts ? slackInboundId(channel, threadTs, ts) : "";
       const replayPayload = {
         content: inboundContent,
         meta: {
@@ -21695,6 +22136,7 @@ ${forwarded.text}` : forwarded.text;
           user_name: userName,
           channel,
           thread_ts: threadTs,
+          ...inboundId ? { inbound_id: inboundId } : {},
           // ENG-5861: explicit message_ts so the agent can pass it back
           // to slack.reply for reliable pending-inbound cleanup. For
           // top-level messages threadTs === ts; for threaded replies
@@ -21725,6 +22167,15 @@ ${forwarded.text}` : forwarded.text;
       });
       if (channel && ts && armMarker) {
         attachSlackReplayPayload(channel, threadTs, ts, replayPayload);
+        slackInboundRegistry.record({
+          inboundId,
+          channel,
+          threadTs,
+          messageTs: ts,
+          user,
+          userName,
+          receivedAt: Date.now()
+        });
       }
       if (!isFromBot && evt.user && channel) {
         writeTurnInitiatorMarker({