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

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,23 +14218,95 @@ 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";
@@ -14261,6 +14314,11 @@ function decideAckReaction(i) {
   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";
@@ -14268,6 +14326,39 @@ function decideAckReaction(i) {
 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;
@@ -14295,6 +14386,21 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
   }
   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";
@@ -14348,6 +14454,233 @@ function probeAgentSessionCached(codeName, ttlMs = SESSION_PROBE_TTL_MS, now = D
   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 = {
   threshold: 3,
@@ -14555,6 +14888,69 @@ var SLACK_EGRESS_TOOLS = /* @__PURE__ */ new Set([
   "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 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;
+    }
+  } 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;
+    }
+  } catch {
+  }
+  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 {
+        mtime = statSync(full).mtimeMs;
+      } catch {
+      }
+      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;
+  }
+}
+
 // ../../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";
 
@@ -14651,17 +15047,17 @@ var StdioServerTransport = class {
 import {
   chmodSync,
   createWriteStream,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
-  readdirSync as readdirSync2,
+  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 join4, resolve as resolve2 } from "path";
+import { basename, join as join5, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
 import { createHash, randomUUID } from "crypto";
 
@@ -14790,88 +15186,6 @@ async function runOrRetry(fn, opts) {
   }
 }
 
-// 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);
-}
-
 // src/slack-inbound-files.ts
 function classifySlackFile(file) {
   if (!file || typeof file.id !== "string" || !file.id) return null;
@@ -15438,14 +15752,14 @@ function createSlackBotUserIdClient(args) {
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync3,
   renameSync,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function defaultIsPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -15463,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 = join3(agentDir, basename2);
+  const path = join4(agentDir, basename2);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -15487,12 +15801,12 @@ 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 = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
@@ -15509,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";
@@ -15576,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 ? join4(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
-var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join4(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
-var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join4(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>";
@@ -15590,7 +15999,7 @@ function safeSlackMarkerName(channel, threadTs, messageTs) {
 }
 function slackPendingInboundPath(channel, threadTs, messageTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return null;
-  return join4(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
+  return join5(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
 }
 function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
@@ -15619,12 +16028,16 @@ function healSlackUndeliverable(channel, messageTs) {
     "Content-Type": "application/json",
     Authorization: `Bearer ${BOT_TOKEN}`
   };
-  fetch("https://slack.com/api/reactions.remove", {
+  const remove = (name) => fetch("https://slack.com/api/reactions.remove", {
     method: "POST",
     headers,
-    body: JSON.stringify({ channel, timestamp: messageTs, name: "x" })
+    body: JSON.stringify({ channel, timestamp: messageTs, name })
   }).catch(() => {
-  }).finally(() => {
+  });
+  void Promise.allSettled([
+    remove(SLACK_UNDELIVERABLE_REACTION),
+    remove(SLACK_UNDELIVERABLE_REACTION_LEGACY)
+  ]).finally(() => {
     fetch("https://slack.com/api/reactions.add", {
       method: "POST",
       headers,
@@ -15633,6 +16046,32 @@ function healSlackUndeliverable(channel, messageTs) {
     });
   });
 }
+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 {
@@ -15646,22 +16085,32 @@ function clearSlackMarkerFileWithHeal(fullPath) {
     healSlackUndeliverable(marker.channel, marker.message_ts);
   }
   try {
-    if (existsSync2(fullPath)) unlinkSync2(fullPath);
+    if (existsSync3(fullPath)) unlinkSync3(fullPath);
   } catch {
   }
 }
-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}__`;
-  try {
-    for (const f of readdirSync2(SLACK_PENDING_INBOUND_DIR)) {
-      if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
-      clearSlackMarkerFileWithHeal(join4(SLACK_PENDING_INBOUND_DIR, f));
-    }
-  } 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$/);
@@ -15677,7 +16126,7 @@ function slackNextRetryName(filename) {
 async function processSlackRecoveryOutboxFile(filename) {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
-  const fullPath = join4(SLACK_RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join5(SLACK_RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
     payload = JSON.parse(readFileSync4(fullPath, "utf-8"));
@@ -15746,7 +16195,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync2(fullPath);
+      unlinkSync3(fullPath);
     } catch {
     }
     return;
@@ -15754,7 +16203,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   const next = slackNextRetryName(filename);
   if (next) {
     try {
-      renameSync2(fullPath, join4(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}
@@ -15784,7 +16233,7 @@ function scanSlackRecoveryRetries() {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync2(SLACK_RECOVERY_OUTBOX_DIR);
+    entries = readdirSync3(SLACK_RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -15793,7 +16242,7 @@ function scanSlackRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync(join4(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync2(join5(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -15814,7 +16263,7 @@ function startSlackRecoveryOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync2(SLACK_RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync3(SLACK_RECOVERY_OUTBOX_DIR)) {
       if (isFirstAttemptSlackOutboxFile(f)) void processSlackRecoveryOutboxFile(f);
     }
   } catch {
@@ -15823,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(join4(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync3(join5(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
         void processSlackRecoveryOutboxFile(filename);
       }
     });
@@ -15842,12 +16291,12 @@ var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
 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 = readdirSync2(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}
@@ -15860,7 +16309,7 @@ function sweepSlackStaleMarkersOnBoot() {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join4(SLACK_PENDING_INBOUND_DIR, filename);
+    const fullPath = join5(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
       marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
@@ -15870,25 +16319,16 @@ function sweepSlackStaleMarkersOnBoot() {
 `
       );
       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) {
-      try {
-        unlinkSync2(fullPath);
-      } catch {
-      }
-      cleared++;
-      continue;
-    }
-    const receivedAtMs = Date.parse(received_at);
-    if (!Number.isFinite(receivedAtMs) || receivedAtMs > now || now - receivedAtMs > STALE_MARKER_MS) {
+    if (!channel || !thread_ts || !message_ts || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
@@ -15901,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;
@@ -15913,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 = readdirSync2(SLACK_PENDING_INBOUND_DIR);
+    filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
   } catch {
     return;
   }
@@ -15927,10 +16525,10 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   for (const filename of filenames) {
     if (!filename.startsWith(channelPrefix)) continue;
     if (!filename.endsWith(messageSuffix)) continue;
-    clearSlackMarkerFileWithHeal(join4(SLACK_PENDING_INBOUND_DIR, filename));
+    clearSlackMarkerFileWithHeal(join5(SLACK_PENDING_INBOUND_DIR, filename));
   }
 }
-var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
+var RESTART_FLAGS_DIR = join5(homedir2(), ".augmented", "restart-flags");
 function buildAugmentedSlackMetadata() {
   if (!AGT_TEAM_ID) return void 0;
   return {
@@ -15980,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;
@@ -16074,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;
   }
@@ -16087,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
@@ -16109,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 = join4(RESTART_FLAGS_DIR, `${codeName}.flag`);
+      const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
       const flag = {
         codeName,
         source: "slack",
@@ -16136,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(
@@ -16147,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(
@@ -16216,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 = join4(RESTART_FLAGS_DIR, `${codeName}.flag`);
+    const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
     const flag = {
       codeName,
       source: "slack",
@@ -16250,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({
@@ -16278,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 join4(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;
@@ -16313,9 +17106,9 @@ if (!BOT_TOKEN || !APP_TOKEN) {
 var slackStderrLogStream = null;
 if (AGENT_CODE_NAME) {
   try {
-    const logDir = join4(homedir2(), ".augmented", AGENT_CODE_NAME);
+    const logDir = join5(homedir2(), ".augmented", AGENT_CODE_NAME);
     mkdirSync3(logDir, { recursive: true });
-    slackStderrLogStream = createWriteStream(join4(logDir, "slack-channel-stderr.log"), {
+    slackStderrLogStream = createWriteStream(join5(logDir, "slack-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -16399,11 +17192,11 @@ 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.",
-      `Inbound: <channel ... thread_ts="..." [thread_context="..."]>. Pass channel + thread_ts to slack.reply on threads. thread_context = thread pre-loaded; ground replies ONLY in it, never another channel's.`,
+      `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 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 \u274C 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 \u274C yourself.)",
+      "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(" ")
@@ -16424,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"]
@@ -16432,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 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. \u274C (:x:) is reserved for the system to mark an inbound that arrived while the agent couldn't reply \u2014 never add \u274C yourself.",
+      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: {
@@ -16490,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: {
@@ -16500,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"]
         }
@@ -16662,7 +17455,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     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",
@@ -16721,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", {
@@ -16874,14 +17674,14 @@ ${result.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;
+      size = stat2.size;
       bytes = readFileSync4(resolvedPath);
     } catch (err) {
       return {
@@ -16992,7 +17792,7 @@ ${result.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
       };
@@ -17179,7 +17979,7 @@ 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 errResult("channel is required");
   }
@@ -17191,97 +17991,16 @@ async function handleSendStructured(args) {
   if (!validation.ok) {
     return errResult(`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 errResult(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
-    }
-    if (typeof interactive.run_id !== "string" || !interactive.run_id) {
-      return errResult("interactive.run_id is required when interactive is set");
-    }
-    if (!interactiveHostAvailable()) {
-      return errResult(
-        "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 errResult(
-        `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 errResult(`Failed to register rating row: ${err.message}`);
-    }
-  }
   const result = await postSlackMessageWithTs({
     channel,
-    blocks: effectiveBlocks,
+    blocks,
     text,
     ...thread_ts ? { thread_ts } : {}
   });
   if (!result.ok || !result.ts) {
     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,
@@ -17311,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 ?? ""
         })
       }
     ]
@@ -17549,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>"
@@ -17631,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);
@@ -17714,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 {
@@ -17775,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");
@@ -17786,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({
@@ -17903,16 +18642,25 @@ async function connectSocketMode() {
         botUserId
       });
       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)
+        oldestPendingAgeMs: oldestPendingMarkerAgeMs(SLACK_PENDING_INBOUND_DIR),
+        paneLogFreshAgeMs
       });
       if (ackDecision !== "none") {
-        const reactionName = ackDecision === "undeliverable" ? "x" : "eyes";
+        const reactionName = ackDecision === "undeliverable" ? SLACK_UNDELIVERABLE_REACTION : "eyes";
         fetch("https://slack.com/api/reactions.add", {
           method: "POST",
           headers: {
@@ -17922,6 +18670,9 @@ async function connectSocketMode() {
           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, ackDecision === "undeliverable");
@@ -17964,6 +18715,13 @@ 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
@@ -18084,3 +18842,7 @@ if (THREAD_STORE_PATH) {
   );
 }
 connectSocketModeSafely();
+export {
+  __resetSlackGiveUpNoticeStateForTests,
+  __resetSlackUndeliverableNoticeThrottle
+};