@integrity-labs/agt-cli 0.27.8 → 0.27.9-test.12

package/dist/mcp/slack-channel.js

@@ -6986,13 +6986,10 @@ __export(slack_block_kit_runtime_exports, {
   DEFAULT_ASK_USER_LIMITS: () => DEFAULT_ASK_USER_LIMITS,
   apiCall: () => apiCall,
   buildAskUserBlocks: () => buildAskUserBlocks,
-  buildRatingActionsBlock: () => buildRatingActionsBlock,
   createPendingInteraction: () => createPendingInteraction,
   decodeActionId: () => decodeActionId,
-  defaultRatingLabels: () => defaultRatingLabels,
   encodeActionId: () => encodeActionId,
   generateOptionToken: () => generateOptionToken,
-  ratingValuesForScale: () => ratingValuesForScale,
   recordSlackDelivery: () => recordSlackDelivery,
   resolveInteractive: () => resolveInteractive,
   updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
@@ -7159,22 +7156,6 @@ function buildAskUserBlocks(opts) {
     }
   ];
 }
-function ratingValuesForScale(scale) {
-  return scale === "1-5" ? [1, 2, 3, 4, 5] : [-1, 0, 1];
-}
-function defaultRatingLabels(scale) {
-  return scale === "1-5" ? ["1", "2", "3", "4", "5"] : ["\u{1F44E}", "\u{1F914}", "\u{1F44D}"];
-}
-function buildRatingActionsBlock(opts) {
-  return {
-    type: "actions",
-    elements: opts.options.map(({ label, token }) => ({
-      type: "button",
-      text: { type: "plain_text", text: label },
-      action_id: encodeActionId(opts.callbackId, token)
-    }))
-  };
-}
 async function resolveInteractive(cfg, input) {
   const res = await apiCall(cfg, "POST", "/host/interactive/resolve", {
     agent_id: cfg.agentId,
@@ -14237,17 +14218,468 @@ function extractAugmentedSlackLabel(evt) {
     agentId: evt.metadata.event_payload?.["augmented_agent_id"]
   };
 }
-function decideSenderPolicyForward(evt, policy) {
+function decideModeForward(evt, policy) {
   if (policy.mode === "all") return { forward: true };
+  if (policy.mode === "manager_only") {
+    if (policy.principalSlackUserId && evt.user === policy.principalSlackUserId) {
+      return { forward: true };
+    }
+  }
+  if (policy.mode === "team_only") {
+    if (policy.teamPrincipalSlackUserIds && policy.teamPrincipalSlackUserIds.length > 0 && typeof evt.user === "string" && policy.teamPrincipalSlackUserIds.includes(evt.user)) {
+      return { forward: true };
+    }
+  }
   const label = extractAugmentedSlackLabel(evt);
   if (!label) return { forward: false, reason: "sender_policy" };
-  if (policy.mode === "team_agents_only") {
+  if (policy.mode === "team_agents_only" || policy.mode === "manager_only" || policy.mode === "team_only") {
     if (!policy.teamId || label.teamId !== policy.teamId) {
       return { forward: false, reason: "sender_policy" };
     }
   }
   return { forward: true };
 }
+function decideSenderPolicyForward(evt, policy) {
+  if (policy.internalOnly) {
+    if (!policy.homeTeamId) return { forward: false, reason: "sender_policy" };
+    if (evt.team !== policy.homeTeamId) return { forward: false, reason: "sender_policy" };
+  }
+  return decideModeForward(evt, policy);
+}
+
+// src/sender-policy-decline.ts
+function classifySlackPolicyBlock(evt, policy) {
+  if (policy.internalOnly && (!policy.homeTeamId || evt.team !== policy.homeTeamId)) {
+    return "internal_only";
+  }
+  switch (policy.mode) {
+    case "manager_only":
+      return "mode_manager_only";
+    case "team_only":
+      return "mode_team_only";
+    case "team_agents_only":
+      return "mode_team_agents_only";
+    case "agents_only":
+      return "mode_agents_only";
+    case "all":
+      return "internal_only";
+  }
+}
+function politeDeclineCopy(reason) {
+  switch (reason) {
+    case "internal_only":
+      return "Sorry, I can only respond to people inside our organisation. This conversation appears to be from outside.";
+    case "mode_manager_only":
+      return "Sorry, I only respond to my manager in this channel.";
+    case "mode_team_only":
+      return "Sorry, this agent only replies to its team members.";
+    case "mode_team_agents_only":
+      return "Sorry, I only respond to agents on my team in this channel.";
+    case "mode_agents_only":
+      return "Sorry, I only respond to other agents in this channel.";
+  }
+}
+function decideDeclineReply(input) {
+  const last = input.cache.get(input.key);
+  if (last !== void 0) {
+    const elapsed = input.now - last;
+    if (elapsed < input.cooldownMs) {
+      return { reply: false, remainingMs: input.cooldownMs - elapsed };
+    }
+  }
+  input.cache.set(input.key, input.now);
+  return { reply: true };
+}
+function declineCacheKey(channelId, senderId, reason) {
+  return `${channelId}|${senderId}|${reason}`;
+}
+function readDeclineCooldownMs(envVarName, defaultSeconds = 1800) {
+  const raw = process.env[envVarName];
+  if (!raw) return defaultSeconds * 1e3;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return defaultSeconds * 1e3;
+  return parsed * 1e3;
+}
+
+// src/ack-reaction.ts
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
+var ACK_STARTUP_GRACE_MS = 6e4;
+var ACK_PANE_FRESH_THRESHOLD_MS = 6e4;
+function decideAckReaction(i) {
+  if (!i.hasTarget) return "none";
+  if (!i.integrationReady) return "undeliverable";
+  if (i.tmux === "dead") return "undeliverable";
+  if (!i.withinStartupGrace && i.claude === "dead") return "undeliverable";
+  const threshold = i.pendingStaleThresholdMs ?? REPLY_WEDGED_THRESHOLD_MS;
+  if (i.oldestPendingAgeMs != null && i.oldestPendingAgeMs > threshold) {
+    const paneFreshThreshold = i.paneFreshThresholdMs ?? ACK_PANE_FRESH_THRESHOLD_MS;
+    const paneIsFresh = i.paneLogFreshAgeMs != null && i.paneLogFreshAgeMs <= paneFreshThreshold;
+    if (paneIsFresh && i.tmux === "alive" && i.claude === "alive") {
+      return "ack";
+    }
+    return "undeliverable";
+  }
+  return "ack";
+}
+function decideRecoveryHeal(i) {
+  return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
+}
+var SLACK_UNDELIVERABLE_REACTION = "hourglass_flowing_sand";
+var SLACK_UNDELIVERABLE_REACTION_LEGACY = "x";
+var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
+function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
+  return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
+}
+function undeliverableNoticeText() {
+  return "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+}
+var GIVE_UP_SIGNAL_FILENAME = "watchdog-give-up.json";
+var GIVE_UP_SIGNAL_MAX_AGE_MS = 30 * 60 * 1e3;
+function readGiveUpSignalAtMs(path, now = Date.now()) {
+  if (!path) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof raw.gave_up_at !== "string") return null;
+    const t = Date.parse(raw.gave_up_at);
+    if (!Number.isFinite(t) || t > now) return null;
+    return t;
+  } catch {
+    return null;
+  }
+}
+function decideGiveUpNotice(input) {
+  const maxAge = input.maxAgeMs ?? GIVE_UP_SIGNAL_MAX_AGE_MS;
+  if (input.signalAtMs == null) return false;
+  if (input.nowMs - input.signalAtMs > maxAge) return false;
+  if (input.lastHandledAtMs != null && input.signalAtMs <= input.lastHandledAtMs) return false;
+  return true;
+}
+function giveUpNoticeText() {
+  return "\u26A0\uFE0F I couldn't read your last message \u2014 please resend it.";
+}
+function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
+  if (!dir) return null;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  let oldest = null;
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    let receivedAt;
+    try {
+      const raw = JSON.parse(readFileSync(join(dir, name), "utf-8"));
+      receivedAt = raw.received_at;
+    } catch {
+      continue;
+    }
+    if (!receivedAt) continue;
+    const t = Date.parse(receivedAt);
+    if (Number.isNaN(t)) continue;
+    const age = now - t;
+    if (age < 0) continue;
+    if (oldest == null || age > oldest) oldest = age;
+  }
+  return oldest;
+}
+function isPendingMarkerStale(receivedAt, nowMs, thresholdMs) {
+  if (!receivedAt) return true;
+  const t = Date.parse(receivedAt);
+  if (!Number.isFinite(t)) return true;
+  if (t > nowMs) return true;
+  return nowMs - t > thresholdMs;
+}
+function channelOrphanMarkerMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_ORPHAN_MARKER_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 30 * 6e4;
+}
+var ORPHAN_SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
+function orphanSweepIntervalMs() {
+  return Math.max(6e4, Math.min(ORPHAN_SWEEP_INTERVAL_MS, channelOrphanMarkerMs()));
+}
+
+// src/session-probe-runtime.ts
+import { execFileSync } from "child_process";
+function agentTmuxSessionName(codeName) {
+  return `agt-${codeName}`;
+}
+function escapePgrepRegex(value) {
+  return value.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&");
+}
+function probeClaudeProcessInTmux(tmuxSession) {
+  const escapedSession = escapePgrepRegex(tmuxSession);
+  const pattern = `(^|[[:space:]])--name ${escapedSession}([[:space:]]|$)`;
+  try {
+    const out = execFileSync("pgrep", ["-f", "--", pattern], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return out.length > 0 ? "alive" : "dead";
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT") return "unknown";
+    return e?.status === 1 ? "dead" : "unknown";
+  }
+}
+function probeTmuxSession(tmuxSession) {
+  try {
+    execFileSync("tmux", ["has-session", "-t", tmuxSession], {
+      stdio: "ignore",
+      timeout: 3e3
+    });
+    return "alive";
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT") return "unknown";
+    return "dead";
+  }
+}
+function probeAgentSession(codeName) {
+  const session = agentTmuxSessionName(codeName);
+  const tmux = probeTmuxSession(session);
+  const claude = tmux === "alive" ? probeClaudeProcessInTmux(session) : tmux;
+  return { tmux, claude };
+}
+var probeCache = /* @__PURE__ */ new Map();
+var SESSION_PROBE_TTL_MS = 15e3;
+function probeAgentSessionCached(codeName, ttlMs = SESSION_PROBE_TTL_MS, now = Date.now()) {
+  const cached2 = probeCache.get(codeName);
+  if (cached2 && now - cached2.at < ttlMs) return cached2.value;
+  const value = probeAgentSession(codeName);
+  probeCache.set(codeName, { at: now, value });
+  return value;
+}
+
+// src/pane-tail.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { open, stat } from "fs/promises";
+
+// src/channel-attachments.ts
+import { homedir } from "os";
+import { join as join2, resolve, sep } from "path";
+function resolveChannelInboundDir(codeName, channelSlug) {
+  const base = join2(homedir(), ".augmented");
+  const allowedSegment = /^[A-Za-z0-9_-]+$/;
+  if (!allowedSegment.test(codeName) || !allowedSegment.test(channelSlug)) {
+    throw new Error(
+      `Refusing to resolve inbound dir \u2014 invalid codeName/channelSlug (got ${JSON.stringify({ codeName, channelSlug })})`
+    );
+  }
+  const candidate = resolve(base, codeName, channelSlug);
+  if (!isPathInside(candidate, base)) {
+    throw new Error(`Refusing inbound dir outside ${base} (got ${candidate})`);
+  }
+  return candidate;
+}
+function classifyMimetype(mimetype) {
+  if (typeof mimetype === "string" && mimetype.startsWith("image/")) return "image";
+  return "attachment";
+}
+function buildSafeInboundPath(root, fileId, mimetype) {
+  const safeId = fileId.replace(/[^A-Za-z0-9_-]/g, "");
+  if (!safeId) throw new Error("Refusing to build inbound path for empty/invalid file id");
+  const ext = extensionForMimetype(mimetype);
+  const candidate = resolve(root, `${safeId}${ext}`);
+  if (!isPathInside(candidate, root)) {
+    throw new Error(`Refusing to build inbound path outside agent dir (got ${candidate})`);
+  }
+  return candidate;
+}
+function extensionForMimetype(mimetype) {
+  if (!mimetype) return ".bin";
+  switch (mimetype) {
+    // Images
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+    case "image/jpg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "image/svg+xml":
+      return ".svg";
+    // Docs
+    case "application/pdf":
+      return ".pdf";
+    case "text/plain":
+      return ".txt";
+    case "text/csv":
+      return ".csv";
+    case "application/json":
+      return ".json";
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+      return ".docx";
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      return ".xlsx";
+    // Audio (Telegram voice notes are typically audio/ogg; regular
+    // audio messages are audio/mpeg)
+    case "audio/ogg":
+      return ".ogg";
+    case "audio/mpeg":
+      return ".mp3";
+    case "audio/mp4":
+      return ".m4a";
+    // Video
+    case "video/mp4":
+      return ".mp4";
+    case "video/quicktime":
+      return ".mov";
+    default:
+      return ".bin";
+  }
+}
+function isPathInside(target, root) {
+  const normalizedRoot = resolve(root) + sep;
+  const normalizedTarget = resolve(target);
+  return normalizedTarget === resolve(root) || normalizedTarget.startsWith(normalizedRoot);
+}
+function redactAugmentedPaths(msg) {
+  const homePrefix = homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return msg.replaceAll(
+    new RegExp(`${homePrefix}[\\\\/]\\.augmented(?:[\\\\/][^\\s'"\`]*)*`, "g"),
+    "<augmented-path>"
+  );
+}
+
+// src/pane-tail.ts
+var execFileAsync = promisify(execFile);
+function evaluateDebugGate(opts) {
+  if (!opts.channelId || !opts.channelId.startsWith("D")) {
+    return { ok: false, reason: "not-dm" };
+  }
+  if (opts.allowedUsers.size === 0) {
+    return { ok: false, reason: "allowlist-empty" };
+  }
+  if (!opts.userId || !opts.allowedUsers.has(opts.userId)) {
+    return { ok: false, reason: "not-allowlisted" };
+  }
+  return { ok: true };
+}
+var PANE_LOG_TAIL_BYTES = 64 * 1024;
+var TMUX_CAPTURE_TIMEOUT_MS = 2e3;
+async function capturePaneSnapshot(opts) {
+  const scrollback = opts.scrollbackLines ?? 200;
+  try {
+    const { stdout } = await execFileAsync(
+      "tmux",
+      ["capture-pane", "-p", "-t", agentTmuxSessionName(opts.codeName), "-S", `-${scrollback}`],
+      { timeout: TMUX_CAPTURE_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 }
+    );
+    return { source: "tmux", text: stdout };
+  } catch {
+  }
+  if (!opts.agentDir) return null;
+  const paneLogPath = `${opts.agentDir}/pane.log`;
+  try {
+    const tail = await readFileTail(paneLogPath, PANE_LOG_TAIL_BYTES);
+    if (tail === null) return null;
+    return { source: "pane-log", text: stripAnsi(tail) };
+  } catch {
+    return null;
+  }
+}
+async function readFileTail(path, maxBytes) {
+  const st = await stat(path);
+  if (!st.isFile()) return null;
+  const start = Math.max(0, st.size - maxBytes);
+  const length = st.size - start;
+  if (length === 0) return "";
+  const handle = await open(path, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    await handle.read(buf, 0, length, start);
+    let text = buf.toString("utf8");
+    if (start > 0) {
+      const nl = text.indexOf("\n");
+      if (nl !== -1) text = text.slice(nl + 1);
+    }
+    return text;
+  } finally {
+    await handle.close();
+  }
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-9;?<=>!]*[ -\/]*[@-~]/g, "").replace(/\x1b./g, "").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+}
+var SECRET_PATTERNS = [
+  // Augmented host API keys
+  { re: /tlk_[A-Za-z0-9]{8,}/g, label: "agt-api-key" },
+  // Slack tokens: bot/app/user/refresh/config
+  { re: /x(?:ox[abprs]|app)-[A-Za-z0-9-]{8,}/g, label: "slack-token" },
+  // JWTs (three base64url segments, first one always starts with eyJ)
+  { re: /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, label: "jwt" },
+  // OpenAI / Anthropic-style keys (sk-..., sk-ant-...)
+  { re: /sk-[A-Za-z0-9_-]{16,}/g, label: "sk-key" },
+  // AWS access key IDs
+  { re: /(?:AKIA|ASIA)[0-9A-Z]{16}/g, label: "aws-key" },
+  // GitHub tokens
+  { re: /gh[pousr]_[A-Za-z0-9]{20,}/g, label: "github-token" }
+];
+function redactPaneText(text) {
+  let out = redactAugmentedPaths(text);
+  for (const { re, label } of SECRET_PATTERNS) {
+    out = out.replace(re, `<redacted:${label}>`);
+  }
+  return out;
+}
+var DEFAULT_MAX_CHARS = 3900;
+var REFLOW_COLS = 80;
+function formatPaneSnapshot(opts) {
+  const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+  const commandName = opts.commandName ?? "/debug";
+  const header = opts.status.kind === "live" ? `\u{1F50E} Live pane tail for \`${opts.codeName}\` \u2014 captured ${opts.capturedAtLabel} \xB7 updates ~3s \xB7 expires in ${formatCountdown(opts.status.secondsRemaining)}` : `\u{1F50E} Pane tail for \`${opts.codeName}\` \u2014 captured ${opts.capturedAtLabel} \xB7 *expired* \u2014 run \`${commandName}\` to restart`;
+  const fenceOverhead = header.length + "\n```\n".length + "\n```".length + 16;
+  const contentBudget = Math.max(0, maxChars - fenceOverhead);
+  const lines = reflowLines(sanitizeForCodeBlock(opts.text), REFLOW_COLS);
+  const kept = [];
+  let used = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const cost = lines[i].length + 1;
+    if (used + cost > contentBudget) break;
+    kept.unshift(lines[i]);
+    used += cost;
+  }
+  const truncated = kept.length < lines.length;
+  const body = kept.join("\n").trimEnd();
+  const block = body.length > 0 ? `\`\`\`
+${truncated ? "\u2026\n" : ""}${body}
+\`\`\`` : "_(pane is empty)_";
+  return `${header}
+${block}`;
+}
+function formatCountdown(totalSeconds) {
+  const s = Math.max(0, Math.floor(totalSeconds));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+function sanitizeForCodeBlock(text) {
+  return text.replace(/```/g, "`\u200B`\u200B`");
+}
+function reflowLines(text, cols) {
+  const out = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.length <= cols) {
+      out.push(line);
+      continue;
+    }
+    for (let i = 0; i < line.length; i += cols) {
+      out.push(line.slice(i, i + cols));
+    }
+  }
+  const collapsed = [];
+  for (const line of out) {
+    if (line === "" && collapsed[collapsed.length - 1] === "") continue;
+    collapsed.push(line);
+  }
+  return collapsed;
+}
 
 // src/slack-loop-throttle.ts
 var DEFAULT_THROTTLE = {
@@ -14351,479 +14783,185 @@ async function isThreadKilled(opts) {
   }
 }
 
