sparkecoder 0.1.139 → 0.1.141

package/dist/server/index.js

@@ -1098,6 +1098,7 @@ function loadConfig(configPath, workingDirectory) {
   }
   if (process.env.SPARKECODER_PORT) {
     rawConfig.server = {
+      ...rawConfig.server ?? {},
       port: parseInt(process.env.SPARKECODER_PORT, 10),
       host: rawConfig.server?.host ?? "127.0.0.1"
     };
@@ -7652,6 +7653,105 @@ var init_cap_image_count = __esm({
   }
 });
 
+// src/utils/sanitize-images.ts
+function hasImageMagic(bytes) {
+  if (bytes.length < 12) return false;
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return true;
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return true;
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56) return true;
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return true;
+  return false;
+}
+function extractBase64(part) {
+  const raw = typeof part?.data === "string" ? part.data : typeof part?.image === "string" ? part.image : null;
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  if (/^https?:\/\//i.test(raw)) return null;
+  const dataUrl = raw.match(/^data:[^;,]+;base64,([\s\S]*)$/);
+  return dataUrl ? dataUrl[1] : raw;
+}
+function isInvalidImagePart(part) {
+  if (!part || typeof part !== "object") return false;
+  const t = part.type;
+  if (t !== "image" && t !== "image-data" && t !== "media") return false;
+  const mt = part.mediaType;
+  const b64 = extractBase64(part);
+  if (b64 === null) {
+    return typeof mt === "string" && mt.startsWith("image/") && !SUPPORTED_IMAGE_TYPES.includes(mt);
+  }
+  let bytes;
+  try {
+    bytes = Buffer.from(b64, "base64");
+  } catch {
+    return true;
+  }
+  if (bytes.length === 0) return true;
+  return !hasImageMagic(bytes);
+}
+function placeholder() {
+  return { type: "text", text: INVALID_IMAGE_PLACEHOLDER };
+}
+function sanitizeInvalidImages(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  let mutated = false;
+  let dropped = 0;
+  const out = messages.slice();
+  for (let i = 0; i < out.length; i++) {
+    const msg = out[i];
+    if (!Array.isArray(msg.content)) continue;
+    let contentCloned = false;
+    const ensureCloned = () => {
+      if (contentCloned) return;
+      out[i] = { ...msg, content: [...msg.content] };
+      contentCloned = true;
+    };
+    const content = () => out[i].content;
+    for (let j = 0; j < content().length; j++) {
+      const part = content()[j];
+      if (isInvalidImagePart(part)) {
+        ensureCloned();
+        out[i].content[j] = placeholder();
+        mutated = true;
+        dropped++;
+        continue;
+      }
+      if (part && typeof part === "object" && part.type === "tool-result" && part.output && part.output.type === "content" && Array.isArray(part.output.value)) {
+        const innerValue = part.output.value;
+        let innerMutated = false;
+        const newValue = innerValue.slice();
+        for (let k = 0; k < newValue.length; k++) {
+          if (isInvalidImagePart(newValue[k])) {
+            newValue[k] = placeholder();
+            innerMutated = true;
+            dropped++;
+          }
+        }
+        if (innerMutated) {
+          ensureCloned();
+          out[i].content[j] = {
+            ...part,
+            output: { ...part.output, value: newValue }
+          };
+          mutated = true;
+        }
+      }
+    }
+  }
+  if (mutated) {
+    console.warn(
+      `[sanitize-images] Replaced ${dropped} invalid image part(s) with a text placeholder (non-image bytes / unsupported type) to avoid provider 400 "invalid image" errors.`
+    );
+  }
+  return mutated ? out : messages;
+}
+var SUPPORTED_IMAGE_TYPES, INVALID_IMAGE_PLACEHOLDER;
+var init_sanitize_images = __esm({
+  "src/utils/sanitize-images.ts"() {
+    "use strict";
+    SUPPORTED_IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+    INVALID_IMAGE_PLACEHOLDER = "[invalid image omitted \u2014 the data was not a valid jpeg/png/gif/webp]";
+  }
+});
+
 // src/agent/model-limits.ts
 function getModelLimits(modelId) {
   const normalized = modelId.trim().toLowerCase();
@@ -7967,6 +8067,7 @@ var init_context = __esm({
     init_prompts();
     init_sanitize_messages();
     init_cap_image_count();
+    init_sanitize_images();
     init_model_limits();
     TOOL_OUTPUT_TRIM_CHARS = 400;
     COMPACTABLE_TOOLS = /* @__PURE__ */ new Set([
@@ -8016,6 +8117,7 @@ ${summaryContent}`
         messages = repairToolPairing(messages);
         messages = ensureToolResultsFollowCalls(messages);
         messages = ensureEndsWithUserOrTool(messages);
+        messages = sanitizeInvalidImages(messages);
         messages = capImageCount(messages);
         messages = this.enforceHardCap(messages);
         return messages;
@@ -8027,28 +8129,35 @@ ${summaryContent}`
        * repairs tool pairing so dropping can't orphan a tool result.
        */
       enforceHardCap(messages) {
-        const { contextWindow } = getModelLimits(this.modelId);
-        const ceiling = Math.max(2e4, Math.floor(contextWindow * 0.9));
+        const { rollingTarget } = getModelLimits(this.modelId);
+        const MAX_MESSAGES = 120;
+        const tokenCeiling = Math.max(2e4, Math.floor(rollingTarget * 1.5));
         const tokens = messages.map((m) => this.messageTokens(m));
         let total = tokens.reduce((a, b) => a + b, 0);
-        if (total <= ceiling) return messages;
         const hasLeadingSummary = messages.length > 0 && messages[0].role === "system";
         const firstBody = hasLeadingSummary ? 1 : 0;
         const lastIndex = messages.length - 1;
+        const bodyCount = messages.length - firstBody;
+        if (bodyCount <= MAX_MESSAGES && total <= tokenCeiling) return messages;
         let start = firstBody;
-        while (start < lastIndex && total > ceiling) {
+        const countDropTarget = messages.length - MAX_MESSAGES;
+        while (start < countDropTarget && start < lastIndex) {
+          total -= tokens[start];
+          start += 1;
+        }
+        while (start < lastIndex && total > tokenCeiling) {
           total -= tokens[start];
           start += 1;
         }
         let out = hasLeadingSummary ? [messages[0], ...messages.slice(start)] : messages.slice(start);
-        if (total > ceiling) {
+        if (total > tokenCeiling) {
           out = out.map((m) => hardTruncateMessageText(m));
         }
         out = repairToolPairing(out);
         out = ensureToolResultsFollowCalls(out);
         out = ensureEndsWithUserOrTool(out);
         console.warn(
-          `[Context] hard cap engaged for ${this.modelId}: trimmed ${messages.length}\u2192${out.length} msgs (ceiling ${ceiling} tokens).`
+          `[Context] hard cap engaged for ${this.modelId}: trimmed ${messages.length}\u2192${out.length} msgs (ceiling ${tokenCeiling} est-tokens / ${MAX_MESSAGES} msgs).`
         );
         return out;
       }
@@ -8472,7 +8581,7 @@ async function addLoadingReaction(channel, timestamp) {
   const adapter = getSlackAdapter();
   if (!adapter) return { ok: false, error: "slack_not_configured" };
   const key2 = reactionKey(channel, timestamp);
-  const inFlight = (async () => {
+  const inFlight2 = (async () => {
     try {
       const res = await adapter.addReaction({ channel, timestamp, name: LOADING_REACTION });
       if (!res.ok && !REACTION_SOFT_ERRORS.has(res.error || "")) {
@@ -8484,11 +8593,11 @@ async function addLoadingReaction(channel, timestamp) {
       return { ok: false, error: err?.message || "unknown" };
     }
   })();
-  pendingAdds.set(key2, inFlight);
-  void inFlight.finally(() => {
-    if (pendingAdds.get(key2) === inFlight) pendingAdds.delete(key2);
+  pendingAdds.set(key2, inFlight2);
+  void inFlight2.finally(() => {
+    if (pendingAdds.get(key2) === inFlight2) pendingAdds.delete(key2);
   });
-  return inFlight;
+  return inFlight2;
 }
 async function removeLoadingReaction(channel, timestamp) {
   const adapter = getSlackAdapter();
@@ -8736,17 +8845,28 @@ async function fetchBotParticipatedInThread(channel, threadTs) {
   const self = await ensureSlackSelfIdentity();
   if (!self) return false;
   try {
-    const url = `https://slack.com/api/conversations.replies?channel=${encodeURIComponent(channel)}&ts=${encodeURIComponent(threadTs)}&limit=200`;
-    const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
-    const data = await res.json().catch(() => ({}));
-    if (!data?.ok) {
-      console.warn(`[slack] conversations.replies(${channel}/${threadTs}) failed: ${data?.error || `HTTP ${res.status}`}`);
-      return false;
+    let cursor = "";
+    for (let page = 0; page < 10; page++) {
+      const params = new URLSearchParams({ channel, ts: threadTs, limit: "200" });
+      if (cursor) params.set("cursor", cursor);
+      const res = await fetch(`https://slack.com/api/conversations.replies?${params.toString()}`, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!data?.ok) {
+        console.warn(`[slack] conversations.replies(${channel}/${threadTs}) failed: ${data?.error || `HTTP ${res.status}`}`);
+        return false;
+      }
+      const messages = Array.isArray(data.messages) ? data.messages : [];
+      if (messages.some(
+        (m) => self.botId && m.bot_id === self.botId || self.botUserId && m.user === self.botUserId
+      )) {
+        return true;
+      }
+      cursor = String(data.response_metadata?.next_cursor || "");
+      if (!cursor) break;
     }
-    const messages = Array.isArray(data.messages) ? data.messages : [];
-    return messages.some(
-      (m) => self.botId && m.bot_id === self.botId || self.botUserId && m.user === self.botUserId
-    );
+    return false;
   } catch (err) {
     console.warn(`[slack] conversations.replies error:`, err?.message || err);
     return false;
@@ -9198,7 +9318,7 @@ async function reconcileOnce(now = Date.now()) {
     entry2.updatedAt = Date.now();
     const nudged = {
       ...entry2.event,
-      content: `[REPLAY attempt ${entry2.attempts}/${MAX_ATTEMPTS} \u2014 you received this but have not yet replied to it or marked it handled. Respond now on the originating channel; if it genuinely needs no reply, you can ignore it.]
+      content: `[REPLAY attempt ${entry2.attempts}/${MAX_ATTEMPTS} \u2014 you received this but have not yet replied to it or marked it handled. Respond now on the originating channel; if it genuinely needs no substantive reply, post a brief acknowledgement.]
 ${entry2.event.content}`,
       wake: "now"
     };
@@ -9606,22 +9726,444 @@ function getChannel(id) {
 function listChannels() {
   return Array.from(channels.values());
 }
-function listOutboundChannels() {
-  return listChannels().filter((c) => c.canSend());
+function listOutboundChannels() {
+  return listChannels().filter((c) => c.canSend());
+}
+var channels;
+var init_registry = __esm({
+  "src/integrations/channels/registry.ts"() {
+    "use strict";
+    init_web();
+    init_slack();
+    init_system();
+    init_schedule();
+    init_webhook();
+    channels = /* @__PURE__ */ new Map();
+    for (const c of [webChannel, slackChannel, systemChannel, scheduleChannel, webhookChannel]) {
+      channels.set(c.id, c);
+    }
+  }
+});
+
+// src/integrations/slack/files.ts
+var files_exports = {};
+__export(files_exports, {
+  INGEST_TIMEOUT_MS: () => INGEST_TIMEOUT_MS,
+  MAX_BYTES: () => MAX_BYTES,
+  formatFileBlock: () => formatFileBlock,
+  ingestSlackFiles: () => ingestSlackFiles
+});
+function inferFileName(file) {
+  return typeof file.name === "string" && file.name || typeof file.title === "string" && file.title || `slack-file-${file.id}`;
+}
+function inferContentType(file) {
+  if (typeof file.mimetype === "string" && file.mimetype) return file.mimetype;
+  return "application/octet-stream";
+}
+function formatBytes(n) {
+  if (!Number.isFinite(n) || n <= 0) return "?";
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+function sleep(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+function imageMagic(bytes) {
+  if (bytes.length < 12) return null;
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "image/png";
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56) return "image/gif";
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+  return null;
+}
+function requiresRasterMagic(contentType) {
+  const normalized = contentType.toLowerCase().split(";", 1)[0].trim();
+  return normalized === "image/jpeg" || normalized === "image/jpg" || normalized === "image/png" || normalized === "image/gif" || normalized === "image/webp";
+}
+function validateDownloadedBytes(bytes, declaredContentType) {
+  if (!requiresRasterMagic(declaredContentType)) return null;
+  const actual = imageMagic(bytes);
+  if (!actual) return "invalid_image_bytes";
+  return null;
+}
+async function fetchSlackPrivateFile(sourceUrl, botToken) {
+  let lastError = "unknown";
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetch(sourceUrl, {
+        headers: { Authorization: `Bearer ${botToken}` }
+      });
+      if (res.status === 429 || res.status >= 500) {
+        lastError = `slack_fetch_${res.status}`;
+        const retryAfter = Number(res.headers.get("retry-after"));
+        const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1e3, 2e3) : 250 * (attempt + 1);
+        if (attempt < 2) {
+          await sleep(waitMs);
+          continue;
+        }
+      }
+      if (!res.ok) {
+        return { ok: false, error: `slack_fetch_${res.status}` };
+      }
+      const contentLength = Number(res.headers.get("content-length"));
+      if (Number.isFinite(contentLength) && contentLength > MAX_BYTES) {
+        return { ok: false, error: "size_exceeded" };
+      }
+      const ab = await res.arrayBuffer();
+      if (ab.byteLength > MAX_BYTES) {
+        return { ok: false, error: "size_exceeded" };
+      }
+      return { ok: true, bytes: Buffer.from(ab) };
+    } catch (err) {
+      lastError = `slack_fetch_error:${err?.message || "unknown"}`;
+      if (attempt < 2) {
+        await sleep(250 * (attempt + 1));
+        continue;
+      }
+    }
+  }
+  return { ok: false, error: lastError };
+}
+function withTimeout(p, ms, label) {
+  return new Promise((resolve13, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label}_timeout`)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve13(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    );
+  });
+}
+async function ingestOne(file, sessionId, botToken) {
+  const fileName = inferFileName(file);
+  const contentType = inferContentType(file);
+  const declaredSize = typeof file.size === "number" ? file.size : 0;
+  const base = {
+    slackFileId: file.id,
+    fileName,
+    contentType,
+    sizeBytes: declaredSize
+  };
+  const sourceUrl = file.url_private_download || file.url_private;
+  if (!sourceUrl || typeof sourceUrl !== "string") {
+    return { ...base, shortUrl: null, error: "no_source_url" };
+  }
+  if (declaredSize > MAX_BYTES) {
+    return { ...base, shortUrl: null, error: "size_exceeded" };
+  }
+  let bytes;
+  const fetched = await fetchSlackPrivateFile(sourceUrl, botToken);
+  if (!fetched.ok) {
+    return { ...base, shortUrl: null, error: fetched.error };
+  }
+  bytes = fetched.bytes;
+  const byteError = validateDownloadedBytes(bytes, contentType);
+  if (byteError) {
+    console.warn(
+      `[slack-files] refusing to upload ${fileName}: Slack metadata says ${contentType}, but downloaded bytes are not a supported image (${bytes.slice(0, 32).toString("utf8").replace(/\s+/g, " ").slice(0, 32)})`
+    );
+    return { ...base, sizeBytes: bytes.length, shortUrl: null, error: byteError };
+  }
+  const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+  let upload;
+  try {
+    upload = await storageQueries2.getUploadUrl(sessionId, fileName, contentType, "slack");
+  } catch (err) {
+    return { ...base, sizeBytes: bytes.length, shortUrl: null, error: `presign_failed:${err?.message || "unknown"}` };
+  }
+  try {
+    const putRes = await fetch(upload.uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: bytes
+    });
+    if (!putRes.ok) {
+      return {
+        ...base,
+        sizeBytes: bytes.length,
+        shortUrl: null,
+        error: `gcs_put_${putRes.status}`
+      };
+    }
+  } catch (err) {
+    return {
+      ...base,
+      sizeBytes: bytes.length,
+      shortUrl: null,
+      error: `gcs_put_error:${err?.message || "unknown"}`
+    };
+  }
+  try {
+    await storageQueries2.updateFile(upload.fileId, { sizeBytes: bytes.length });
+  } catch (err) {
+    console.warn(`[slack-files] sizeBytes patch failed for ${upload.fileId}:`, err?.message || err);
+  }
+  const shortUrl = upload.shortUrl || // Defensive fallback: build it from the upload URL's origin if the
+  // server somehow forgot to return it (older remote-server versions).
+  inferShortUrlFromUploadUrl(upload.uploadUrl, upload.fileId);
+  return {
+    ...base,
+    sizeBytes: bytes.length,
+    shortUrl
+  };
+}
+function inferShortUrlFromUploadUrl(uploadUrl, fileId) {
+  try {
+    const u = new URL(uploadUrl);
+    if (u.hostname.endsWith(".googleapis.com")) return null;
+    return `${u.origin}/f/${fileId}`;
+  } catch {
+    return null;
+  }
+}
+async function ingestSlackFiles(files, sessionId, options = {}) {
+  if (!Array.isArray(files) || files.length === 0) return [];
+  const { isRemoteConfigured: isRemoteConfigured2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+  if (!isRemoteConfigured2()) {
+    console.warn(`[slack-files] storage not configured \u2014 skipping ingestion for ${files.length} file(s)`);
+    return files.map((f) => ({
+      slackFileId: f.id,
+      fileName: inferFileName(f),
+      contentType: inferContentType(f),
+      sizeBytes: typeof f.size === "number" ? f.size : 0,
+      shortUrl: null,
+      error: "storage_unconfigured"
+    }));
+  }
+  const botToken = getSlackBotToken();
+  if (!botToken) {
+    console.warn("[slack-files] no bot token \u2014 cannot download from Slack");
+    return files.map((f) => ({
+      slackFileId: f.id,
+      fileName: inferFileName(f),
+      contentType: inferContentType(f),
+      sizeBytes: typeof f.size === "number" ? f.size : 0,
+      shortUrl: null,
+      error: "no_bot_token"
+    }));
+  }
+  const timeoutMs = options.timeoutMs ?? INGEST_TIMEOUT_MS;
+  const startedAt = Date.now();
+  const pipeline = Promise.allSettled(
+    files.map(
+      (f) => withTimeout(ingestOne(f, sessionId, botToken), timeoutMs, `ingest:${f.id}`).catch((err) => {
+        if (String(err?.message || err).includes("_timeout")) {
+          return {
+            slackFileId: f.id,
+            fileName: inferFileName(f),
+            contentType: inferContentType(f),
+            sizeBytes: typeof f.size === "number" ? f.size : 0,
+            shortUrl: null,
+            error: "timeout"
+          };
+        }
+        throw err;
+      })
+    )
+  );
+  const settled = await pipeline;
+  const results = settled.map((s, i) => {
+    if (s.status === "fulfilled") return s.value;
+    const f = files[i];
+    return {
+      slackFileId: f.id,
+      fileName: inferFileName(f),
+      contentType: inferContentType(f),
+      sizeBytes: typeof f.size === "number" ? f.size : 0,
+      shortUrl: null,
+      error: `unexpected:${s.reason?.message || String(s.reason)}`
+    };
+  });
+  const okCount = results.filter((r) => r.shortUrl).length;
+  console.log(
+    `[slack-files] ingested ${okCount}/${files.length} file(s) in ${Date.now() - startedAt}ms`
+  );
+  return results;
+}
+function formatFileBlock(files) {
+  if (!files || files.length === 0) return "";
+  const lines = ["[files]"];
+  for (const f of files) {
+    const sizeLabel = formatBytes(f.sizeBytes);
+    if (f.shortUrl) {
+      lines.push(`  - ${f.fileName} (${f.contentType}, ${sizeLabel}): ${f.shortUrl}`);
+    } else {
+      lines.push(
+        `  - ${f.fileName} (${f.contentType}, ${sizeLabel}): [ingestion failed: ${f.error || "unknown"}]`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+var MAX_BYTES, INGEST_TIMEOUT_MS;
+var init_files = __esm({
+  "src/integrations/slack/files.ts"() {
+    "use strict";
+    init_client3();
+    MAX_BYTES = 100 * 1024 * 1024;
+    INGEST_TIMEOUT_MS = 2500;
+  }
+});
+
+// src/integrations/slack/read.ts
+var read_exports = {};
+__export(read_exports, {
+  findChannelByName: () => findChannelByName,
+  findUsers: () => findUsers,
+  getChannelHistory: () => getChannelHistory,
+  getPermalink: () => getPermalink,
+  getThreadReplies: () => getThreadReplies,
+  ingestMessageFiles: () => ingestMessageFiles
+});
+async function slackGet(method, params) {
+  const token = getSlackBotToken();
+  if (!token) return { ok: false, error: "slack_not_configured" };
+  try {
+    const qs = new URLSearchParams(params).toString();
+    const res = await fetch(`https://slack.com/api/${method}?${qs}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!json?.ok) return { ok: false, error: json?.error || `HTTP ${res.status}` };
+    return { ok: true, json };
+  } catch (err) {
+    return { ok: false, error: err?.message || "unknown" };
+  }
+}
+function clampLimit(n, def, max) {
+  const v = typeof n === "number" && Number.isFinite(n) ? n : def;
+  return String(Math.min(Math.max(Math.floor(v), 1), max));
+}
+function liteMessage(m) {
+  return {
+    ts: String(m?.ts ?? ""),
+    threadTs: typeof m?.thread_ts === "string" ? m.thread_ts : void 0,
+    user: typeof m?.user === "string" ? m.user : void 0,
+    botId: typeof m?.bot_id === "string" ? m.bot_id : void 0,
+    text: typeof m?.text === "string" ? m.text.slice(0, 4e3) : "",
+    files: Array.isArray(m?.files) ? m.files.map((f) => ({ id: String(f?.id ?? ""), name: f?.name || f?.title, mimetype: f?.mimetype, size: typeof f?.size === "number" ? f.size : void 0 })) : void 0,
+    replyCount: typeof m?.reply_count === "number" ? m.reply_count : void 0
+  };
+}
+async function enrichUserNames(messages) {
+  const ids = [...new Set(messages.map((m) => m.user).filter((u) => !!u))];
+  const names = /* @__PURE__ */ new Map();
+  await Promise.all(
+    ids.map(async (id) => {
+      const info = await resolveSlackUserInfo(id).catch(() => null);
+      if (info?.name) names.set(id, info.name);
+    })
+  );
+  return messages.map((m) => m.user && names.has(m.user) ? { ...m, userName: names.get(m.user) } : m);
+}
+async function getChannelHistory(channel, limit) {
+  const r = await slackGet("conversations.history", { channel, limit: clampLimit(limit, 20, 100) });
+  if (!r.ok) return { ok: false, error: r.error };
+  const messages = Array.isArray(r.json.messages) ? r.json.messages.map(liteMessage) : [];
+  return { ok: true, data: await enrichUserNames(messages) };
+}
+async function getThreadReplies(channel, threadTs, limit) {
+  const r = await slackGet("conversations.replies", { channel, ts: threadTs, limit: clampLimit(limit, 50, 200) });
+  if (!r.ok) return { ok: false, error: r.error };
+  const messages = Array.isArray(r.json.messages) ? r.json.messages.map(liteMessage) : [];
+  return { ok: true, data: await enrichUserNames(messages) };
+}
+async function getPermalink(channel, messageTs) {
+  const r = await slackGet("chat.getPermalink", { channel, message_ts: messageTs });
+  if (!r.ok) return { ok: false, error: r.error };
+  return { ok: true, data: { permalink: String(r.json.permalink ?? "") } };
+}
+async function findChannelByName(name) {
+  const clean = name.replace(/^#/, "").trim().toLowerCase();
+  let cursor;
+  for (let page = 0; page < 10; page++) {
+    const params = {
+      types: "public_channel,private_channel",
+      exclude_archived: "true",
+      limit: "999"
+    };
+    if (cursor) params.cursor = cursor;
+    const r = await slackGet("conversations.list", params);
+    if (!r.ok) return { ok: false, error: r.error };
+    const match = (r.json.channels || []).find((c) => String(c?.name ?? "").toLowerCase() === clean);
+    if (match) return { ok: true, data: { id: String(match.id), name: String(match.name) } };
+    cursor = r.json.response_metadata?.next_cursor || "";
+    if (!cursor) break;
+  }
+  return { ok: false, error: "channel_not_found" };
+}
+async function findUsers(query, max = 10) {
+  const q = query.trim().toLowerCase();
+  if (!q) return { ok: false, error: "empty_query" };
+  if (q.includes("@")) {
+    const r = await slackGet("users.lookupByEmail", { email: query.trim() });
+    if (r.ok && r.json.user) {
+      const u = r.json.user;
+      return { ok: true, data: [{ id: String(u.id), name: u.profile?.display_name || u.real_name || u.name, realName: u.real_name, email: u.profile?.email }] };
+    }
+    if (r.error && !["users_not_found", "user_not_found", "not_found"].includes(r.error)) {
+      return { ok: false, error: r.error };
+    }
+  }
+  const matches = [];
+  let cursor;
+  for (let page = 0; page < 10 && matches.length < max; page++) {
+    const params = { limit: "1000" };
+    if (cursor) params.cursor = cursor;
+    const r = await slackGet("users.list", params);
+    if (!r.ok) return { ok: false, error: r.error };
+    for (const u of r.json.members || []) {
+      if (u?.deleted || u?.is_bot) continue;
+      const dn = String(u?.profile?.display_name_normalized || u?.profile?.real_name || u?.name || "");
+      const email = String(u?.profile?.email || "");
+      if (dn.toLowerCase().includes(q) || email.toLowerCase().includes(q)) {
+        matches.push({ id: String(u.id), name: dn || String(u.name), realName: u?.profile?.real_name, email: email || void 0 });
+        if (matches.length >= max) break;
+      }
+    }
+    cursor = r.json.response_metadata?.next_cursor || "";
+    if (!cursor) break;
+  }
+  return matches.length > 0 ? { ok: true, data: matches } : { ok: false, error: "no_match" };
+}
+async function getSingleMessage(channel, ts, threadTs) {
+  if (threadTs) {
+    const rr2 = await slackGet("conversations.replies", { channel, ts: threadTs, limit: "200" });
+    if (rr2.ok && Array.isArray(rr2.json.messages)) {
+      const match = rr2.json.messages.find((m) => m?.ts === ts);
+      if (match) return match;
+    }
+  }
+  const r = await slackGet("conversations.history", { channel, latest: ts, oldest: ts, inclusive: "true", limit: "1" });
+  if (r.ok && Array.isArray(r.json.messages) && r.json.messages[0]) return r.json.messages[0];
+  const rr = await slackGet("conversations.replies", { channel, ts, limit: "1" });
+  if (rr.ok && Array.isArray(rr.json.messages)) {
+    return rr.json.messages.find((m) => m?.ts === ts) || rr.json.messages[0] || null;
+  }
+  return null;
+}
+async function ingestMessageFiles(channel, ts, orchestratorSessionId, threadTs) {
+  const msg = await getSingleMessage(channel, ts, threadTs);
+  if (!msg) return { ok: false, error: "message_not_found" };
+  const files = Array.isArray(msg.files) ? msg.files : [];
+  if (files.length === 0) return { ok: true, data: [] };
+  const { ingestSlackFiles: ingestSlackFiles2 } = await Promise.resolve().then(() => (init_files(), files_exports));
+  const ingested = await ingestSlackFiles2(files, orchestratorSessionId);
+  return {
+    ok: true,
+    data: ingested.map((f) => ({ name: f.fileName, url: f.shortUrl, error: f.error }))
+  };
 }
-var channels;
-var init_registry = __esm({
-  "src/integrations/channels/registry.ts"() {
+var init_read = __esm({
+  "src/integrations/slack/read.ts"() {
     "use strict";
-    init_web();
-    init_slack();
-    init_system();
-    init_schedule();
-    init_webhook();
-    channels = /* @__PURE__ */ new Map();
-    for (const c of [webChannel, slackChannel, systemChannel, scheduleChannel, webhookChannel]) {
-      channels.set(c.id, c);
-    }
+    init_client3();
   }
 });
 
@@ -9635,7 +10177,16 @@ async function postMessage(opts) {
   let ref;
   switch (opts.channel) {
     case "slack": {
-      const slackRef = { channel: "slack", slackChannel: opts.to, threadTs: opts.threadTs };
+      let slackChannel2 = opts.to.trim();
+      if (slackChannel2.startsWith("#")) {
+        const { findChannelByName: findChannelByName2 } = await Promise.resolve().then(() => (init_read(), read_exports));
+        const found = await findChannelByName2(slackChannel2);
+        if (!found.ok || !found.data?.id) {
+          return { ok: false, error: `slack channel lookup failed: ${found.error || "channel_not_found"}` };
+        }
+        slackChannel2 = found.data.id;
+      }
+      const slackRef = { channel: "slack", slackChannel: slackChannel2, threadTs: opts.threadTs };
       ref = slackRef;
       break;
     }
@@ -9942,6 +10493,46 @@ function buildMessengerTool() {
     }
   });
 }
+function buildSlackTool(opts) {
+  return tool13({
+    description: "Read from Slack like a human would. Actions: history (channel[, limit] \u2192 recent messages, newest first, with sender names + file metadata), replies (channel, threadTs[, limit] \u2192 full thread), permalink (channel, messageTs \u2192 shareable link), find_channel (query=name \u2192 channel id), find_user (query=name|email \u2192 matching members), user_info (user=U0123 \u2192 name/email), fetch_files (channel, messageTs[, threadTs] \u2192 re-uploads that message's attachments and returns fetchable URLs you can curl). Use this to scroll back, read context, and open files others posted before replying.",
+    inputSchema: slackInputSchema,
+    execute: async (input) => {
+      if (!isSlackConfigured()) return { ok: false, error: "slack not configured" };
+      switch (input.action) {
+        case "history": {
+          if (!input.channel) return { ok: false, error: "channel required" };
+          return getChannelHistory(input.channel, input.limit);
+        }
+        case "replies": {
+          if (!input.channel || !input.threadTs) return { ok: false, error: "channel and threadTs required" };
+          return getThreadReplies(input.channel, input.threadTs, input.limit);
+        }
+        case "permalink": {
+          if (!input.channel || !input.messageTs) return { ok: false, error: "channel and messageTs required" };
+          return getPermalink(input.channel, input.messageTs);
+        }
+        case "find_channel": {
+          if (!input.query) return { ok: false, error: "query (channel name) required" };
+          return findChannelByName(input.query);
+        }
+        case "find_user": {
+          if (!input.query) return { ok: false, error: "query (name or email) required" };
+          return findUsers(input.query);
+        }
+        case "user_info": {
+          if (!input.user) return { ok: false, error: "user required" };
+          const info = await resolveSlackUserInfo(input.user);
+          return info ? { ok: true, data: { id: input.user, ...info } } : { ok: false, error: "not_found" };
+        }
+        case "fetch_files": {
+          if (!input.channel || !input.messageTs) return { ok: false, error: "channel and messageTs required" };
+          return ingestMessageFiles(input.channel, input.messageTs, opts.orchestratorSessionId, input.threadTs);
+        }
+      }
+    }
+  });
+}
 function buildScheduleTool(opts) {
   return tool13({
     description: "Recurring prompts. Actions: create (required: name, cron, prompt), list, update (required: id; any of name/cron/prompt/enabled/replyChannel), delete (required: id), pause (required: id), resume (required: id). Cron is standard 5-field syntax.",
@@ -10023,15 +10614,18 @@ function createOrchestratorActionTools(opts) {
   return {
     agent: buildAgentTool(opts),
     messenger: buildMessengerTool(),
+    slack: buildSlackTool(opts),
     schedule: buildScheduleTool(opts),
     webhook: buildWebhookTool(opts)
   };
 }
-var AGENT_STATUS_ENUM, agentInputSchema, messengerInputSchema, scheduleInputSchema, webhookInputSchema;
+var AGENT_STATUS_ENUM, agentInputSchema, messengerInputSchema, slackInputSchema, scheduleInputSchema, webhookInputSchema;
 var init_orchestrator_actions = __esm({
   "src/tools/orchestrator-actions.ts"() {
     "use strict";
     init_messenger();
+    init_read();
+    init_client3();
     init_schedules_store();
     init_config();
     init_webhooks_store();
@@ -10089,6 +10683,15 @@ var init_orchestrator_actions = __esm({
       threadTs: z14.string().optional().describe("post + slack: reply in this thread."),
       subject: z14.string().optional().describe("post + email: subject (future).")
     });
+    slackInputSchema = z14.object({
+      action: z14.enum(["history", "replies", "permalink", "find_channel", "find_user", "user_info", "fetch_files"]),
+      channel: z14.string().optional().describe("channel id (C0123/G0123/D0123). Required for history/replies/permalink/fetch_files."),
+      threadTs: z14.string().optional().describe("replies/fetch_files: parent message ts of the thread."),
+      messageTs: z14.string().optional().describe("permalink/fetch_files: ts of the target message; for thread-reply files also pass threadTs."),
+      query: z14.string().optional().describe("find_channel: channel name (no #). find_user: name or email."),
+      user: z14.string().optional().describe("user_info: user id (U0123)."),
+      limit: z14.number().optional().describe("history/replies: max messages (history \u2264100, replies \u2264200).")
+    });
     scheduleInputSchema = z14.object({
       action: z14.enum(["create", "list", "update", "delete", "pause", "resume"]),
       // create / update
@@ -15726,226 +16329,69 @@ function verifySlackSignature(opts) {
 // src/server/routes/slack.ts
 init_client3();
 init_slack();
-
-// src/integrations/slack/files.ts
-init_client3();
-var MAX_BYTES = 100 * 1024 * 1024;
-var INGEST_TIMEOUT_MS = 2500;
-function inferFileName(file) {
-  return typeof file.name === "string" && file.name || typeof file.title === "string" && file.title || `slack-file-${file.id}`;
-}
-function inferContentType(file) {
-  if (typeof file.mimetype === "string" && file.mimetype) return file.mimetype;
-  return "application/octet-stream";
-}
-function formatBytes(n) {
-  if (!Number.isFinite(n) || n <= 0) return "?";
-  if (n < 1024) return `${n} B`;
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
-  return `${(n / 1024 / 1024).toFixed(2)} MB`;
-}
-function withTimeout(p, ms, label) {
-  return new Promise((resolve13, reject) => {
-    const t = setTimeout(() => reject(new Error(`${label}_timeout`)), ms);
-    p.then(
-      (v) => {
-        clearTimeout(t);
-        resolve13(v);
-      },
-      (e) => {
-        clearTimeout(t);
-        reject(e);
-      }
-    );
-  });
-}
-async function ingestOne(file, sessionId, botToken) {
-  const fileName = inferFileName(file);
-  const contentType = inferContentType(file);
-  const declaredSize = typeof file.size === "number" ? file.size : 0;
-  const base = {
-    slackFileId: file.id,
-    fileName,
-    contentType,
-    sizeBytes: declaredSize
-  };
-  const sourceUrl = file.url_private_download || file.url_private;
-  if (!sourceUrl || typeof sourceUrl !== "string") {
-    return { ...base, shortUrl: null, error: "no_source_url" };
-  }
-  if (declaredSize > MAX_BYTES) {
-    return { ...base, shortUrl: null, error: "size_exceeded" };
-  }
-  let bytes;
-  try {
-    const res = await fetch(sourceUrl, {
-      headers: { Authorization: `Bearer ${botToken}` }
-    });
-    if (!res.ok) {
-      return { ...base, shortUrl: null, error: `slack_fetch_${res.status}` };
-    }
-    const ab = await res.arrayBuffer();
-    if (ab.byteLength > MAX_BYTES) {
-      return { ...base, shortUrl: null, error: "size_exceeded" };
-    }
-    bytes = Buffer.from(ab);
-  } catch (err) {
-    return { ...base, shortUrl: null, error: `slack_fetch_error:${err?.message || "unknown"}` };
-  }
-  const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
-  let upload;
-  try {
-    upload = await storageQueries2.getUploadUrl(sessionId, fileName, contentType, "slack");
-  } catch (err) {
-    return { ...base, sizeBytes: bytes.length, shortUrl: null, error: `presign_failed:${err?.message || "unknown"}` };
-  }
-  try {
-    const putRes = await fetch(upload.uploadUrl, {
-      method: "PUT",
-      headers: { "Content-Type": contentType },
-      body: bytes
-    });
-    if (!putRes.ok) {
-      return {
-        ...base,
-        sizeBytes: bytes.length,
-        shortUrl: null,
-        error: `gcs_put_${putRes.status}`
-      };
-    }
-  } catch (err) {
-    return {
-      ...base,
-      sizeBytes: bytes.length,
-      shortUrl: null,
-      error: `gcs_put_error:${err?.message || "unknown"}`
-    };
-  }
-  try {
-    await storageQueries2.updateFile(upload.fileId, { sizeBytes: bytes.length });
-  } catch (err) {
-    console.warn(`[slack-files] sizeBytes patch failed for ${upload.fileId}:`, err?.message || err);
-  }
-  const shortUrl = upload.shortUrl || // Defensive fallback: build it from the upload URL's origin if the
-  // server somehow forgot to return it (older remote-server versions).
-  inferShortUrlFromUploadUrl(upload.uploadUrl, upload.fileId);
-  return {
-    ...base,
-    sizeBytes: bytes.length,
-    shortUrl
-  };
-}
-function inferShortUrlFromUploadUrl(uploadUrl, fileId) {
-  try {
-    const u = new URL(uploadUrl);
-    if (u.hostname.endsWith(".googleapis.com")) return null;
-    return `${u.origin}/f/${fileId}`;
-  } catch {
-    return null;
-  }
-}
-async function ingestSlackFiles(files, sessionId, options = {}) {
-  if (!Array.isArray(files) || files.length === 0) return [];
-  const { isRemoteConfigured: isRemoteConfigured2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
-  if (!isRemoteConfigured2()) {
-    console.warn(`[slack-files] storage not configured \u2014 skipping ingestion for ${files.length} file(s)`);
-    return files.map((f) => ({
-      slackFileId: f.id,
-      fileName: inferFileName(f),
-      contentType: inferContentType(f),
-      sizeBytes: typeof f.size === "number" ? f.size : 0,
-      shortUrl: null,
-      error: "storage_unconfigured"
-    }));
-  }
-  const botToken = getSlackBotToken();
-  if (!botToken) {
-    console.warn("[slack-files] no bot token \u2014 cannot download from Slack");
-    return files.map((f) => ({
-      slackFileId: f.id,
-      fileName: inferFileName(f),
-      contentType: inferContentType(f),
-      sizeBytes: typeof f.size === "number" ? f.size : 0,
-      shortUrl: null,
-      error: "no_bot_token"
-    }));
-  }
-  const timeoutMs = options.timeoutMs ?? INGEST_TIMEOUT_MS;
-  const startedAt = Date.now();
-  const pipeline = Promise.allSettled(
-    files.map((f) => ingestOne(f, sessionId, botToken))
-  );
-  let settled;
-  try {
-    settled = await withTimeout(pipeline, timeoutMs, "ingest");
-  } catch (err) {
-    console.warn(`[slack-files] pipeline timeout after ${Date.now() - startedAt}ms (${err?.message || "timeout"})`);
-    return files.map((f) => ({
-      slackFileId: f.id,
-      fileName: inferFileName(f),
-      contentType: inferContentType(f),
-      sizeBytes: typeof f.size === "number" ? f.size : 0,
-      shortUrl: null,
-      error: "timeout"
-    }));
-  }
-  const results = settled.map((s, i) => {
-    if (s.status === "fulfilled") return s.value;
-    const f = files[i];
-    return {
-      slackFileId: f.id,
-      fileName: inferFileName(f),
-      contentType: inferContentType(f),
-      sizeBytes: typeof f.size === "number" ? f.size : 0,
-      shortUrl: null,
-      error: `unexpected:${s.reason?.message || String(s.reason)}`
-    };
-  });
-  const okCount = results.filter((r) => r.shortUrl).length;
-  console.log(
-    `[slack-files] ingested ${okCount}/${files.length} file(s) in ${Date.now() - startedAt}ms`
-  );
-  return results;
-}
-function formatFileBlock(files) {
-  if (!files || files.length === 0) return "";
-  const lines = ["[files]"];
-  for (const f of files) {
-    const sizeLabel = formatBytes(f.sizeBytes);
-    if (f.shortUrl) {
-      lines.push(`  - ${f.fileName} (${f.contentType}, ${sizeLabel}): ${f.shortUrl}`);
-    } else {
-      lines.push(
-        `  - ${f.fileName} (${f.contentType}, ${sizeLabel}): [ingestion failed: ${f.error || "unknown"}]`
-      );
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/server/routes/slack.ts
+init_files();
 init_webhook_events();
 init_inbox();
 var recentlyHandled = /* @__PURE__ */ new Map();
+var recentlyDeniedReplies = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Set();
 var MAX_RECENT = 1e3;
+function deliveryKey(channel, ts) {
+  if (!channel || !ts) return null;
+  return `${channel}\u241F${ts}`;
+}
 function wasHandled(channel, ts) {
-  if (!channel || !ts) return false;
-  return recentlyHandled.has(`${channel}\u241F${ts}`);
+  const key2 = deliveryKey(channel, ts);
+  if (!key2) return false;
+  return recentlyHandled.has(key2) || inFlight.has(key2);
+}
+function markInFlight(channel, ts) {
+  const key2 = deliveryKey(channel, ts);
+  if (key2) inFlight.add(key2);
+}
+function clearInFlight(channel, ts) {
+  const key2 = deliveryKey(channel, ts);
+  if (key2) inFlight.delete(key2);
 }
 function markHandled(channel, ts) {
-  if (!channel || !ts) return;
-  const key2 = `${channel}\u241F${ts}`;
+  const key2 = deliveryKey(channel, ts);
+  if (!key2) return;
+  inFlight.delete(key2);
   recentlyHandled.set(key2, Date.now());
   if (recentlyHandled.size > MAX_RECENT) {
     const oldest = recentlyHandled.keys().next().value;
     if (oldest) recentlyHandled.delete(oldest);
   }
 }
+function wasDeniedReplySent(channel, ts) {
+  const key2 = deliveryKey(channel, ts);
+  if (!key2) return false;
+  return recentlyDeniedReplies.has(key2);
+}
+function markDeniedReplySent(channel, ts) {
+  const key2 = deliveryKey(channel, ts);
+  if (!key2) return;
+  recentlyDeniedReplies.set(key2, Date.now());
+  if (recentlyDeniedReplies.size > MAX_RECENT) {
+    const oldest = recentlyDeniedReplies.keys().next().value;
+    if (oldest) recentlyDeniedReplies.delete(oldest);
+  }
+}
 var slack = new Hono6();
 slack.post("/events", async (c) => {
-  const signingSecret = getSlackSigningSecret();
-  if (!signingSecret) return c.json({ error: "slack not configured" }, 503);
   const rawBody = await c.req.text();
+  const signingSecret = getSlackSigningSecret();
+  if (!signingSecret) {
+    let unsignedPayload;
+    try {
+      unsignedPayload = JSON.parse(rawBody);
+    } catch {
+    }
+    if (unsignedPayload?.type === "url_verification" && typeof unsignedPayload.challenge === "string") {
+      return c.json({ challenge: unsignedPayload.challenge });
+    }
+    return c.json({ error: "slack not configured" }, 503);
+  }
   const verification = verifySlackSignature({
     signingSecret,
     timestampHeader: c.req.header("x-slack-request-timestamp") || null,
@@ -15999,65 +16445,79 @@ slack.post("/events", async (c) => {
       if (ev.type === "message" && ev.channel_type === "im" && ev.channel && (ev.thread_ts || ev.ts)) {
         markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
       }
-      const orchestratorId = await findOrCreateOrchestratorId();
-      if (orchestratorId) {
-        inbound.content = await normalizeSlackMentions(inbound.content);
-        if (ev.user) {
-          const info = await resolveSlackUserInfo(ev.user);
-          if (info?.name) {
-            const emailSuffix = info.email ? ` (${info.email})` : "";
-            const enriched = `user=${info.name} <@${ev.user}>${emailSuffix}`;
-            inbound.content = inbound.content.replace(`user=${ev.user}`, () => enriched);
+      if (wasHandled(ev.channel, ev.ts)) {
+        updateEvent(auditId, { status: "dropped", dropReason: "duplicate_delivery" });
+        return c.json({ ok: true });
+      }
+      markInFlight(ev.channel, ev.ts);
+      let routed = false;
+      try {
+        const orchestratorId = await findOrCreateOrchestratorId();
+        if (orchestratorId) {
+          inbound.content = await normalizeSlackMentions(inbound.content);
+          if (ev.user) {
+            const info = await resolveSlackUserInfo(ev.user);
+            if (info?.name) {
+              const emailSuffix = info.email ? ` (${info.email})` : "";
+              const enriched = `user=${info.name} <@${ev.user}>${emailSuffix}`;
+              inbound.content = inbound.content.replace(`user=${ev.user}`, () => enriched);
+            }
           }
-        }
-        const slackFiles = Array.isArray(ev.files) ? ev.files : [];
-        markHandled(ev.channel, ev.ts);
-        if (ev.channel && ev.ts) {
-          void addLoadingReaction(String(ev.channel), String(ev.ts));
-        }
-        let ingestedCount = 0;
-        if (slackFiles.length > 0) {
-          try {
-            const ingested = await ingestSlackFiles(slackFiles, orchestratorId);
-            const block = formatFileBlock(ingested);
-            if (block) inbound.content = `${inbound.content}
+          const slackFiles = Array.isArray(ev.files) ? ev.files : [];
+          if (ev.channel && ev.ts) {
+            void addLoadingReaction(String(ev.channel), String(ev.ts));
+          }
+          let ingestedCount = 0;
+          if (slackFiles.length > 0) {
+            try {
+              const ingested = await ingestSlackFiles(slackFiles, orchestratorId);
+              const block = formatFileBlock(ingested);
+              if (block) inbound.content = `${inbound.content}
 ${block}`;
-            ingestedCount = ingested.filter((f) => f.shortUrl).length;
-          } catch (err) {
-            console.warn("[slack-files] ingestion threw:", err?.message || err);
-            inbound.content = `${inbound.content}
+              ingestedCount = ingested.filter((f) => f.shortUrl).length;
+            } catch (err) {
+              console.warn("[slack-files] ingestion threw:", err?.message || err);
+              inbound.content = `${inbound.content}
 [files] (ingestion failed: ${err?.message || "unknown"})`;
+            }
           }
+          pushToInbox(orchestratorId, inbound);
+          routed = true;
+          markHandled(ev.channel, ev.ts);
+          updateEvent(auditId, {
+            status: "routed",
+            sessionId: orchestratorId,
+            ...slackFiles.length > 0 ? {
+              // Preserve the original meta (ts, thread_ts, team,
+              // event_subtype) from recordEvent above — updateEvent does a
+              // shallow merge, so we have to re-include them.
+              meta: {
+                ts: ev.ts,
+                thread_ts: ev.thread_ts,
+                team: ev.team,
+                event_subtype: ev.subtype,
+                fileCount: slackFiles.length,
+                ingestedCount
+              }
+            } : {}
+          });
+        } else {
+          updateEvent(auditId, { status: "error", error: "no orchestrator session available" });
         }
-        pushToInbox(orchestratorId, inbound);
-        updateEvent(auditId, {
-          status: "routed",
-          sessionId: orchestratorId,
-          ...slackFiles.length > 0 ? {
-            // Preserve the original meta (ts, thread_ts, team,
-            // event_subtype) from recordEvent above — updateEvent does a
-            // shallow merge, so we have to re-include them.
-            meta: {
-              ts: ev.ts,
-              thread_ts: ev.thread_ts,
-              team: ev.team,
-              event_subtype: ev.subtype,
-              fileCount: slackFiles.length,
-              ingestedCount
-            }
-          } : {}
-        });
-      } else {
-        updateEvent(auditId, { status: "error", error: "no orchestrator session available" });
+      } finally {
+        if (!routed) clearInFlight(ev.channel, ev.ts);
       }
     } else if (dropReason) {
       updateEvent(auditId, { status: "dropped", dropReason });
       const userFacingDrops = ["user_not_allowed", "channel_not_allowed", "dm_blocked"];
       if (userFacingDrops.includes(dropReason)) {
         console.log(`[slack] dropped event from user=${payload.event.user} channel=${payload.event.channel}: ${dropReason}`);
-        void sendDeniedReply(payload.event).catch((err) => {
-          console.warn(`[slack] denied-reply failed:`, err?.message || err);
-        });
+        if (!wasDeniedReplySent(payload.event.channel, payload.event.ts)) {
+          markDeniedReplySent(payload.event.channel, payload.event.ts);
+          void sendDeniedReply(payload.event, dropReason).catch((err) => {
+            console.warn(`[slack] denied-reply failed:`, err?.message || err);
+          });
+        }
       }
     }
   }
@@ -16082,7 +16542,7 @@ async function findOrCreateOrchestratorId() {
     return null;
   }
 }
-async function sendDeniedReply(event) {
+async function sendDeniedReply(event, reason) {
   const policy = getSlackDeniedReplyPolicy();
   if (!policy.enabled) return;
   const adapter = getSlackAdapter();
@@ -16091,7 +16551,7 @@ async function sendDeniedReply(event) {
   const channel = String(event?.channel || "");
   if (!channel) return;
   const threadTs = event?.thread_ts || event?.ts;
-  const text = policy.template.replace(/\{user\}/g, `<@${user}>`).replace(/\{channel\}/g, `<#${channel}>`);
+  const text = policy.template.replace(/\{user\}/g, `<@${user}>`).replace(/\{channel\}/g, `<#${channel}>`).replace(/\{reason\}/g, reason);
   const result = await adapter.postMessage({ channel, text, threadTs });
   if (!result.ok) {
     console.warn(`[slack] denied-reply post failed: ${result.error}`);