@integrity-labs/agt-cli 0.27.7-test.6 → 0.27.8-test.10

package/dist/mcp/slack-channel.js

@@ -14237,17 +14237,184 @@ 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 };
+    }
+  }
   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") {
     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_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_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";
+}
+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;
+}
+
+// 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/slack-loop-throttle.ts
 var DEFAULT_THROTTLE = {
@@ -14351,466 +14518,62 @@ 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}*`);
-    }
-  }
-  if (state.stepLabel) parts.push(state.stepLabel);
-  return parts.length > 0 ? parts.join(": ") : void 0;
-}
-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}`;
-  return {
-    text: fallbackText,
-    blocks: [
-      {
-        type: "section",
-        text: { type: "mrkdwn", text: lines.join("\n") }
-      }
-    ]
-  };
-}
-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";
-  }
-};
-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);
-    }
-    const parsed = await response.json().catch(() => ({ ok: false, error: "invalid_json" }));
-    if (!parsed.ok) {
-      throw new SlackApiError(endpoint, parsed.error ?? "unknown", response.status);
-    }
-    return parsed;
-  }
-  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;
-      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;
-    }
+// 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 {
-      await slackCall("chat.update", {
-        channel: opts.channel,
-        ts: anchorTs,
-        text: payload.text,
-        blocks: payload.blocks
+      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) {
-      if (opts.onApiError && err instanceof SlackApiError) {
-        await opts.onApiError(err);
-        return;
-      }
-      throw err;
-    }
-  };
-}
-
-// src/progress-tools.ts
-import { randomUUID } from "crypto";
-
-// 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
-    };
-  }
-  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(() => {
+      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 ?? ""
       });
-    }, 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";
+    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) };
 }
 
 // src/impersonation.ts
