sparkecoder 0.1.139 → 0.1.141

package/dist/agent/index.js

@@ -1798,6 +1798,17 @@ function hookExit() {
   process.once("SIGINT", flush2);
   process.once("SIGTERM", flush2);
 }
+function getCachedUserName(userId) {
+  load();
+  return userMap.get(userId);
+}
+function setCachedUserName(userId, entry2) {
+  load();
+  hookExit();
+  userMap.set(userId, entry2);
+  evictIfOversized(userMap, MAX_USERS);
+  scheduleSave();
+}
 function setCachedThreadOwnership(key2, entry2) {
   load();
   hookExit();
@@ -1805,7 +1816,7 @@ function setCachedThreadOwnership(key2, entry2) {
   evictIfOversized(threadMap, MAX_THREADS);
   scheduleSave();
 }
-var FILENAME, FILE_VERSION, SAVE_DEBOUNCE_MS, MAX_THREADS, loaded, userMap, threadMap, dirty, saveTimer, exitHooked;
+var FILENAME, FILE_VERSION, SAVE_DEBOUNCE_MS, MAX_USERS, MAX_THREADS, loaded, userMap, threadMap, dirty, saveTimer, exitHooked;
 var init_persistence = __esm({
   "src/integrations/slack/persistence.ts"() {
     "use strict";
@@ -1813,6 +1824,7 @@ var init_persistence = __esm({
     FILENAME = "slack-cache.json";
     FILE_VERSION = 1;
     SAVE_DEBOUNCE_MS = 500;
+    MAX_USERS = 5e3;
     MAX_THREADS = 5e3;
     loaded = false;
     userMap = /* @__PURE__ */ new Map();
@@ -1936,6 +1948,58 @@ function getSlackAdapter() {
 function isSlackConfigured() {
   return readSlackConfig() !== void 0;
 }
+function getSlackBotToken() {
+  return readSlackConfig()?.botToken ?? null;
+}
+async function fetchSlackUserInfo(userId) {
+  const token = getSlackBotToken();
+  if (!token) return null;
+  try {
+    const res = await fetch(`https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!data?.ok) {
+      console.warn(`[slack] users.info(${userId}) failed: ${data?.error || `HTTP ${res.status}`}`);
+      return null;
+    }
+    const profile = data.user?.profile || {};
+    const name = profile.display_name_normalized || profile.display_name || profile.real_name_normalized || profile.real_name || data.user?.real_name || data.user?.name || null;
+    const realName = profile.real_name_normalized || profile.real_name || data.user?.real_name || null;
+    const email = profile.email || null;
+    return {
+      name: name ? String(name) : null,
+      realName: realName ? String(realName) : null,
+      email: email ? String(email) : null
+    };
+  } catch (err) {
+    console.warn(`[slack] users.info(${userId}) error:`, err?.message || err);
+    return null;
+  }
+}
+async function resolveSlackUserInfo(userId) {
+  if (!userId) return null;
+  const now = Date.now();
+  const hit = getCachedUserName(userId);
+  if (hit && hit.expiresAt > now) {
+    return { name: hit.name, realName: hit.realName ?? null, email: hit.email ?? null };
+  }
+  const inflight = userInflight.get(userId);
+  if (inflight) return inflight;
+  const p = (async () => {
+    const info = await fetchSlackUserInfo(userId);
+    setCachedUserName(userId, {
+      name: info?.name ?? null,
+      realName: info?.realName ?? null,
+      email: info?.email ?? null,
+      expiresAt: now + (info?.name ? USER_TTL_MS : USER_FAIL_TTL_MS)
+    });
+    userInflight.delete(userId);
+    return info;
+  })();
+  userInflight.set(userId, p);
+  return p;
+}
 function threadCacheKey(channel, threadTs) {
   return `${channel}\u241F${threadTs}`;
 }
@@ -1946,7 +2010,7 @@ function noteBotPostedInThread(channel, threadTs) {
     expiresAt: Date.now() + THREAD_OWNED_TTL_MS
   });
 }
-var RESULT_REACTIONS, SLACK_FETCH_ATTEMPTS, SLACK_BACKOFF_BASE_MS, SLACK_BACKOFF_CAP_MS, REACTION_SOFT_ERRORS, USER_TTL_MS, USER_FAIL_TTL_MS, THREAD_OWNED_TTL_MS, THREAD_NEG_TTL_MS;
+var RESULT_REACTIONS, SLACK_FETCH_ATTEMPTS, SLACK_BACKOFF_BASE_MS, SLACK_BACKOFF_CAP_MS, REACTION_SOFT_ERRORS, USER_TTL_MS, USER_FAIL_TTL_MS, userInflight, THREAD_OWNED_TTL_MS, THREAD_NEG_TTL_MS;
 var init_client2 = __esm({
   "src/integrations/slack/client.ts"() {
     "use strict";
@@ -1971,6 +2035,7 @@ var init_client2 = __esm({
     ]);
     USER_TTL_MS = 60 * 60 * 1e3;
     USER_FAIL_TTL_MS = 5 * 60 * 1e3;
+    userInflight = /* @__PURE__ */ new Map();
     THREAD_OWNED_TTL_MS = 60 * 60 * 1e3;
     THREAD_NEG_TTL_MS = 5 * 60 * 1e3;
   }
@@ -2278,7 +2343,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"
     };
@@ -2392,6 +2457,428 @@ var init_inbox_acks = __esm({
   }
 });
 
+// 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((resolve11) => setTimeout(resolve11, 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((resolve11, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label}_timeout`)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve11(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_client2();
+    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 init_read = __esm({
+  "src/integrations/slack/read.ts"() {
+    "use strict";
+    init_client2();
+  }
+});
+
 // src/browser/stream-proxy.ts
 var stream_proxy_exports = {};
 __export(stream_proxy_exports, {
@@ -7734,6 +8221,99 @@ function capImageCount(messages, max = MAX_IMAGES_IN_CONTEXT) {
   return mutated ? out : messages;
 }
 
+// src/utils/sanitize-images.ts
+var SUPPORTED_IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var INVALID_IMAGE_PLACEHOLDER = "[invalid image omitted \u2014 the data was not a valid jpeg/png/gif/webp]";
+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;
+}
+
 // src/agent/model-limits.ts
 var MODEL_LIMITS = {
   "claude-opus-4-8": { contextWindow: 2e5, rollingTarget: 15e4 },
@@ -7813,6 +8393,7 @@ ${summaryContent}`
     messages = repairToolPairing(messages);
     messages = ensureToolResultsFollowCalls(messages);
     messages = ensureEndsWithUserOrTool(messages);
+    messages = sanitizeInvalidImages(messages);
     messages = capImageCount(messages);
     messages = this.enforceHardCap(messages);
     return messages;
@@ -7824,28 +8405,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;
   }
@@ -8427,7 +9015,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;
     }
@@ -8449,6 +9046,10 @@ function describeConfiguredChannels() {
   }));
 }
 
+// src/tools/orchestrator-actions.ts
+init_read();
+init_client2();
+
 // src/orchestrator/schedules-store.ts
 init_db();
 import { nanoid as nanoid5 } from "nanoid";
@@ -8757,6 +9358,55 @@ function buildMessengerTool() {
     }
   });
 }
+var 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).")
+});
+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);
+        }
+      }
+    }
+  });
+}
 var scheduleInputSchema = z14.object({
   action: z14.enum(["create", "list", "update", "delete", "pause", "resume"]),
   // create / update
@@ -8857,6 +9507,7 @@ function createOrchestratorActionTools(opts) {
   return {
     agent: buildAgentTool(opts),
     messenger: buildMessengerTool(),
+    slack: buildSlackTool(opts),
     schedule: buildScheduleTool(opts),
     webhook: buildWebhookTool(opts)
   };