-// src/slack-progress.ts
-var MODE_EMOJI = {
-  thinking: "\u{1F4AD}",
-  working: "\u{1F6E0}\uFE0F",
-  waiting: "\u23F3"
-};
-var TERMINAL_EMOJI = {
-  completed: "\u2705",
-  failed: "\u274C"
-};
-function formatWallClock(ms, timeZone) {
-  const fmt = new Intl.DateTimeFormat("en-GB", {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-    timeZone,
-    timeZoneName: "short"
-  });
-  const parts = fmt.formatToParts(new Date(ms));
-  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
-  return `${get("hour")}:${get("minute")}:${get("second")} ${get("timeZoneName")}`;
-}
-function renderHeaderLine(state) {
-  if (state.terminal) {
-    return `${TERMINAL_EMOJI[state.terminal.kind]} *${state.terminal.kind === "completed" ? "Done" : "Failed"}* \u2014 ${state.initialLabel}`;
-  }
-  return `${MODE_EMOJI[state.mode]} *Working on:* ${state.initialLabel}`;
-}
-function renderStepLine(state) {
-  if (state.terminal) {
-    return state.terminal.message ? state.terminal.message : void 0;
-  }
-  const parts = [];
-  if (state.stepNumber) {
-    if (state.stepNumber.total != null) {
-      parts.push(`*Step ${state.stepNumber.current} of ${state.stepNumber.total}*`);
-    } else {
-      parts.push(`*Step ${state.stepNumber.current}*`);
+// src/slack-thread-context.ts
+var SLACK_AUTOLOAD_THREAD_LIMIT = 30;
+var SLACK_AUTOLOAD_THREAD_MAX_CHARS = 4e3;
+function formatThreadMessages(messages, nameById) {
+  return messages.map((m) => `[${m.ts}] ${nameById.get(m.user) ?? m.user} (<@${m.user}>): ${m.text}`).join("\n");
+}
+function capThreadContext(formatted, maxChars) {
+  if (formatted.length <= maxChars) return formatted;
+  const marker = "[\u2026earlier thread messages omitted \u2014 slack.read_thread for full history\u2026]\n";
+  if (maxChars <= marker.length) return marker.slice(0, maxChars);
+  const tailBudget = maxChars - marker.length;
+  const tail = formatted.slice(formatted.length - tailBudget);
+  const firstNewline = tail.indexOf("\n");
+  const clean = firstNewline >= 0 ? tail.slice(firstNewline + 1) : tail;
+  return `${marker}${clean}`;
+}
+async function fetchThreadTranscript(channel, threadTs, limit, deps) {
+  const { botToken, resolveUserName: resolveUserName2, fetchImpl = fetch } = deps;
+  const cappedLimit = Math.min(Math.max(limit, 1), 200);
+  const allMessages = [];
+  let cursor;
+  do {
+    const remaining = cappedLimit - allMessages.length;
+    if (remaining <= 0) break;
+    const params = new URLSearchParams({
+      channel,
+      ts: threadTs,
+      limit: String(Math.min(remaining, 100)),
+      ...cursor ? { cursor } : {}
+    });
+    let data;
+    try {
+      const res = await fetchImpl(`https://slack.com/api/conversations.replies?${params}`, {
+        headers: { Authorization: `Bearer ${botToken}` }
+      });
+      if (!res.ok) return { ok: false, error: `http_${res.status}` };
+      data = await res.json();
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : "fetch_failed" };
+    }
+    if (!data.ok) return { ok: false, error: data.error ?? "unknown" };
+    for (const msg of data.messages ?? []) {
+      allMessages.push({
+        user: msg.user ?? msg.bot_id ?? "unknown",
+        text: msg.text ?? "",
+        ts: msg.ts ?? ""
+      });
     }
-  }
-  if (state.stepLabel) parts.push(state.stepLabel);
-  return parts.length > 0 ? parts.join(": ") : void 0;
+    cursor = data.response_metadata?.next_cursor || void 0;
+  } while (cursor && allMessages.length < cappedLimit);
+  const uniqueUserIds = [...new Set(allMessages.map((m) => m.user))];
+  const resolved = await Promise.all(
+    uniqueUserIds.map(async (id) => [id, await resolveUserName2(id)])
+  );
+  const nameById = new Map(resolved);
+  return { ok: true, count: allMessages.length, formatted: formatThreadMessages(allMessages, nameById) };
 }
-function renderProgressBlocks(state) {
-  const header = renderHeaderLine(state);
-  const step = renderStepLine(state);
-  const footer = state.terminal ? `_${state.terminal.kind === "completed" ? "completed" : "failed"}: ${formatWallClock(state.lastChangeAt)}_` : `_last update: ${formatWallClock(state.lastChangeAt)}_`;
-  const lines = [header];
-  if (step) lines.push(step);
-  if (state.detail) lines.push(`_${state.detail}_`);
-  lines.push(footer);
-  const fallbackText = state.terminal ? `${state.terminal.kind === "completed" ? "Done" : "Failed"} \u2014 ${state.initialLabel}` : `Working on: ${state.initialLabel}`;
+
+// src/impersonation.ts
+var ENV_VAR = "AGT_ACT_AS_AGENT_ID";
+var OVERRIDE_ENV_VAR = "ENABLE_IMPERSONATION_CHANNELS";
+function isImpersonating() {
+  return impersonatedAgentId() !== null;
+}
+function impersonatedAgentId() {
+  const raw = process.env[ENV_VAR];
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function channelsEnabledOverride() {
+  const raw = process.env[OVERRIDE_ENV_VAR];
+  if (typeof raw !== "string") return false;
+  const trimmed = raw.trim().toLowerCase();
+  return trimmed === "1" || trimmed === "true" || trimmed === "yes" || trimmed === "on";
+}
+var IMPERSONATION_REFUSAL_CODE = "CHANNEL.IMPERSONATION_DISABLED";
+var IMPERSONATION_REFUSAL_MESSAGE = "Posting as an agent under impersonation is disabled in v0 \u2014 quit impersonation with `agt impersonate exit` to send as yourself.";
+function buildImpersonationRefusal(toolName) {
   return {
-    text: fallbackText,
-    blocks: [
+    content: [
       {
-        type: "section",
-        text: { type: "mrkdwn", text: lines.join("\n") }
+        type: "text",
+        text: JSON.stringify({
+          error: {
+            code: IMPERSONATION_REFUSAL_CODE,
+            message: IMPERSONATION_REFUSAL_MESSAGE,
+            tool: toolName
+          }
+        })
       }
-    ]
+    ],
+    isError: true
   };
 }
-var SLACK_POST_URL = "https://slack.com/api/chat.postMessage";
-var SLACK_UPDATE_URL = "https://slack.com/api/chat.update";
-var DEFAULT_TIMEOUT_MS = 5e3;
-var SlackApiError = class extends Error {
-  constructor(endpoint, slackError, status) {
-    super(`Slack ${endpoint} failed: ${slackError} (status=${status})`);
-    this.endpoint = endpoint;
-    this.slackError = slackError;
-    this.status = status;
-    this.name = "SlackApiError";
+
+// src/channel-egress-tools.ts
+var SLACK_EGRESS_TOOLS = /* @__PURE__ */ new Set([
+  "slack.reply",
+  "slack.react",
+  "slack.send_structured",
+  "slack.ask_user",
+  "slack.upload_file"
+]);
+
+// src/slack-pending-inbound-cleanup.ts
+import { existsSync, readdirSync as readdirSync2, statSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+function sanitizeMarkerSegment(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+var defaultClearMarkerFile = (fullPath) => {
+  try {
+    if (existsSync(fullPath)) unlinkSync(fullPath);
+  } catch {
   }
 };
-function createSlackProgressFlush(opts) {
-  const fetchImpl = opts.fetchImpl ?? fetch;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  let anchorTs = null;
-  async function slackCall(endpoint, body) {
-    const url = endpoint === "chat.postMessage" ? SLACK_POST_URL : SLACK_UPDATE_URL;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let response;
-    try {
-      response = await fetchImpl(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${opts.botToken}`
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-    } finally {
-      clearTimeout(timer);
+function clearAllSlackPendingMarkersForThread(dir, channel, threadTs, clear = defaultClearMarkerFile) {
+  if (!dir) return 0;
+  const prefix = `${sanitizeMarkerSegment(channel)}__${sanitizeMarkerSegment(threadTs)}__`;
+  let cleared = 0;
+  try {
+    for (const f of readdirSync2(dir)) {
+      if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
+      clear(join3(dir, f));
+      cleared += 1;
     }
-    const parsed = await response.json().catch(() => ({ ok: false, error: "invalid_json" }));
-    if (!parsed.ok) {
-      throw new SlackApiError(endpoint, parsed.error ?? "unknown", response.status);
+  } catch {
+  }
+  return cleared;
+}
+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(join3(dir, f));
+      cleared += 1;
     }
-    return parsed;
+  } catch {
   }
-  return async function flush(state) {
-    const payload = renderProgressBlocks(state);
-    if (anchorTs == null) {
-      const body = {
-        channel: opts.channel,
-        text: payload.text,
-        blocks: payload.blocks
-      };
-      if (opts.threadTs) body.thread_ts = opts.threadTs;
+  return cleared;
+}
+function clearOldestSlackPendingMarkerInChannel(dir, channel, clear = defaultClearMarkerFile) {
+  if (!dir) return null;
+  const channelPrefix = `${sanitizeMarkerSegment(channel)}__`;
+  try {
+    const entries = readdirSync2(dir).filter((f) => f.startsWith(channelPrefix) && f.endsWith(".json")).map((f) => {
+      const full = join3(dir, f);
+      let mtime = 0;
       try {
-        const res = await slackCall("chat.postMessage", body);
-        if (!res.ts) {
-          throw new SlackApiError(
-            "chat.postMessage",
-            "missing ts in successful response",
-            200
-          );
-        }
-        anchorTs = res.ts;
-        opts.onAnchorPosted?.(res.ts);
-      } catch (err) {
-        throw err;
-      }
-      return;
-    }
-    try {
-      await slackCall("chat.update", {
-        channel: opts.channel,
-        ts: anchorTs,
-        text: payload.text,
-        blocks: payload.blocks
-      });
-    } catch (err) {
-      if (opts.onApiError && err instanceof SlackApiError) {
-        await opts.onApiError(err);
-        return;
+        mtime = statSync(full).mtimeMs;
+      } catch {
       }
-      throw err;
-    }
-  };
+      return { name: f, full, mtime };
+    }).filter((e) => e.mtime > 0).sort((a, b) => a.mtime - b.mtime);
+    const oldest = entries[0];
+    if (!oldest) return null;
+    clear(oldest.full);
+    return oldest.name;
+  } catch {
+    return null;
+  }
 }
 
-// src/progress-tools.ts
-import { randomUUID } from "crypto";
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process2 from "process";
 
-// src/progress-handle.ts
-async function startProgressHandle(opts) {
-  const now = opts.now ?? (() => Date.now());
-  const setTimer = opts.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-  const clearTimer = opts.clearTimer ?? ((id) => clearTimeout(id));
-  const debounceMs = opts.debounceMs ?? 1e3;
-  const onPostTerminalUpdate = opts.onPostTerminalUpdate ?? defaultPostTerminalWarn;
-  const state = {
-    initialLabel: opts.initialLabel,
-    mode: opts.initialMode ?? "working",
-    lastChangeAt: now()
-  };
-  let lastFlushAt = 0;
-  let pendingTimer = null;
-  let inFlight = null;
-  let terminal = false;
-  async function doFlush() {
-    while (inFlight) await inFlight;
-    if (pendingTimer != null) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    lastFlushAt = now();
-    const promise = opts.flush(snapshotState());
-    inFlight = promise.then(
-      () => {
-        inFlight = null;
-      },
-      (err) => {
-        inFlight = null;
-        throw err;
-      }
-    );
-    await inFlight;
-  }
-  function snapshotState() {
-    return {
-      initialLabel: state.initialLabel,
-      mode: state.mode,
-      stepLabel: state.stepLabel,
-      stepNumber: state.stepNumber ? { ...state.stepNumber } : void 0,
-      detail: state.detail,
-      lastChangeAt: state.lastChangeAt,
-      terminal: state.terminal ? { ...state.terminal } : void 0
-    };
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var ReadBuffer = class {
+  append(chunk) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
-  function applyUpdate(next) {
-    if (next.mode !== void 0) state.mode = next.mode;
-    if (next.stepLabel !== void 0) state.stepLabel = next.stepLabel;
-    if (next.stepNumber !== void 0) state.stepNumber = { ...next.stepNumber };
-    if (next.detail !== void 0) state.detail = next.detail;
-    state.lastChangeAt = now();
-  }
-  async function scheduleOrFlush() {
-    const elapsed = now() - lastFlushAt;
-    if (elapsed >= debounceMs) {
-      await doFlush();
-      return;
-    }
-    if (pendingTimer != null) return;
-    const remaining = debounceMs - elapsed;
-    pendingTimer = setTimer(() => {
-      pendingTimer = null;
-      void doFlush().catch(() => {
-      });
-    }, remaining);
-  }
-  lastFlushAt = now();
-  await opts.flush(snapshotState());
-  return {
-    snapshot: snapshotState,
-    async update(next) {
-      if (terminal) {
-        const peeked = snapshotState();
-        Object.assign(peeked, {
-          mode: next.mode ?? peeked.mode,
-          stepLabel: next.stepLabel ?? peeked.stepLabel,
-          stepNumber: next.stepNumber ?? peeked.stepNumber,
-          detail: next.detail ?? peeked.detail
-        });
-        try {
-          onPostTerminalUpdate(peeked);
-        } catch (err) {
-          console.warn(
-            "[progress-handle] onPostTerminalUpdate threw \u2014 swallowed to keep update() non-throwing:",
-            err
-          );
-        }
-        return;
-      }
-      applyUpdate(next);
-      await scheduleOrFlush();
-    },
-    async complete(summary) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "completed", message: summary };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    async fail(reason) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "failed", message: reason };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    isTerminal: () => terminal
-  };
-}
-function defaultPostTerminalWarn(state) {
-  console.warn(
-    `[progress-handle] update() called after terminal transition (${state.terminal?.kind}) \u2014 ignored.`
-  );
-}
-
-// src/progress-tools.ts
-var ProgressToolRegistry = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.toolNames = {
-      start: `${opts.prefix}_progress_start`,
-      update: `${opts.prefix}_progress_update`,
-      complete: `${opts.prefix}_progress_complete`,
-      fail: `${opts.prefix}_progress_fail`
-    };
-  }
-  handles = /* @__PURE__ */ new Map();
-  toolNames;
-  /** Tool definitions to splice into the MCP ListToolsRequest response. */
-  getDefinitions() {
-    const { surfaceDescription, startArgsSchema } = this.opts;
-    const debounceMs = this.opts.debounceMs ?? 1e3;
-    const debounceText = debounceMs === 1e3 ? "per second" : `every ${debounceMs}ms`;
-    return [
-      {
-        name: this.toolNames.start,
-        description: `Post a "still working" anchor to ${surfaceDescription} and return a progress_id. The anchor message updates in place as you call ${this.toolNames.update} \u2014 operators see one message that ticks forward instead of a flood of new ones. Always end with ${this.toolNames.complete} or ${this.toolNames.fail}; otherwise the anchor lingers as "working" until the stale-state sweep flips it. Opt-in \u2014 only call this for tasks that will take more than a few seconds.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            label: {
-              type: "string",
-              description: 'Short top-line label for the task (e.g. "diagnose vigil"). Stays constant for the lifetime of this progress anchor.'
-            },
-            initial_mode: {
-              type: "string",
-              enum: ["thinking", "working", "waiting"],
-              description: 'Initial mode emoji \u2014 defaults to "working".'
-            },
-            ...startArgsSchema.properties
-          },
-          required: ["label", ...startArgsSchema.required]
-        }
-      },
-      {
-        name: this.toolNames.update,
-        description: `Update the progress anchor in place. The state machine debounces calls to one ${surfaceDescription} API call ${debounceText}, so spamming this every step is safe \u2014 only the latest pending state will paint. Any subset of fields can be passed; omitted ones retain their previous value.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string", description: "The progress_id returned from start." },
-            step_label: { type: "string", description: 'Short label for the current step (e.g. "Querying CloudWatch logs").' },
-            step_current: { type: "number", description: "1-based step counter \u2014 current." },
-            step_total: { type: "number", description: "Total steps if known. Omit for open-ended progress." },
-            mode: { type: "string", enum: ["thinking", "working", "waiting"] },
-            detail: { type: "string", description: "Free-text detail line under the step label." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.complete,
-        description: `Mark the progress anchor as \u2705 completed. Flushes any pending debounced state before painting the terminal banner \u2014 the operator never sees a stale "Step N" beside the \u2705. After this, the handle is dead; further updates are no-ops.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            summary: { type: "string", description: "Optional one-line summary of what was achieved." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.fail,
-        description: `Mark the progress anchor as \u274C failed. Always include a one-sentence reason \u2014 the operator can't tell *why* from emoji alone. Same flush-then-paint behaviour as complete.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            reason: { type: "string", description: "One-sentence failure reason." }
-          },
-          required: ["progress_id", "reason"]
-        }
-      }
-    ];
-  }
-  /**
-   * Dispatch a CallToolRequest. Returns `undefined` if the tool name
-   * isn't one of ours (so the caller can keep walking its dispatch
-   * chain). Returns a tool result otherwise.
-   */
-  async handle(name, args) {
-    if (name === this.toolNames.start) return this.handleStart(args);
-    if (name === this.toolNames.update) return this.handleUpdate(args);
-    if (name === this.toolNames.complete) return this.handleComplete(args);
-    if (name === this.toolNames.fail) return this.handleFail(args);
-    return void 0;
-  }
-  /** Live count of in-flight handles. Exposed for tests + diagnostics. */
-  size() {
-    return this.handles.size;
-  }
-  async handleStart(args) {
-    const label = typeof args.label === "string" ? args.label : null;
-    if (!label) return errResult(`${this.toolNames.start}: 'label' must be a non-empty string`);
-    if ("initial_mode" in args && !isMode(args.initial_mode)) {
-      return errResult(
-        `${this.toolNames.start}: 'initial_mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    for (const k of this.opts.startArgsSchema.required) {
-      if (typeof args[k] !== "string" || args[k].length === 0) {
-        return errResult(`${this.toolNames.start}: '${k}' must be a non-empty string`);
-      }
-    }
-    const initialMode = isMode(args.initial_mode) ? args.initial_mode : void 0;
-    const progressId = randomUUID();
-    try {
-      const flush = this.opts.createFlush(args);
-      const handle = await startProgressHandle({
-        initialLabel: label,
-        initialMode,
-        flush,
-        debounceMs: this.opts.debounceMs ?? 1e3
-      });
-      this.handles.set(progressId, handle);
-      return okResult(JSON.stringify({ progress_id: progressId }));
-    } catch (err) {
-      return errResult(`${this.toolNames.start} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleUpdate(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.update}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.update}: unknown progress_id (already terminated, or never started)`);
-    if ("mode" in args && !isMode(args.mode)) {
-      return errResult(
-        `${this.toolNames.update}: 'mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    if (typeof args.step_total === "number" && typeof args.step_current !== "number") {
-      return errResult(
-        `${this.toolNames.update}: 'step_total' requires 'step_current'`
-      );
-    }
-    const next = {};
-    if (typeof args.step_label === "string") next.stepLabel = args.step_label;
-    if (typeof args.step_current === "number") {
-      next.stepNumber = {
-        current: args.step_current,
-        ...typeof args.step_total === "number" ? { total: args.step_total } : {}
-      };
-    }
-    if (isMode(args.mode)) next.mode = args.mode;
-    if (typeof args.detail === "string") next.detail = args.detail;
-    try {
-      await handle.update(next);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.update} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleComplete(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.complete}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.complete}: unknown progress_id`);
-    const summary = typeof args.summary === "string" ? args.summary : void 0;
-    try {
-      await handle.complete(summary);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.complete} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleFail(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.fail}: 'progress_id' must be a string`);
-    const reason = typeof args.reason === "string" ? args.reason : null;
-    if (!reason) return errResult(`${this.toolNames.fail}: 'reason' must be a non-empty string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.fail}: unknown progress_id`);
-    try {
-      await handle.fail(reason);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.fail} failed: ${err.message ?? String(err)}`);
-    }
-  }
-};
-function okResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function errResult(text) {
-  return { content: [{ type: "text", text }], isError: true };
-}
-function isMode(value) {
-  return value === "thinking" || value === "working" || value === "waiting";
-}
-
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-import process2 from "process";
-
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
-var ReadBuffer = class {
-  append(chunk) {
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-  }
-  readMessage() {
-    if (!this._buffer) {
-      return null;
+  readMessage() {
+    if (!this._buffer) {
+      return null;
     }
     const index = this._buffer.indexOf("\n");
     if (index === -1) {
@@ -14909,22 +15047,22 @@ var StdioServerTransport = class {
 import {
   chmodSync,
   createWriteStream,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
-  readdirSync,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
   renameSync as renameSync2,
-  statSync,
-  unlinkSync as unlinkSync2,
+  statSync as statSync2,
+  unlinkSync as unlinkSync3,
   watch,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename, join as join3, resolve as resolve2 } from "path";
+import { basename, join as join5, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomUUID } from "crypto";
 
 // src/slack-thread-store.ts
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { dirname } from "path";
 var FILE_VERSION = 1;
 var DEFAULT_TTL_DAYS = 30;
@@ -14935,7 +15073,7 @@ function loadThreadStore(filePath, opts = {}) {
   const ttlMs = ttlDays * 24 * 60 * 60 * 1e3;
   let raw;
   try {
-    raw = readFileSync(filePath, "utf-8");
+    raw = readFileSync2(filePath, "utf-8");
   } catch {
     return { threads: /* @__PURE__ */ new Map(), pruned: 0 };
   }
@@ -15048,88 +15186,6 @@ async function runOrRetry(fn, opts) {
   }
 }
 
-// src/channel-attachments.ts
-import { homedir } from "os";
-import { join, resolve, sep } from "path";
-function resolveChannelInboundDir(codeName, channelSlug) {
-  const base = join(homedir(), ".augmented");
-  const allowedSegment = /^[A-Za-z0-9_-]+$/;
-  if (!allowedSegment.test(codeName) || !allowedSegment.test(channelSlug)) {
-    throw new Error(
-      `Refusing to resolve inbound dir \u2014 invalid codeName/channelSlug (got ${JSON.stringify({ codeName, channelSlug })})`
-    );
-  }
-  const candidate = resolve(base, codeName, channelSlug);
-  if (!isPathInside(candidate, base)) {
-    throw new Error(`Refusing inbound dir outside ${base} (got ${candidate})`);
-  }
-  return candidate;
-}
-function classifyMimetype(mimetype) {
-  if (typeof mimetype === "string" && mimetype.startsWith("image/")) return "image";
-  return "attachment";
-}
-function buildSafeInboundPath(root, fileId, mimetype) {
-  const safeId = fileId.replace(/[^A-Za-z0-9_-]/g, "");
-  if (!safeId) throw new Error("Refusing to build inbound path for empty/invalid file id");
-  const ext = extensionForMimetype(mimetype);
-  const candidate = resolve(root, `${safeId}${ext}`);
-  if (!isPathInside(candidate, root)) {
-    throw new Error(`Refusing to build inbound path outside agent dir (got ${candidate})`);
-  }
-  return candidate;
-}
-function extensionForMimetype(mimetype) {
-  if (!mimetype) return ".bin";
-  switch (mimetype) {
-    // Images
-    case "image/png":
-      return ".png";
-    case "image/jpeg":
-    case "image/jpg":
-      return ".jpg";
-    case "image/gif":
-      return ".gif";
-    case "image/webp":
-      return ".webp";
-    case "image/svg+xml":
-      return ".svg";
-    // Docs
-    case "application/pdf":
-      return ".pdf";
-    case "text/plain":
-      return ".txt";
-    case "text/csv":
-      return ".csv";
-    case "application/json":
-      return ".json";
-    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-      return ".docx";
-    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
-      return ".xlsx";
-    // Audio (Telegram voice notes are typically audio/ogg; regular
-    // audio messages are audio/mpeg)
-    case "audio/ogg":
-      return ".ogg";
-    case "audio/mpeg":
-      return ".mp3";
-    case "audio/mp4":
-      return ".m4a";
-    // Video
-    case "video/mp4":
-      return ".mp4";
-    case "video/quicktime":
-      return ".mov";
-    default:
-      return ".bin";
-  }
-}
-function isPathInside(target, root) {
-  const normalizedRoot = resolve(root) + sep;
-  const normalizedTarget = resolve(target);
-  return normalizedTarget === resolve(root) || normalizedTarget.startsWith(normalizedRoot);
-}
-
 // src/slack-inbound-files.ts
 function classifySlackFile(file) {
   if (!file || typeof file.id !== "string" || !file.id) return null;
@@ -15696,14 +15752,14 @@ function createSlackBotUserIdClient(args) {
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 function defaultIsPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -15721,7 +15777,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 = join2(agentDir, basename2);
+  const path = join4(agentDir, basename2);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -15745,14 +15801,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync(lockPath);
+    unlinkSync2(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync3(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;
@@ -15767,22 +15823,117 @@ function readLockHolder(path) {
 var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
 var APP_TOKEN = process.env.SLACK_APP_TOKEN;
 var AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME ?? null;
+var SLACK_COMMAND_MAX_LENGTH = 32;
+function agentSlashCommand(base) {
+  const codeName = AGENT_CODE_NAME?.trim().toLowerCase();
+  if (!codeName || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(codeName)) return base;
+  const suffixed = `${base}-${codeName}`;
+  return suffixed.length > SLACK_COMMAND_MAX_LENGTH ? base : suffixed;
+}
+function matchesAgentCommand(command, base) {
+  return command === base || command === agentSlashCommand(base);
+}
 var AGT_HOST = process.env.AGT_HOST ?? null;
 var AGT_API_KEY = process.env.AGT_API_KEY ?? null;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID ?? null;
 var AGT_TEAM_ID = process.env.AGT_TEAM_ID ?? null;
 var SLACK_SENDER_POLICY = (() => {
   const raw = (process.env.SLACK_SENDER_POLICY ?? "all").trim().toLowerCase();
-  if (raw === "all") return { mode: "all" };
-  if (raw === "agents_only") return { mode: "agents_only" };
+  const internalOnly = process.env.SLACK_INTERNAL_ONLY === "true";
+  const homeTeamId = process.env.SLACK_HOME_TEAM_ID;
+  if (internalOnly && !homeTeamId) {
+    throw new Error(
+      "SLACK_INTERNAL_ONLY=true requires SLACK_HOME_TEAM_ID. The bot install must have a known team_id (run auth.test against the workspace and persist the result)."
+    );
+  }
+  const internalOnlyFields = internalOnly ? { internalOnly: true, homeTeamId } : {};
+  if (raw === "all") return { mode: "all", ...internalOnlyFields };
+  if (raw === "agents_only") return { mode: "agents_only", ...internalOnlyFields };
   if (raw === "team_agents_only") {
     if (!AGT_TEAM_ID) {
       throw new Error("SLACK_SENDER_POLICY=team_agents_only requires AGT_TEAM_ID");
     }
-    return { mode: "team_agents_only", teamId: AGT_TEAM_ID };
+    return { mode: "team_agents_only", teamId: AGT_TEAM_ID, ...internalOnlyFields };
+  }
+  if (raw === "team_only") {
+    if (!AGT_TEAM_ID) {
+      throw new Error("SLACK_SENDER_POLICY=team_only requires AGT_TEAM_ID");
+    }
+    const rawIds = process.env.SLACK_SENDER_POLICY_TEAM_PRINCIPAL_IDS ?? "";
+    const teamPrincipalSlackUserIds = rawIds.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    return {
+      mode: "team_only",
+      teamId: AGT_TEAM_ID,
+      teamPrincipalSlackUserIds,
+      ...internalOnlyFields
+    };
+  }
+  if (raw === "manager_only") {
+    const principalSlackUserId = process.env.SLACK_SENDER_POLICY_PRINCIPAL_ID;
+    if (!AGT_TEAM_ID) {
+      throw new Error("SLACK_SENDER_POLICY=manager_only requires AGT_TEAM_ID");
+    }
+    if (!principalSlackUserId) {
+      throw new Error(
+        "SLACK_SENDER_POLICY=manager_only requires SLACK_SENDER_POLICY_PRINCIPAL_ID. Set agent.reports_to_person with a slack_user_id in contact_preferences and re-run /host/refresh."
+      );
+    }
+    return { mode: "manager_only", teamId: AGT_TEAM_ID, principalSlackUserId, ...internalOnlyFields };
   }
   throw new Error(`Invalid SLACK_SENDER_POLICY=${JSON.stringify(process.env.SLACK_SENDER_POLICY)}`);
 })();
+var SLACK_POLICY_DECLINE_CACHE = /* @__PURE__ */ new Map();
+var SLACK_POLICY_DECLINE_COOLDOWN_MS = readDeclineCooldownMs(
+  "SLACK_SENDER_POLICY_REPLY_COOLDOWN_SEC"
+);
+async function maybeSendSenderPolicyDecline(args) {
+  if (!BOT_TOKEN) return;
+  if (!args.channel || !args.senderId) return;
+  const key2 = declineCacheKey(args.channel, args.senderId, args.subReason);
+  const decision = decideDeclineReply({
+    cache: SLACK_POLICY_DECLINE_CACHE,
+    key: key2,
+    cooldownMs: SLACK_POLICY_DECLINE_COOLDOWN_MS,
+    now: Date.now()
+  });
+  if (!decision.reply) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): decline suppressed by cooldown (channel=${redactSlackId(args.channel)}, sender=${redactSlackId(args.senderId)}, reason=${args.subReason}, remaining=${decision.remainingMs}ms)
+`
+    );
+    return;
+  }
+  const text = politeDeclineCopy(args.subReason);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${BOT_TOKEN}`
+      },
+      body: JSON.stringify({
+        channel: args.channel,
+        text,
+        // Reply in-thread if the inbound was a thread message — keeps
+        // the decline next to the message that caused it. For top-level
+        // posts (DMs / channel root) omit thread_ts and post inline.
+        ...args.threadTs ? { thread_ts: args.threadTs } : {}
+      })
+    });
+    const data = await res.json();
+    if (!data.ok) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): decline post failed: ${data.error ?? "unknown"}
+`
+      );
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
 var BLOCK_KIT_ENABLED = process.env.SLACK_BLOCK_KIT_ENABLED === "true";
 var BLOCK_KIT_ASK_USER_ENABLED = process.env.SLACK_BLOCK_KIT_ASK_USER_ENABLED === "true";
 var BLOCK_KIT_DISABLED = process.env.SLACK_BLOCK_KIT_DISABLED === "true";
@@ -15834,9 +15985,9 @@ var SLACK_PEER_CLASSIFIER_CONFIG = {
   peers: parsePeersEnv(process.env.SLACK_PEERS, process.env.SLACK_PEERS_GATE),
   peer_disabled_mode: SLACK_PEER_DISABLED_MODE
 };
-var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join3(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
-var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join3(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
-var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join3(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
+var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join5(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
+var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
 var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
 function redactSlackId(id) {
   if (!id) return "<none>";
@@ -15848,16 +15999,18 @@ function safeSlackMarkerName(channel, threadTs, messageTs) {
 }
 function slackPendingInboundPath(channel, threadTs, messageTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return null;
-  return join3(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
+  return join5(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
 }
-function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
+function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !SLACK_PENDING_INBOUND_DIR) return;
   const marker = {
     channel,
     thread_ts: threadTs,
     message_ts: messageTs,
-    received_at: (/* @__PURE__ */ new Date()).toISOString()
+    received_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Only persist the flag when set — keeps healthy-path markers byte-identical.
+    ...undeliverable ? { undeliverable: true } : {}
   };
   try {
     mkdirSync3(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
@@ -15869,21 +16022,95 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
     );
   }
 }
-function clearAllSlackPendingMarkersForThread(channel, threadTs) {
-  if (!SLACK_PENDING_INBOUND_DIR) return;
-  const safeChan = channel.replace(/[^A-Za-z0-9_-]/g, "_");
-  const safeThread = threadTs.replace(/[^A-Za-z0-9_-]/g, "_");
-  const prefix = `${safeChan}__${safeThread}__`;
+function healSlackUndeliverable(channel, messageTs) {
+  if (!BOT_TOKEN || !channel || !messageTs) return;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${BOT_TOKEN}`
+  };
+  const remove = (name) => fetch("https://slack.com/api/reactions.remove", {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ channel, timestamp: messageTs, name })
+  }).catch(() => {
+  });
+  void Promise.allSettled([
+    remove(SLACK_UNDELIVERABLE_REACTION),
+    remove(SLACK_UNDELIVERABLE_REACTION_LEGACY)
+  ]).finally(() => {
+    fetch("https://slack.com/api/reactions.add", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ channel, timestamp: messageTs, name: "eyes" })
+    }).catch(() => {
+    });
+  });
+}
+var lastSlackUndeliverableNoticeAt = /* @__PURE__ */ new Map();
+function postUndeliverableNotice(channel, threadTs, isThreadReply) {
+  if (!BOT_TOKEN || !channel) return;
+  const now = Date.now();
+  const conversationKey = isThreadReply && threadTs ? `${channel}:${threadTs}` : channel;
+  if (!shouldPostUndeliverableNotice(lastSlackUndeliverableNoticeAt.get(conversationKey), now)) {
+    return;
+  }
+  lastSlackUndeliverableNoticeAt.set(conversationKey, now);
+  fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${BOT_TOKEN}`
+    },
+    body: JSON.stringify({
+      channel,
+      text: undeliverableNoticeText(),
+      ...threadTs ? { thread_ts: threadTs } : {}
+    })
+  }).catch(() => {
+  });
+}
+function __resetSlackUndeliverableNoticeThrottle() {
+  lastSlackUndeliverableNoticeAt.clear();
+}
+function clearSlackMarkerFileWithHeal(fullPath) {
+  let marker = null;
   try {
-    for (const f of readdirSync(SLACK_PENDING_INBOUND_DIR)) {
-      if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
-      try {
-        unlinkSync2(join3(SLACK_PENDING_INBOUND_DIR, f));
-      } catch {
-      }
-    }
+    marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
   } catch {
   }
+  if (marker && decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.channel && marker.message_ts)
+  }) === "heal") {
+    healSlackUndeliverable(marker.channel, marker.message_ts);
+  }
+  try {
+    if (existsSync3(fullPath)) unlinkSync3(fullPath);
+  } catch {
+  }
+}
+function clearAllSlackPendingMarkersForThread2(channel, threadTs) {
+  clearAllSlackPendingMarkersForThread(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    threadTs,
+    clearSlackMarkerFileWithHeal
+  );
+}
+function clearSlackPendingMarkerByMessageTs2(channel, messageTs) {
+  clearSlackPendingMarkerByMessageTs(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    messageTs,
+    clearSlackMarkerFileWithHeal
+  );
+}
+function clearOldestSlackPendingMarkerInChannel2(channel) {
+  clearOldestSlackPendingMarkerInChannel(
+    SLACK_PENDING_INBOUND_DIR,
+    channel,
+    clearSlackMarkerFileWithHeal
+  );
 }
 function slackNextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
@@ -15899,10 +16126,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 = join3(SLACK_RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join5(SLACK_RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    payload = JSON.parse(readFileSync3(fullPath, "utf-8"));
+    payload = JSON.parse(readFileSync4(fullPath, "utf-8"));
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
@@ -15968,7 +16195,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync2(fullPath);
+      unlinkSync3(fullPath);
     } catch {
     }
     return;
@@ -15976,7 +16203,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   const next = slackNextRetryName(filename);
   if (next) {
     try {
-      renameSync2(fullPath, join3(SLACK_RECOVERY_OUTBOX_DIR, next.next));
+      renameSync2(fullPath, join5(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}
@@ -16006,7 +16233,7 @@ function scanSlackRecoveryRetries() {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync(SLACK_RECOVERY_OUTBOX_DIR);
+    entries = readdirSync3(SLACK_RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -16015,7 +16242,7 @@ function scanSlackRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync(join3(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync2(join5(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -16036,7 +16263,7 @@ function startSlackRecoveryOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync(SLACK_RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync3(SLACK_RECOVERY_OUTBOX_DIR)) {
       if (isFirstAttemptSlackOutboxFile(f)) void processSlackRecoveryOutboxFile(f);
     }
   } catch {
@@ -16045,7 +16272,7 @@ function startSlackRecoveryOutboxWatcher() {
     const watcher = watch(SLACK_RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptSlackOutboxFile(filename)) return;
-      if (existsSync2(join3(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync3(join5(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
         void processSlackRecoveryOutboxFile(filename);
       }
     });
@@ -16061,15 +16288,15 @@ function startSlackRecoveryOutboxWatcher() {
 }
 startSlackRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function trackPendingMessage(channel, threadTs, messageTs) {
-  writeSlackPendingInboundMarker(channel, threadTs, messageTs);
+function trackPendingMessage(channel, threadTs, messageTs, undeliverable = false) {
+  writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable);
 }
-function sweepSlackStaleMarkersOnBoot() {
+function sweepSlackStaleMarkers(thresholdMs) {
   if (!SLACK_PENDING_INBOUND_DIR) return;
-  if (!existsSync2(SLACK_PENDING_INBOUND_DIR)) return;
+  if (!existsSync3(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
-    filenames = readdirSync(SLACK_PENDING_INBOUND_DIR);
+    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): stale-marker readdir failed: ${err.message}
@@ -16082,35 +16309,26 @@ function sweepSlackStaleMarkersOnBoot() {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join3(SLACK_PENDING_INBOUND_DIR, filename);
+    const fullPath = join5(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `slack-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactSlackId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
       continue;
     }
     const { channel, thread_ts, message_ts, received_at } = marker;
-    if (!channel || !thread_ts || !message_ts || !received_at) {
+    if (!channel || !thread_ts || !message_ts || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
-        unlinkSync2(fullPath);
-      } catch {
-      }
-      cleared++;
-      continue;
-    }
-    const receivedAtMs = Date.parse(received_at);
-    if (!Number.isFinite(receivedAtMs) || receivedAtMs > now || now - receivedAtMs > STALE_MARKER_MS) {
-      try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
@@ -16123,9 +16341,167 @@ function sweepSlackStaleMarkersOnBoot() {
     );
   }
 }
-sweepSlackStaleMarkersOnBoot();
+sweepSlackStaleMarkers(STALE_MARKER_MS);
+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";
+  sweepSlackStaleMarkers(sessionAlive ? channelOrphanMarkerMs() : STALE_MARKER_MS);
+  checkSlackWatchdogGiveUpNotice();
+}, orphanSweepIntervalMs());
+slackOrphanSweepTimer.unref?.();
+var lastSlackGiveUpHandledAtMs = null;
+function listPendingSlackConversations() {
+  if (!SLACK_PENDING_INBOUND_DIR || !existsSync3(SLACK_PENDING_INBOUND_DIR)) return [];
+  const byKey = /* @__PURE__ */ new Map();
+  try {
+    for (const name of readdirSync3(SLACK_PENDING_INBOUND_DIR)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const marker = JSON.parse(
+          readFileSync4(join5(SLACK_PENDING_INBOUND_DIR, name), "utf8")
+        );
+        if (typeof marker.channel !== "string" || !marker.channel) continue;
+        if (typeof marker.thread_ts !== "string" || !marker.thread_ts) 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)) {
+          byKey.set(key2, { channel: marker.channel, threadTs: marker.thread_ts, isThreadReply });
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return [...byKey.values()];
+}
+function postSlackWatchdogGiveUpNotice(channel, threadTs, isThreadReply) {
+  if (!BOT_TOKEN || !channel) return;
+  const now = Date.now();
+  const conversationKey = isThreadReply ? `${channel}:${threadTs}` : channel;
+  if (!shouldPostUndeliverableNotice(lastSlackUndeliverableNoticeAt.get(conversationKey), now)) {
+    return;
+  }
+  lastSlackUndeliverableNoticeAt.set(conversationKey, now);
+  process.stderr.write(
+    `slack-channel(${AGENT_CODE_NAME}): give-up notice posted channel=${redactSlackId(channel)}
+`
+  );
+  fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${BOT_TOKEN}`
+    },
+    body: JSON.stringify({
+      channel,
+      text: giveUpNoticeText(),
+      // CR on PR #1824: anchor to the originating message even for root
+      // messages (threadTs === messageTs is still the conversation target) —
+      // a channel-root notice diverges from postUndeliverableNotice and
+      // loses the link to the message the user should resend. isThreadReply
+      // only shapes the THROTTLE key, not the delivery target.
+      ...threadTs ? { thread_ts: threadTs } : {}
+    })
+  }).catch(() => {
+  });
+}
+function checkSlackWatchdogGiveUpNotice() {
+  if (!SLACK_AGENT_DIR) return;
+  const signalAtMs = readGiveUpSignalAtMs(join5(SLACK_AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
+  const act = decideGiveUpNotice({
+    signalAtMs,
+    lastHandledAtMs: lastSlackGiveUpHandledAtMs,
+    nowMs: Date.now()
+  });
+  if (signalAtMs != null) {
+    lastSlackGiveUpHandledAtMs = Math.max(lastSlackGiveUpHandledAtMs ?? 0, signalAtMs);
+  }
+  if (!act) return;
+  for (const convo of listPendingSlackConversations()) {
+    postSlackWatchdogGiveUpNotice(convo.channel, convo.threadTs, convo.isThreadReply);
+  }
+}
+function __resetSlackGiveUpNoticeStateForTests() {
+  lastSlackGiveUpHandledAtMs = null;
+}
+var SLACK_PROCESS_BOOT_MS = Date.now();
+var STRANDED_INBOUND_MIN_AGE_FROM_BOOT_MS = 6e4;
+var STRANDED_INBOUND_MAX_AGE_MS = 5 * 60 * 1e3;
+var strandedInboundNoticeFired = false;
+var strandedInboundNoticeInFlight = false;
+async function notifyStrandedInboundsOnFirstConnect() {
+  if (strandedInboundNoticeFired || strandedInboundNoticeInFlight) return;
+  strandedInboundNoticeInFlight = true;
+  let hadFailure = false;
+  try {
+    if (!SLACK_PENDING_INBOUND_DIR || !existsSync3(SLACK_PENDING_INBOUND_DIR)) return;
+    let filenames;
+    try {
+      filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
+    } catch {
+      hadFailure = true;
+      return;
+    }
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    let notified = 0;
+    for (const filename of filenames) {
+      if (!filename.endsWith(".json")) continue;
+      const fullPath = join5(SLACK_PENDING_INBOUND_DIR, filename);
+      let marker;
+      try {
+        marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
+      } catch {
+        continue;
+      }
+      const { channel, thread_ts, received_at } = marker;
+      if (!channel || !thread_ts || !received_at) continue;
+      const receivedAtMs = Date.parse(received_at);
+      if (!Number.isFinite(receivedAtMs)) continue;
+      if (receivedAtMs >= SLACK_PROCESS_BOOT_MS - STRANDED_INBOUND_MIN_AGE_FROM_BOOT_MS) continue;
+      if (now - receivedAtMs > STRANDED_INBOUND_MAX_AGE_MS) continue;
+      const key2 = `${channel}__${thread_ts}`;
+      if (seen.has(key2)) {
+        try {
+          unlinkSync3(fullPath);
+        } catch {
+        }
+        continue;
+      }
+      seen.add(key2);
+      const res = await postSlackMessage({
+        channel,
+        thread_ts,
+        text: "I was restarted mid-conversation and may have missed your last message. Please re-send if I didn't reply."
+      });
+      if (res.ok) {
+        notified += 1;
+        try {
+          unlinkSync3(fullPath);
+        } catch {
+        }
+      } else {
+        hadFailure = true;
+        process.stderr.write(
+          `slack-channel(${AGENT_CODE_NAME}): stranded-inbound notify failed channel=${redactSlackId(channel)} thread=${redactSlackId(thread_ts)} error=${res.error}
+`
+        );
+      }
+    }
+    if (notified > 0) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): notified ${notified} stranded inbound thread(s) after restart
+`
+      );
+    }
+  } finally {
+    if (!hadFailure) strandedInboundNoticeFired = true;
+    strandedInboundNoticeInFlight = false;
+  }
+}
 function clearPendingMessage(channel, threadTs) {
-  clearAllSlackPendingMarkersForThread(channel, threadTs);
+  clearAllSlackPendingMarkersForThread2(channel, threadTs);
 }
 function noteThreadActivity(channel, threadTs) {
   if (!channel || !threadTs) return;
@@ -16135,10 +16511,10 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   if (!channel || !messageTs) return;
   clearPendingMessage(channel, messageTs);
   if (!SLACK_PENDING_INBOUND_DIR) return;
-  if (!existsSync2(SLACK_PENDING_INBOUND_DIR)) return;
+  if (!existsSync3(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
-    filenames = readdirSync(SLACK_PENDING_INBOUND_DIR);
+    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
   } catch {
     return;
   }
@@ -16149,13 +16525,10 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   for (const filename of filenames) {
     if (!filename.startsWith(channelPrefix)) continue;
     if (!filename.endsWith(messageSuffix)) continue;
-    try {
-      unlinkSync2(join3(SLACK_PENDING_INBOUND_DIR, filename));
-    } catch {
-    }
+    clearSlackMarkerFileWithHeal(join5(SLACK_PENDING_INBOUND_DIR, filename));
   }
 }
-var RESTART_FLAGS_DIR = join3(homedir2(), ".augmented", "restart-flags");
+var RESTART_FLAGS_DIR = join5(homedir2(), ".augmented", "restart-flags");
 function buildAugmentedSlackMetadata() {
   if (!AGT_TEAM_ID) return void 0;
   return {
@@ -16205,12 +16578,13 @@ function buildSlackHelpMessage(codeName) {
   return [
     `\u{1F916} *Available commands for \`${codeName}\`*`,
     "",
-    "All commands are real Slack slash commands (autocomplete via `/`). For backward compatibility, `/help` and `/restart` can also be typed as plain messages in any channel where the bot is present:",
+    "All commands are real Slack slash commands (autocomplete via `/`). For backward compatibility, `/help` and the restart command can also be typed as plain messages in any channel where the bot is present:",
     "\u2022 `/help` \u2014 show this help",
-    "\u2022 `/restart` \u2014 restart this agent",
-    "\u2022 `/agent-status` \u2014 report whether this agent is online + last activity",
+    `\u2022 \`${agentSlashCommand("/restart")}\` \u2014 restart this agent`,
+    `\u2022 \`${agentSlashCommand("/agent-status")}\` \u2014 report whether this agent is online + last activity`,
     "\u2022 `/kill` \u2014 silence all agents in this thread for 6h (use as a thread reply)",
-    "\u2022 `/unkill` \u2014 clear a kill (use as a thread reply)"
+    "\u2022 `/unkill` \u2014 clear a kill (use as a thread reply)",
+    `\u2022 \`${agentSlashCommand("/investigate")}\` \u2014 live tail of this agent's terminal pane (DM only, allowlisted users; works while the channel process is alive \u2014 a wedged host still needs SSM diagnostics)`
   ].join("\n");
 }
 var lastActivityAt = null;
@@ -16299,12 +16673,202 @@ async function postEphemeralViaResponseUrl(responseUrl, text, logTag) {
     );
   }
 }
+var DEBUG_TAIL_WINDOW_MS = 12e4;
+var DEBUG_TAIL_INTERVAL_MS = 3e3;
+var DEBUG_TAIL_MAX_CONSECUTIVE_FAILURES = 4;
+var activeDebugTailExpiresAtMs = null;
+function debugAuditLog(line) {
+  process.stderr.write(`slack-channel(${AGENT_CODE_NAME ?? "unknown"}): /debug ${line}
+`);
+}
+function debugSleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function nowUtcLabel() {
+  return `${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)} UTC`;
+}
+async function updateSlackMessage(channel, ts, text) {
+  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 }),
+      signal: AbortSignal.timeout(SLACK_DOWNLOAD_TIMEOUT_MS)
+    });
+    const retryAfterHeader = res.headers.get("retry-after");
+    const retryAfterSec = retryAfterHeader ? parseInt(retryAfterHeader, 10) : NaN;
+    const retryAfterMs = Number.isFinite(retryAfterSec) ? Math.max(0, retryAfterSec * 1e3) : null;
+    const data = await res.json().catch(() => ({ ok: false, error: `http-${res.status}` }));
+    return { ok: data.ok === true, error: data.error, retryAfterMs };
+  } catch (err) {
+    return { ok: false, error: err.message, retryAfterMs: null };
+  }
+}
+async function runDebugTailLoop(opts) {
+  const expiresAtMs = opts.expiresAtMs;
+  let last = opts.initialFrame;
+  let consecutiveFailures = 0;
+  let delayMs = DEBUG_TAIL_INTERVAL_MS;
+  try {
+    while (Date.now() + delayMs < expiresAtMs) {
+      await debugSleep(delayMs);
+      delayMs = DEBUG_TAIL_INTERVAL_MS;
+      const snapshot = await capturePaneSnapshot({
+        codeName: opts.codeName,
+        agentDir: SLACK_AGENT_DIR
+      });
+      if (!snapshot) continue;
+      const body = redactPaneText(snapshot.text);
+      if (body === last.body) continue;
+      const frame = { body, source: snapshot.source, capturedAtLabel: nowUtcLabel() };
+      const secondsRemaining = Math.max(0, Math.round((expiresAtMs - Date.now()) / 1e3));
+      const result = await updateSlackMessage(
+        opts.channel,
+        opts.ts,
+        formatPaneSnapshot({
+          codeName: opts.codeName,
+          text: frame.body,
+          source: frame.source,
+          capturedAtLabel: frame.capturedAtLabel,
+          status: { kind: "live", secondsRemaining }
+        })
+      );
+      if (result.ok) {
+        last = frame;
+        consecutiveFailures = 0;
+        continue;
+      }
+      if (result.retryAfterMs !== null || result.error === "ratelimited") {
+        delayMs = Math.max(result.retryAfterMs ?? 0, DEBUG_TAIL_INTERVAL_MS * 2);
+        continue;
+      }
+      consecutiveFailures++;
+      if (consecutiveFailures >= DEBUG_TAIL_MAX_CONSECUTIVE_FAILURES) {
+        debugAuditLog(
+          `tail aborted after ${consecutiveFailures} consecutive update failures (last: ${result.error ?? "unknown"})`
+        );
+        break;
+      }
+    }
+  } finally {
+    activeDebugTailExpiresAtMs = null;
+    await updateSlackMessage(
+      opts.channel,
+      opts.ts,
+      formatPaneSnapshot({
+        codeName: opts.codeName,
+        text: last.body,
+        source: last.source,
+        capturedAtLabel: last.capturedAtLabel,
+        status: { kind: "expired" },
+        // ENG-6044: advertise the renamed command in the expired header.
+        commandName: agentSlashCommand("/investigate")
+      })
+    );
+  }
+}
+async function handleDebugSlashCommand(payload, responseUrl) {
+  const codeName = AGENT_CODE_NAME ?? "unknown";
+  const verdict = evaluateDebugGate({
+    channelId: payload.channel_id,
+    userId: payload.user_id,
+    allowedUsers: ALLOWED_USERS
+  });
+  const investigateCmd = agentSlashCommand("/investigate");
+  if (!verdict.ok) {
+    debugAuditLog(`denied reason=${verdict.reason} user=${payload.user_id ?? "unknown"}`);
+    const denialText = verdict.reason === "not-dm" ? `:warning: \`${investigateCmd}\` only works in a direct message with \`${codeName}\` \u2014 it shows the agent's raw terminal, so it stays 1:1. Open a DM with the bot and run \`${investigateCmd}\` there.` : verdict.reason === "allowlist-empty" ? `\u{1F6AB} \`${investigateCmd}\` is disabled for \`${codeName}\` \u2014 no diagnostic allowlist is configured. Because it exposes the agent's raw terminal, \`${investigateCmd}\` requires a non-empty \`SLACK_ALLOWED_USERS\` on the host (unlike the restart command, it does not open up when the allowlist is unset).` : `\u{1F6AB} \`${investigateCmd}\` denied \u2014 your Slack user isn't on the diagnostic allowlist for \`${codeName}\`. Ask whoever operates this host to add you to \`SLACK_ALLOWED_USERS\`.`;
+    await postEphemeralViaResponseUrl(responseUrl, denialText, codeName);
+    return;
+  }
+  const channelId = payload.channel_id;
+  if (!channelId || !BOT_TOKEN) {
+    debugAuditLog(
+      `not-started reason=missing-${channelId ? "bot-token" : "channel"} user=${payload.user_id ?? "unknown"}`
+    );
+    await postEphemeralViaResponseUrl(
+      responseUrl,
+      `:warning: \`${investigateCmd}\` can't run \u2014 this channel process has no bot token wired.`,
+      codeName
+    );
+    return;
+  }
+  if (activeDebugTailExpiresAtMs !== null && activeDebugTailExpiresAtMs > Date.now()) {
+    const remaining = formatCountdown((activeDebugTailExpiresAtMs - Date.now()) / 1e3);
+    debugAuditLog(
+      `not-started reason=tail-already-running user=${payload.user_id ?? "unknown"} remaining=${remaining}`
+    );
+    await postEphemeralViaResponseUrl(
+      responseUrl,
+      `:hourglass: A \`${investigateCmd}\` tail is already running for \`${codeName}\` (one at a time) \u2014 it expires in ${remaining}.`,
+      codeName
+    );
+    return;
+  }
+  const reservedExpiresAtMs = Date.now() + DEBUG_TAIL_WINDOW_MS;
+  activeDebugTailExpiresAtMs = reservedExpiresAtMs;
+  const snapshot = await capturePaneSnapshot({ codeName, agentDir: SLACK_AGENT_DIR });
+  if (!snapshot) {
+    activeDebugTailExpiresAtMs = null;
+    debugAuditLog(`not-started reason=no-pane-output user=${payload.user_id ?? "unknown"}`);
+    await postEphemeralViaResponseUrl(
+      responseUrl,
+      `:warning: No pane output available for \`${codeName}\` yet \u2014 the agent session may not have started. (If the whole host is wedged, \`${investigateCmd}\` can't reach it either \u2014 fall back to the SSM diagnostics runbook.)`,
+      codeName
+    );
+    return;
+  }
+  debugAuditLog(`granted user=${payload.user_id ?? "unknown"} \u2014 starting live tail (source=${snapshot.source})`);
+  const initialFrame = {
+    body: redactPaneText(snapshot.text),
+    source: snapshot.source,
+    capturedAtLabel: nowUtcLabel()
+  };
+  const posted = await postSlackMessageWithTs({
+    channel: channelId,
+    text: formatPaneSnapshot({
+      codeName,
+      text: initialFrame.body,
+      source: initialFrame.source,
+      capturedAtLabel: initialFrame.capturedAtLabel,
+      status: {
+        kind: "live",
+        secondsRemaining: Math.max(0, Math.round((reservedExpiresAtMs - Date.now()) / 1e3))
+      }
+    })
+  });
+  if (!posted.ok || !posted.ts) {
+    activeDebugTailExpiresAtMs = null;
+    debugAuditLog(
+      `not-started reason=post-failed error=${posted.error ?? "unknown"} user=${payload.user_id ?? "unknown"}`
+    );
+    await postEphemeralViaResponseUrl(
+      responseUrl,
+      `:x: Failed to post the pane snapshot${posted.error ? ` (${posted.error})` : ""}. Try again in a moment.`,
+      codeName
+    );
+    return;
+  }
+  void runDebugTailLoop({
+    channel: channelId,
+    ts: posted.ts,
+    codeName,
+    initialFrame,
+    expiresAtMs: reservedExpiresAtMs
+  }).catch((err) => {
+    activeDebugTailExpiresAtMs = null;
+    debugAuditLog(`tail loop crashed: ${redactAugmentedPaths2(err.message)}`);
+  });
+}
 async function handleSlashCommandEnvelope(payload) {
   const command = payload.command;
   const responseUrl = payload.response_url;
   const codeName = AGENT_CODE_NAME ?? "unknown";
   if (!command || !responseUrl) return;
-  if (command === "/agent-status") {
+  if (matchesAgentCommand(command, "/agent-status")) {
     await postEphemeralViaResponseUrl(responseUrl, buildAgentStatusReply(codeName), codeName);
     return;
   }
@@ -16312,7 +16876,7 @@ async function handleSlashCommandEnvelope(payload) {
     await postEphemeralViaResponseUrl(responseUrl, buildSlackHelpMessage(codeName), codeName);
     return;
   }
-  if (command === "/restart") {
+  if (matchesAgentCommand(command, "/restart")) {
     if (ALLOWED_USERS.size > 0 && (!payload.user_id || !ALLOWED_USERS.has(payload.user_id))) {
       process.stderr.write(
         `slack-channel(${codeName}): /restart slash-command denied \u2014 user not in SLACK_ALLOWED_USERS
@@ -16334,10 +16898,10 @@ async function handleSlashCommandEnvelope(payload) {
       return;
     }
     try {
-      if (!existsSync2(RESTART_FLAGS_DIR)) {
+      if (!existsSync3(RESTART_FLAGS_DIR)) {
         mkdirSync3(RESTART_FLAGS_DIR, { recursive: true });
       }
-      const flagPath = join3(RESTART_FLAGS_DIR, `${codeName}.flag`);
+      const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
       const flag = {
         codeName,
         source: "slack",
@@ -16347,7 +16911,7 @@ async function handleSlashCommandEnvelope(payload) {
           ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
         }
       };
-      const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+      const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
       writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync2(tmpPath, flagPath);
       process.stderr.write(
@@ -16361,7 +16925,7 @@ async function handleSlashCommandEnvelope(payload) {
       );
     } catch (err) {
       process.stderr.write(
-        `slack-channel(${codeName}): /restart slash-command flag write failed: ${redactAugmentedPaths(err.message)}
+        `slack-channel(${codeName}): /restart slash-command flag write failed: ${redactAugmentedPaths2(err.message)}
 `
       );
       await postEphemeralViaResponseUrl(
@@ -16372,6 +16936,10 @@ async function handleSlashCommandEnvelope(payload) {
     }
     return;
   }
+  if (command === "/debug" || matchesAgentCommand(command, "/investigate")) {
+    await handleDebugSlashCommand(payload, responseUrl);
+    return;
+  }
   if (command === "/kill" || command === "/unkill") {
     if (!AGT_HOST || !AGT_API_KEY || !AGT_AGENT_ID) {
       await postEphemeralViaResponseUrl(
@@ -16441,10 +17009,10 @@ async function handleHelpCommand(opts) {
 async function handleRestartCommand(opts) {
   const codeName = AGENT_CODE_NAME ?? "unknown";
   try {
-    if (!existsSync2(RESTART_FLAGS_DIR)) {
+    if (!existsSync3(RESTART_FLAGS_DIR)) {
       mkdirSync3(RESTART_FLAGS_DIR, { recursive: true });
     }
-    const flagPath = join3(RESTART_FLAGS_DIR, `${codeName}.flag`);
+    const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
     const flag = {
       codeName,
       source: "slack",
@@ -16455,7 +17023,7 @@ async function handleRestartCommand(opts) {
         message_ts: opts.ts
       }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
     writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync2(tmpPath, flagPath);
     process.stderr.write(
@@ -16475,7 +17043,7 @@ async function handleRestartCommand(opts) {
     }
   } catch (err) {
     process.stderr.write(
-      `slack-channel(${codeName}): /restart flag write failed: ${redactAugmentedPaths(err.message)}
+      `slack-channel(${codeName}): /restart flag write failed: ${redactAugmentedPaths2(err.message)}
 `
     );
     await postSlackMessage({
@@ -16503,7 +17071,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 join3(homedir2(), ".augmented", AGENT_CODE_NAME, "slack-tracked-threads.json");
+  return join5(homedir2(), ".augmented", AGENT_CODE_NAME, "slack-tracked-threads.json");
 }
 function parseTtlDays(raw) {
   if (!raw) return void 0;
@@ -16538,9 +17106,9 @@ if (!BOT_TOKEN || !APP_TOKEN) {
 var slackStderrLogStream = null;
 if (AGENT_CODE_NAME) {
   try {
-    const logDir = join3(homedir2(), ".augmented", AGENT_CODE_NAME);
+    const logDir = join5(homedir2(), ".augmented", AGENT_CODE_NAME);
     mkdirSync3(logDir, { recursive: true });
-    slackStderrLogStream = createWriteStream(join3(logDir, "slack-channel-stderr.log"), {
+    slackStderrLogStream = createWriteStream(join5(logDir, "slack-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -16610,7 +17178,6 @@ void resolveBotUserIdOrThrow().then((id) => {
   );
   if (authFailed) slackBotUserIdClient?.reportAuthHealth(false);
 });
-var selfIdentityInstruction = `Mentions of your own Slack bot user are directed at you, even inside auto_followed threads.`;
 var mcp = new Server(
   { name: "slack", version: "0.1.0" },
   {
@@ -16625,43 +17192,18 @@ var mcp = new Server(
       // 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.",
-      'Messages from Slack arrive as <channel source="slack" user="<slack-id>" user_name="<display-name>" channel="..." thread_ts="...">. Pass channel + thread_ts from the tag to slack.reply; always include thread_ts on threaded replies.',
-      "Long task (3+ tool calls or >5s)? slack_progress_start (channel + thread_ts), slack_progress_update between steps, slack_progress_complete/_fail to close. One anchor edits in place; avoids thread spam. Not for one-shots.",
-      selfIdentityInstruction,
+      `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.",
-      'Mentioned in a channel \u2192 respond in that thread. DM \u2192 respond directly. auto_followed="true" \u2192 only reply if you have something useful to add.',
-      "Reaction taxonomy (use slack.react sparingly \u2014 prefer a reply): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u2705 = success. NEVER react to signal failure \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).",
+      'Mentioned in a channel \u2192 respond in that thread. DM \u2192 respond directly. 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): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u2705 = success. 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.)",
       `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(" ")
   }
 );
-var progressRegistry = new ProgressToolRegistry({
-  prefix: "slack",
-  surfaceDescription: "a Slack thread",
-  startArgsSchema: {
-    properties: {
-      channel: {
-        type: "string",
-        description: "Slack channel id (from the `channel` attribute on the inbound <channel> tag)."
-      },
-      thread_ts: {
-        type: "string",
-        description: "Thread `ts` so the anchor lands in the same thread as the request (from the `thread_ts` attribute on the inbound <channel> tag). Omit to post at channel-root."
-      }
-    },
-    required: ["channel"]
-  },
-  createFlush: (args) => createSlackProgressFlush({
-    botToken: BOT_TOKEN,
-    channel: args.channel,
-    threadTs: typeof args.thread_ts === "string" ? args.thread_ts : void 0
-  })
-});
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
-    ...progressRegistry.getDefinitions(),
     {
       name: "slack.reply",
       description: "Send a message back to a Slack channel or thread",
@@ -16675,7 +17217,18 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           text: { type: "string", description: "The message to send" },
           thread_ts: {
             type: "string",
-            description: "Thread timestamp for threaded replies (from the thread_ts attribute)"
+            description: "Thread timestamp for threaded replies (from the thread_ts attribute). Omit for a top-level reply (e.g. a fresh DM)."
+          },
+          // ENG-5861: explicit message_ts so the cleanup gate can match the
+          // exact pending-inbound marker — necessary because top-level DM
+          // replies legitimately have no thread_ts and the marker filename
+          // is `<channel>__<thread_ts>__<message_ts>.json`. Without this
+          // the marker sat undrained, eventually tripping ENG-5832\'s
+          // "wedged" threshold and firing a false-positive red ✗ on the
+          // next inbound.
+          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."
           }
         },
         required: ["channel", "text"]
@@ -16683,7 +17236,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "slack.react",
-      description: "Add an emoji reaction to a Slack message. Use sparingly \u2014 prefer a text reply. Reaction taxonomy: \u2705 = action completed successfully. NEVER react to signal failure \u2014 users can't tell why it failed from a reaction. On failure, call slack.reply with one sentence explaining what went wrong instead. \u{1F440} (eyes) is already auto-applied on inbound; do not duplicate.",
+      description: "Add an emoji reaction to a Slack message. Use sparingly \u2014 prefer a text reply. Reaction taxonomy: \u2705 = action completed successfully. NEVER react to signal failure of your work \u2014 users can't tell why it failed from a reaction. On failure, call slack.reply with one sentence explaining what went wrong instead. \u{1F440} (eyes) is already auto-applied on inbound; do not duplicate. \u23F3 (:hourglass_flowing_sand:) is reserved for the system to mark an inbound that arrived while the agent couldn't reply \u2014 never add \u23F3 or \u274C yourself.",
       inputSchema: {
         type: "object",
         properties: {
@@ -16696,7 +17249,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "slack.read_thread",
-      description: "Read the full message history of a Slack thread. Use this to catch up on thread context before replying, especially for auto-followed threads.",
+      description: "Read the full message history of a Slack thread. Inbound thread replies already carry the surrounding thread inline as the <channel> tag's thread_context attribute \u2014 ground your reply in that first, and only call this tool when you need MORE history than thread_context shows (it is capped to recent messages) or to catch up on an auto-followed thread.",
       inputSchema: {
         type: "object",
         properties: {
@@ -16741,7 +17294,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
     ...blockKitToolsAvailable() ? [
       {
         name: "slack.send_structured",
-        description: 'Send a Slack message built from Block Kit blocks (structured layout: headers, sections, dividers, context, action buttons). Use when plain text isn\'t enough \u2014 status reports, confirmations with multiple fields, calls-to-action with buttons. Pass a `text` fallback for push notifications. Returns { message_ts, permalink }. Does NOT block waiting for user interactions; for that use slack.ask_user. Pass `interactive: { type: "rate_run", run_id }` to append a 1-5 rating button row that records the score against this scheduled-task run (ENG-4572).',
+        description: "Send a Slack message built from Block Kit blocks (structured layout: headers, sections, dividers, context, action buttons). Use when plain text isn't enough \u2014 status reports, confirmations with multiple fields, calls-to-action with buttons. Pass a `text` fallback for push notifications. Returns { message_ts, permalink }. Does NOT block waiting for user interactions; for that use slack.ask_user.",
         inputSchema: {
           type: "object",
           properties: {
@@ -16751,18 +17304,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
               description: "Array of Block Kit blocks. Supported block types: header, section, divider, context, actions. Supported interactive elements (inside actions blocks): button. Hard limits: 50 blocks per message, 5 elements per actions block, 3000 chars per section text, 75 chars per button label."
             },
             text: { type: "string", description: "Plain-text fallback for push notifications and unfurls. Required." },
-            thread_ts: { type: "string", description: "Thread timestamp for threaded replies (optional)" },
-            interactive: {
-              type: "object",
-              description: `Optional interactive affordance appended to the message. Currently supports type="rate_run" \u2014 appends a 1-5 button row that updates this run's rating when tapped. Use after a scheduled-task delivery so users can rate the firing.`,
-              properties: {
-                type: { type: "string", enum: ["rate_run"], description: 'Affordance kind. Only "rate_run" is supported today.' },
-                run_id: { type: "string", description: "The runs.run_id this rating belongs to (returned by /host/runs/start)." },
-                scale: { type: "string", enum: ["1-5", "sentiment"], description: 'Rating scale. Default "1-5" (1..5 buttons). "sentiment" emits \u{1F44E}/\u{1F914}/\u{1F44D} mapping to -1/0/+1 \u2014 reserved for future Telegram parity.' },
-                expires_in_seconds: { type: "number", description: "How long the rating row stays tappable. Default 86400 (24h). The pending row times out after this; later taps are ignored." }
-              },
-              required: ["type", "run_id"]
-            }
+            thread_ts: { type: "string", description: "Thread timestamp for threaded replies (optional)" }
           },
           required: ["channel", "blocks", "text"]
         }
@@ -16909,10 +17451,11 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name, arguments: args } = req.params;
-  const progressResult = await progressRegistry.handle(name, args ?? {});
-  if (progressResult !== void 0) return progressResult;
+  if (isImpersonating() && !channelsEnabledOverride() && SLACK_EGRESS_TOOLS.has(name)) {
+    return buildImpersonationRefusal(name);
+  }
   if (name === "slack.reply") {
-    const { channel, text, thread_ts } = args;
+    const { channel, text, thread_ts, message_ts } = args;
     if (channel && thread_ts) {
       const killed = await isThreadKilled({
         channelType: "slack",
@@ -16971,8 +17514,15 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
-    if (channel && thread_ts) {
-      clearPendingMessage(channel, thread_ts);
+    if (channel) {
+      if (message_ts) {
+        clearSlackPendingMarkerByMessageTs2(channel, message_ts);
+        if (thread_ts) clearPendingMessage(channel, thread_ts);
+      } else if (thread_ts) {
+        clearPendingMessage(channel, thread_ts);
+      } else {
+        clearOldestSlackPendingMarkerInChannel2(channel);
+      }
     }
     try {
       const res = await fetch("https://slack.com/api/chat.postMessage", {
@@ -17067,46 +17617,22 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     const limit = Math.min(Math.max(rawLimit ?? 50, 1), 200);
     noteThreadActivity(channel, thread_ts);
     try {
-      const allMessages = [];
-      let cursor;
-      do {
-        const remaining = limit - allMessages.length;
-        if (remaining <= 0) break;
-        const params = new URLSearchParams({
-          channel,
-          ts: thread_ts,
-          limit: String(Math.min(remaining, 100)),
-          ...cursor ? { cursor } : {}
-        });
-        const res = await fetch(`https://slack.com/api/conversations.replies?${params}`, {
-          headers: { Authorization: `Bearer ${BOT_TOKEN}` }
-        });
-        const data = await res.json();
-        if (!data.ok) {
-          return {
-            content: [{ type: "text", text: `Slack error: ${data.error}` }],
-            isError: true
-          };
-        }
-        for (const msg of data.messages ?? []) {
-          allMessages.push({
-            user: msg.user ?? msg.bot_id ?? "unknown",
-            text: msg.text ?? "",
-            ts: msg.ts ?? ""
-          });
-        }
-        cursor = data.response_metadata?.next_cursor || void 0;
-      } while (cursor && allMessages.length < limit);
-      const uniqueUserIds = [...new Set(allMessages.map((m) => m.user))];
-      const resolved = await Promise.all(uniqueUserIds.map(async (id) => [id, await resolveUserName(id)]));
-      const nameById = new Map(resolved);
-      const formatted = allMessages.map((m) => `[${m.ts}] ${nameById.get(m.user) ?? m.user} (<@${m.user}>): ${m.text}`).join("\n");
+      const result = await fetchThreadTranscript(channel, thread_ts, limit, {
+        botToken: BOT_TOKEN,
+        resolveUserName
+      });
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: `Slack error: ${result.error}` }],
+          isError: true
+        };
+      }
       return {
         content: [{
           type: "text",
-          text: allMessages.length > 0 ? `Thread (${allMessages.length} messages):
+          text: result.count > 0 ? `Thread (${result.count} messages):
 
-${formatted}` : "Thread is empty or not found."
+${result.formatted}` : "Thread is empty or not found."
         }]
       };
     } catch (err) {
@@ -17148,15 +17674,15 @@ ${formatted}` : "Thread is empty or not found."
     let bytes;
     let size;
     try {
-      const stat = statSync(resolvedPath);
-      if (!stat.isFile()) {
+      const stat2 = statSync2(resolvedPath);
+      if (!stat2.isFile()) {
         return {
           content: [{ type: "text", text: `Upload refused: ${resolvedPath} is not a regular file.` }],
           isError: true
         };
       }
-      size = stat.size;
-      bytes = readFileSync3(resolvedPath);
+      size = stat2.size;
+      bytes = readFileSync4(resolvedPath);
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed to read file: ${err.message}` }],
@@ -17266,7 +17792,7 @@ ${formatted}` : "Thread is empty or not found."
       return {
         content: [{
           type: "text",
-          text: `Failed to download attachment: ${redactAugmentedPaths(err.message)}`
+          text: `Failed to download attachment: ${redactAugmentedPaths2(err.message)}`
         }],
         isError: true
       };
@@ -17453,109 +17979,28 @@ async function handleSendStructured(args) {
   }
   const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
   const { validateSlackBlocks: validateSlackBlocks2 } = runtime;
-  const { channel, blocks, text, thread_ts, interactive } = args;
+  const { channel, blocks, text, thread_ts } = args;
   if (typeof channel !== "string" || !channel) {
-    return errResult2("channel is required");
+    return errResult("channel is required");
   }
   if (typeof text !== "string" || !text) {
-    return errResult2("text is required (used as fallback for push notifications and unfurls)");
+    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 errResult2(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
-  }
-  let effectiveBlocks = blocks;
-  let ratingCallbackId = null;
-  let ratingExpiresAt = null;
-  let ratingTokenised = [];
-  if (interactive) {
-    if (interactive.type !== "rate_run") {
-      return errResult2(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
-    }
-    if (typeof interactive.run_id !== "string" || !interactive.run_id) {
-      return errResult2("interactive.run_id is required when interactive is set");
-    }
-    if (!interactiveHostAvailable()) {
-      return errResult2(
-        "interactive=rate_run requires Block Kit plus host MCP wiring (AGT_HOST, AGT_API_KEY, AGT_AGENT_ID)."
-      );
-    }
-    const scale = interactive.scale === "sentiment" ? "sentiment" : "1-5";
-    const requestedTtl = typeof interactive.expires_in_seconds === "number" ? interactive.expires_in_seconds : 86400;
-    const ttl = Math.max(60, Math.min(7 * 86400, requestedTtl));
-    const { randomUUID: rndUUID } = await import("crypto");
-    ratingCallbackId = rndUUID();
-    ratingExpiresAt = new Date(Date.now() + ttl * 1e3);
-    const values = runtime.ratingValuesForScale(scale);
-    const labels = runtime.defaultRatingLabels(scale);
-    ratingTokenised = values.map((v, i) => ({
-      token: runtime.generateOptionToken(),
-      value: String(v),
-      label: labels[i] ?? String(v)
-    }));
-    const ratingBlock = runtime.buildRatingActionsBlock({
-      callbackId: ratingCallbackId,
-      options: ratingTokenised.map(({ label, token }) => ({
-        // The numeric value is carried by token → options mapping in the
-        // pending_interaction row, not by the button itself, so this
-        // cast-back to RatingOption only needs label + token + a placeholder.
-        value: 0,
-        label,
-        token
-      }))
-    });
-    effectiveBlocks = [...blocks, ratingBlock];
-    const finalValidation = runtime.validateSlackBlocks(effectiveBlocks);
-    if (!finalValidation.ok) {
-      return errResult2(
-        `Invalid blocks (after appending rating row): ${finalValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
-      );
-    }
-    const cfg = {
-      apiHost: AGT_HOST,
-      apiKey: AGT_API_KEY,
-      agentId: AGT_AGENT_ID
-    };
-    try {
-      await runtime.createPendingInteraction(cfg, {
-        callbackId: ratingCallbackId,
-        channelId: channel,
-        messageTs: "",
-        threadTs: thread_ts,
-        options: ratingTokenised,
-        expiresAt: ratingExpiresAt,
-        kind: "rate_run",
-        kindData: { run_id: interactive.run_id, scale }
-      });
-    } catch (err) {
-      return errResult2(`Failed to register rating row: ${err.message}`);
-    }
+    return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   const result = await postSlackMessageWithTs({
     channel,
-    blocks: effectiveBlocks,
+    blocks,
     text,
     ...thread_ts ? { thread_ts } : {}
   });
   if (!result.ok || !result.ts) {
-    return errResult2(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
+    return errResult(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
   }
-  if (ratingCallbackId) {
-    try {
-      await runtime.updatePendingInteractionMessageTs(
-        { apiHost: AGT_HOST, apiKey: AGT_API_KEY, agentId: AGT_AGENT_ID },
-        ratingCallbackId,
-        result.ts
-      );
-    } catch (err) {
-      process.stderr.write(
-        `slack-channel(${AGENT_CODE_NAME}): updatePendingInteractionMessageTs failed for rating ${hashId(ratingCallbackId)}: ${err.message}
-`
-      );
-    }
-  }
-  if (interactiveHostAvailable() && !ratingCallbackId) {
+  if (interactiveHostAvailable()) {
     const cfg = {
       apiHost: AGT_HOST,
       apiKey: AGT_API_KEY,
@@ -17585,8 +18030,7 @@ async function handleSendStructured(args) {
         type: "text",
         text: JSON.stringify({
           message_ts: result.ts,
-          permalink: permalink ?? "",
-          ...ratingCallbackId ? { rating_callback_id: ratingCallbackId } : {}
+          permalink: permalink ?? ""
         })
       }
     ]
@@ -17594,17 +18038,17 @@ async function handleSendStructured(args) {
 }
 async function handleAskUser(args) {
   if (!askUserToolAvailable()) {
-    return errResult2("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
+    return errResult("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
   }
   const { randomUUID: rndUUID } = await import("crypto");
   const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
   const { validateAskUserOptions: validateAskUserOptions2, buildAskUserBlocks: buildAskUserBlocks2 } = runtime;
   const { channel, question, options, timeout_seconds, thread_ts } = args;
-  if (typeof channel !== "string" || !channel) return errResult2("channel is required");
-  if (typeof question !== "string" || !question) return errResult2("question is required");
+  if (typeof channel !== "string" || !channel) return errResult("channel is required");
+  if (typeof question !== "string" || !question) return errResult("question is required");
   const optsValidation = validateAskUserOptions2(options);
   if (!optsValidation.ok) {
-    return errResult2(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+    return errResult(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
   const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
@@ -17637,7 +18081,7 @@ async function handleAskUser(args) {
       expiresAt
     });
   } catch (err) {
-    return errResult2(`Failed to register pending interaction: ${err.message}`);
+    return errResult(`Failed to register pending interaction: ${err.message}`);
   }
   const slackResult = await postSlackMessageWithTs({
     channel,
@@ -17647,7 +18091,7 @@ async function handleAskUser(args) {
     ...thread_ts ? { thread_ts } : {}
   });
   if (!slackResult.ok || !slackResult.ts) {
-    return errResult2(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
+    return errResult(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
   }
   try {
     await runtime.updatePendingInteractionMessageTs(cfg, callbackId, slackResult.ts);
@@ -17694,7 +18138,7 @@ async function handleAskUser(args) {
 }
 async function handleChannelRequestInput(args) {
   if (!askUserToolAvailable()) {
-    return errResult2(
+    return errResult(
       "channel_request_input is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring."
     );
   }
@@ -17702,10 +18146,10 @@ async function handleChannelRequestInput(args) {
   const { apiCall: apiCall2, waitForResolution: waitForResolution2, validateAskUserOptions: validateAskUserOptions2 } = runtime;
   const { thread_id, prompt_text, options, schema, request_id, timeout_seconds } = args;
   if (typeof thread_id !== "string" || !thread_id) {
-    return errResult2("thread_id is required (shape: `<channel_id>:<thread_ts>`)");
+    return errResult("thread_id is required (shape: `<channel_id>:<thread_ts>`)");
   }
   if (typeof prompt_text !== "string" || !prompt_text) {
-    return errResult2("prompt_text is required");
+    return errResult("prompt_text is required");
   }
   const optsValidation = validateAskUserOptions2(options, {
     maxOptions: 4,
@@ -17713,25 +18157,25 @@ async function handleChannelRequestInput(args) {
     maxValueChars: 2e3
   });
   if (!optsValidation.ok) {
-    return errResult2(
+    return errResult(
       `Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
     );
   }
   const optionsArr = options;
   if (optionsArr.length < 2) {
-    return errResult2("options must contain at least 2 entries (this is a picker, not a notification)");
+    return errResult("options must contain at least 2 entries (this is a picker, not a notification)");
   }
   if (!schema || typeof schema.type !== "string") {
-    return errResult2("schema is required with shape { type: 'yes_no' | 'choice' }");
+    return errResult("schema is required with shape { type: 'yes_no' | 'choice' }");
   }
   if (schema.type !== "yes_no" && schema.type !== "choice") {
-    return errResult2("schema.type must be 'yes_no' or 'choice'");
+    return errResult("schema.type must be 'yes_no' or 'choice'");
   }
   if (schema.type === "yes_no" && optionsArr.length !== 2) {
-    return errResult2("schema.type='yes_no' requires exactly 2 options");
+    return errResult("schema.type='yes_no' requires exactly 2 options");
   }
   if (request_id !== void 0 && (typeof request_id !== "string" || !request_id)) {
-    return errResult2("request_id must be a non-empty string when provided");
+    return errResult("request_id must be a non-empty string when provided");
   }
   const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
   const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
@@ -17753,10 +18197,10 @@ async function handleChannelRequestInput(args) {
     dispatchPayload = await res.json().catch(() => ({}));
     if (!res.ok || !dispatchPayload.ok || !dispatchPayload.callback_id) {
       const reason = dispatchPayload.reason ?? `http_${res.status}`;
-      return errResult2(`channel_request_input dispatch failed: ${reason}`);
+      return errResult(`channel_request_input dispatch failed: ${reason}`);
     }
   } catch (err) {
-    return errResult2(
+    return errResult(
       `channel_request_input dispatch failed: ${err.message}`
     );
   }
@@ -17794,7 +18238,7 @@ async function handleChannelRequestInput(args) {
     ]
   };
 }
-function errResult2(text) {
+function errResult(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
 var MAX_INBOUND_FILE_BYTES = 25 * 1024 * 1024;
@@ -17823,7 +18267,7 @@ function isDownloadableFileId(fileId, channel) {
   }
   return entry.channel === channel;
 }
-function redactAugmentedPaths(msg) {
+function redactAugmentedPaths2(msg) {
   return msg.replaceAll(
     new RegExp(`${homedir2().replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}/\\.augmented/[^\\s'"\`]*`, "g"),
     "<augmented-path>"
@@ -17905,7 +18349,7 @@ async function buildInboundFileMeta(rawFiles, codeName, channel) {
         });
       } catch (err) {
         process.stderr.write(
-          `slack-channel: image auto-download failed for ${classified.id}: ${redactAugmentedPaths(err.message)}
+          `slack-channel: image auto-download failed for ${classified.id}: ${redactAugmentedPaths2(err.message)}
 `
         );
         registerDownloadableFileId(classified.id, channel);
@@ -17988,6 +18432,7 @@ async function connectSocketMode() {
     process.stderr.write("slack-channel: Socket Mode connected\n");
     recordActivity("connect");
     void setBotStatus(":large_green_circle:", "Active");
+    void notifyStrandedInboundsOnFirstConnect();
   };
   ws.onmessage = async (event) => {
     try {
@@ -18049,8 +18494,27 @@ async function connectSocketMode() {
       }
       const senderPolicyDecision = decideSenderPolicyForward(evt, SLACK_SENDER_POLICY);
       if (!senderPolicyDecision.forward) {
-        process.stderr.write(`slack-channel: dropped message event (reason=sender_policy, mode=${SLACK_SENDER_POLICY.mode}, ts=${evt.ts ?? "n/a"})
+        const subReason = classifySlackPolicyBlock(evt, SLACK_SENDER_POLICY);
+        process.stderr.write(`slack-channel: dropped message event (reason=sender_policy, sub=${subReason}, mode=${SLACK_SENDER_POLICY.mode}, ts=${evt.ts ?? "n/a"})
 `);
+        await maybeSendSenderPolicyDecline({
+          channel: evt.channel,
+          senderId: evt.user,
+          // CR on PR #1623: top-level posts (DMs, channel root messages)
+          // arrive with no `thread_ts` and MUST decline inline, not in a
+          // new thread off the inbound message. The `?? evt.ts` fallback
+          // forced every root message into a thread reply — exactly the
+          // case the helper's "omit thread_ts when undefined" branch was
+          // meant to handle. Pass through as-is: in-thread for thread
+          // replies (thread_ts present), inline for everything else.
+          threadTs: evt.thread_ts,
+          subReason
+        }).catch((err) => {
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): decline reply failed: ${err.message}
+`
+          );
+        });
         return;
       }
       recordActivity("inbound");
@@ -18060,7 +18524,8 @@ async function connectSocketMode() {
       const threadKey = buildThreadKey(evt.channel, trackTs);
       const rawText = evt.text ?? "";
       const strippedText = rawText.replace(/^\s*<@[^>]+>\s*/, "").trim();
-      const isRestartCommand = strippedText === "/restart" || strippedText.startsWith("/restart ");
+      const restartSuffixed = agentSlashCommand("/restart");
+      const isRestartCommand = strippedText === "/restart" || strippedText.startsWith("/restart ") || strippedText === restartSuffixed || strippedText.startsWith(`${restartSuffixed} `);
       const isHelpCommand = strippedText === "/help" || strippedText.startsWith("/help ");
       if (isHelpCommand) {
         await handleHelpCommand({
@@ -18176,19 +18641,41 @@ async function connectSocketMode() {
         isAutoFollowed,
         botUserId
       });
-      if (decideSlackAckReaction({ channel, ts })) {
+      const ackProbe = process.env.TMUX && AGENT_CODE_NAME ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
+      let paneLogFreshAgeMs = null;
+      if (SLACK_AGENT_DIR) {
+        try {
+          const paneMtimeMs = statSync2(join5(SLACK_AGENT_DIR, "pane.log")).mtimeMs;
+          paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
+        } catch {
+        }
+      }
+      const ackDecision = decideAckReaction({
+        hasTarget: decideSlackAckReaction({ channel, ts }),
+        integrationReady: Boolean(BOT_TOKEN),
+        tmux: ackProbe.tmux,
+        claude: ackProbe.claude,
+        withinStartupGrace: process.uptime() * 1e3 < ACK_STARTUP_GRACE_MS,
+        oldestPendingAgeMs: oldestPendingMarkerAgeMs(SLACK_PENDING_INBOUND_DIR),
+        paneLogFreshAgeMs
+      });
+      if (ackDecision !== "none") {
+        const reactionName = ackDecision === "undeliverable" ? SLACK_UNDELIVERABLE_REACTION : "eyes";
         fetch("https://slack.com/api/reactions.add", {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${BOT_TOKEN}`
           },
-          body: JSON.stringify({ channel, timestamp: ts, name: "eyes" })
+          body: JSON.stringify({ channel, timestamp: ts, name: reactionName })
         }).catch(() => {
         });
+        if (ackDecision === "undeliverable" && channel && shouldEngage) {
+          postUndeliverableNotice(channel, threadTs, isThreadReply);
+        }
       }
       if (channel && ts && shouldEngage) {
-        trackPendingMessage(channel, threadTs, ts);
+        trackPendingMessage(channel, threadTs, ts, ackDecision === "undeliverable");
       }
       const userName = await resolveUserName(user);
       const fileMeta = await buildInboundFileMeta(evt.files, AGENT_CODE_NAME, channel);
@@ -18196,6 +18683,29 @@ async function connectSocketMode() {
         (f) => f.kind === "image" && typeof f.path === "string"
       );
       const imagePath = downloadedImages.length === 1 ? downloadedImages[0].path : void 0;
+      let threadContext;
+      if (isThreadReply && channel && threadTs) {
+        try {
+          const transcript = await fetchThreadTranscript(
+            channel,
+            threadTs,
+            SLACK_AUTOLOAD_THREAD_LIMIT,
+            { botToken: BOT_TOKEN, resolveUserName }
+          );
+          if (transcript.ok && transcript.count >= 2) {
+            threadContext = capThreadContext(
+              transcript.formatted,
+              SLACK_AUTOLOAD_THREAD_MAX_CHARS
+            );
+          }
+        } catch (err) {
+          const msg2 = err instanceof Error ? err.message : String(err);
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): thread_context fetch failed (channel=${redactSlackId(channel)} thread=${redactSlackId(threadTs)}): ${msg2}
+`
+          );
+        }
+      }
       await mcp.notification({
         method: "notifications/claude/channel",
         params: {
@@ -18205,12 +18715,21 @@ async function connectSocketMode() {
             user_name: userName,
             channel,
             thread_ts: threadTs,
+            // 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
+            // threadTs is the thread root and message_ts is the specific
+            // reply being addressed — different keys, both needed by the
+            // marker-cleanup gate.
+            message_ts: ts,
             event_type: evt.type,
             ...isAutoFollowed ? { auto_followed: "true" } : {},
             // Only set these when we actually have attachments to avoid
             // bloating every notification with empty metadata.
             ...fileMeta.length > 0 ? { files: JSON.stringify(fileMeta) } : {},
-            ...imagePath ? { image_path: imagePath } : {}
+            ...imagePath ? { image_path: imagePath } : {},
+            // ENG-5830: the pre-loaded surrounding thread (thread replies only).
+            ...threadContext ? { thread_context: threadContext } : {}
           }
         }
       });
@@ -18323,3 +18842,7 @@ if (THREAD_STORE_PATH) {
   );
 }
 connectSocketModeSafely();
+export {
+  __resetSlackGiveUpNoticeStateForTests,
+  __resetSlackUndeliverableNoticeThrottle
+};