@@ -14860,6 +14623,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 join2 } 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(join2(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(join2(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 = join2(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";
 
@@ -14956,22 +14782,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;
@@ -14982,7 +14808,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 };
   }
@@ -15097,9 +14923,9 @@ async function runOrRetry(fn, opts) {
 
 // src/channel-attachments.ts
 import { homedir } from "os";
-import { join, resolve, sep } from "path";
+import { join as join3, resolve, sep } from "path";
 function resolveChannelInboundDir(codeName, channelSlug) {
-  const base = join(homedir(), ".augmented");
+  const base = join3(homedir(), ".augmented");
   const allowedSegment = /^[A-Za-z0-9_-]+$/;
   if (!allowedSegment.test(codeName) || !allowedSegment.test(channelSlug)) {
     throw new Error(
@@ -15743,14 +15569,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 {
@@ -15768,7 +15594,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) {
@@ -15792,14 +15618,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;
@@ -15820,16 +15646,88 @@ 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 === "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";
@@ -15881,9 +15779,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>";
@@ -15895,16 +15793,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 });
@@ -15916,21 +15816,65 @@ 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}`
+  };
+  fetch("https://slack.com/api/reactions.remove", {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ channel, timestamp: messageTs, name: "x" })
+  }).catch(() => {
+  }).finally(() => {
+    fetch("https://slack.com/api/reactions.add", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ channel, timestamp: messageTs, name: "eyes" })
+    }).catch(() => {
+    });
+  });
+}
+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$/);
@@ -15946,10 +15890,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}
@@ -16015,7 +15959,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync2(fullPath);
+      unlinkSync3(fullPath);
     } catch {
     }
     return;
@@ -16023,7 +15967,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}
@@ -16053,7 +15997,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;
   }
@@ -16062,7 +16006,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;
     }
@@ -16083,7 +16027,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 {
@@ -16092,7 +16036,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);
       }
     });
@@ -16108,15 +16052,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() {
   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}
@@ -16129,17 +16073,17 @@ 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++;
@@ -16148,7 +16092,7 @@ function sweepSlackStaleMarkersOnBoot() {
     const { channel, thread_ts, message_ts, received_at } = marker;
     if (!channel || !thread_ts || !message_ts || !received_at) {
       try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
@@ -16157,7 +16101,7 @@ function sweepSlackStaleMarkersOnBoot() {
     const receivedAtMs = Date.parse(received_at);
     if (!Number.isFinite(receivedAtMs) || receivedAtMs > now || now - receivedAtMs > STALE_MARKER_MS) {
       try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
       } catch {
       }
       cleared++;
@@ -16171,8 +16115,83 @@ function sweepSlackStaleMarkersOnBoot() {
   }
 }
 sweepSlackStaleMarkersOnBoot();
+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;
@@ -16182,10 +16201,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;
   }
@@ -16196,13 +16215,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 {
@@ -16381,10 +16397,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",
@@ -16394,7 +16410,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(
@@ -16488,10 +16504,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",
@@ -16502,7 +16518,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(
@@ -16550,7 +16566,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;
@@ -16585,9 +16601,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
     });
@@ -16657,7 +16673,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" },
   {
@@ -16672,43 +16687,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 \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.)",
       `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",
@@ -16722,7 +16712,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"]
@@ -16730,7 +16731,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. \u274C (:x:) is reserved for the system to mark an inbound that arrived while the agent couldn't reply \u2014 never add \u274C yourself.",
       inputSchema: {
         type: "object",
         properties: {
@@ -16743,7 +16744,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: {
@@ -16959,10 +16960,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   if (isImpersonating() && !channelsEnabledOverride() && SLACK_EGRESS_TOOLS.has(name)) {
     return buildImpersonationRefusal(name);
   }
-  const progressResult = await progressRegistry.handle(name, args ?? {});
-  if (progressResult !== void 0) return progressResult;
   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",
@@ -17021,8 +17020,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", {
@@ -17117,46 +17123,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) {
@@ -17198,7 +17180,7 @@ ${formatted}` : "Thread is empty or not found."
     let bytes;
     let size;
     try {
-      const stat = statSync(resolvedPath);
+      const stat = statSync2(resolvedPath);
       if (!stat.isFile()) {
         return {
           content: [{ type: "text", text: `Upload refused: ${resolvedPath} is not a regular file.` }],
@@ -17206,7 +17188,7 @@ ${formatted}` : "Thread is empty or not found."
         };
       }
       size = stat.size;
-      bytes = readFileSync3(resolvedPath);
+      bytes = readFileSync4(resolvedPath);
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed to read file: ${err.message}` }],
@@ -17505,15 +17487,15 @@ async function handleSendStructured(args) {
   const { validateSlackBlocks: validateSlackBlocks2 } = runtime;
   const { channel, blocks, text, thread_ts, interactive } = 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("; ")}`);
+    return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   let effectiveBlocks = blocks;
   let ratingCallbackId = null;
@@ -17521,13 +17503,13 @@ async function handleSendStructured(args) {
   let ratingTokenised = [];
   if (interactive) {
     if (interactive.type !== "rate_run") {
-      return errResult2(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
+      return errResult(`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");
+      return errResult("interactive.run_id is required when interactive is set");
     }
     if (!interactiveHostAvailable()) {
-      return errResult2(
+      return errResult(
         "interactive=rate_run requires Block Kit plus host MCP wiring (AGT_HOST, AGT_API_KEY, AGT_AGENT_ID)."
       );
     }
@@ -17558,7 +17540,7 @@ async function handleSendStructured(args) {
     effectiveBlocks = [...blocks, ratingBlock];
     const finalValidation = runtime.validateSlackBlocks(effectiveBlocks);
     if (!finalValidation.ok) {
-      return errResult2(
+      return errResult(
         `Invalid blocks (after appending rating row): ${finalValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
       );
     }
@@ -17579,7 +17561,7 @@ async function handleSendStructured(args) {
         kindData: { run_id: interactive.run_id, scale }
       });
     } catch (err) {
-      return errResult2(`Failed to register rating row: ${err.message}`);
+      return errResult(`Failed to register rating row: ${err.message}`);
     }
   }
   const result = await postSlackMessageWithTs({
@@ -17589,7 +17571,7 @@ async function handleSendStructured(args) {
     ...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 {
@@ -17644,17 +17626,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));
@@ -17687,7 +17669,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,
@@ -17697,7 +17679,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);
@@ -17744,7 +17726,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."
     );
   }
@@ -17752,10 +17734,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,
@@ -17763,25 +17745,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));
@@ -17803,10 +17785,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}`
     );
   }
@@ -17844,7 +17826,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;
@@ -18038,6 +18020,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 {
@@ -18099,8 +18082,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");
@@ -18226,19 +18228,38 @@ 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" ? "x" : "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 (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);
@@ -18246,6 +18267,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: {
@@ -18255,12 +18299,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 } : {}
           }
         }
       });