agent-slack 0.6.1 → 0.8.0

package/dist/index.js

@@ -1819,6 +1819,41 @@ class SlackApiClient {
       this.web = new WebClient(auth.token);
     }
   }
+  async apiMultipart(method, params = {}) {
+    if (this.auth.auth_type === "standard") {
+      return this.api(method, params);
+    }
+    if (!this.workspaceUrl) {
+      throw new Error("Browser auth requires workspace URL.");
+    }
+    const auth = this.auth;
+    const url = `${this.workspaceUrl.replace(/\/$/, "")}/api/${method}`;
+    const fd = new FormData;
+    fd.append("token", auth.xoxc_token);
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined) {
+        fd.append(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Cookie: `d=${encodeURIComponent(auth.xoxd_cookie)}`,
+        Origin: "https://app.slack.com",
+        "User-Agent": getUserAgent()
+      },
+      body: fd
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(`Slack HTTP ${response.status} calling ${method}`);
+    }
+    if (!isRecord3(data) || data.ok !== true) {
+      const error = isRecord3(data) && typeof data.error === "string" ? data.error : null;
+      throw new Error(error || `Slack API error calling ${method}`);
+    }
+    return data;
+  }
   async api(method, params = {}) {
     if (this.auth.auth_type === "standard") {
       if (!this.web) {
@@ -3892,191 +3927,661 @@ function toThreadListMessage(m) {
   return rest;
 }
 
-// src/cli/message-read-actions.ts
-async function handleMessageGet(input) {
-  const target = parseMsgTarget(input.targetInput);
-  if (target.kind === "user") {
-    throw new Error("message get does not support user ID targets. Use a channel name, channel ID, or message URL.");
-  }
-  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
-  return input.ctx.withAutoRefresh({
-    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
-    work: async () => {
-      if (target.kind === "url") {
-        const { ref: ref2 } = target;
-        warnOnTruncatedSlackUrl(ref2);
-        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref2.workspace_url);
-        const includeReactions2 = Boolean(input.options.includeReactions);
-        const msg2 = await fetchMessage(client2, { ref: ref2, includeReactions: includeReactions2 });
-        const thread2 = await getThreadSummary(client2, { channelId: ref2.channel_id, msg: msg2 });
-        const downloadedPaths2 = await downloadMessageFiles({ auth: auth2, messages: [msg2] });
-        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
-        const message2 = toCompactMessage(msg2, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 });
-        return pruneEmpty({ message: message2, thread: thread2 });
-      }
-      const ts = input.options.ts?.trim();
-      if (!ts) {
-        throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
-      }
-      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
-        workspaceUrl,
-        channels: [target.channel]
-      });
-      const includeReactions = Boolean(input.options.includeReactions);
-      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
-      const channelId = await resolveChannelId(client, target.channel);
-      const ref = {
-        workspace_url: workspace_url ?? workspaceUrl ?? "",
-        channel_id: channelId,
-        message_ts: ts,
-        thread_ts_hint: input.options.threadTs?.trim() || undefined,
-        raw: input.targetInput
-      };
-      const msg = await fetchMessage(client, { ref, includeReactions });
-      const thread = await getThreadSummary(client, { channelId, msg });
-      const downloadedPaths = await downloadMessageFiles({ auth, messages: [msg] });
-      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
-      const message = toCompactMessage(msg, { maxBodyChars, includeReactions, downloadedPaths });
-      return pruneEmpty({ message, thread });
-    }
-  });
-}
-async function handleMessageList(input) {
-  const target = parseMsgTarget(input.targetInput);
-  if (target.kind === "user") {
-    throw new Error("message list does not support user ID targets. Use a channel name, channel ID, or message URL.");
-  }
-  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
-  return input.ctx.withAutoRefresh({
-    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
-    work: async () => {
-      const withReactions = parseReactionFilters(input.options.withReaction);
-      const withoutReactions = parseReactionFilters(input.options.withoutReaction);
-      const hasReactionFilters = withReactions.length > 0 || withoutReactions.length > 0;
-      if (target.kind === "url") {
-        if (hasReactionFilters) {
-          throw new Error("Reaction filters are only supported for channel history mode (not message URL thread mode)");
+// src/slack/user-cache.ts
+import { createHash } from "node:crypto";
+import { join as join13 } from "node:path";
+
+// src/slack/users.ts
+async function listUsers(client, options) {
+  const limit = Math.min(Math.max(options?.limit ?? 200, 1), 1000);
+  const includeBots = options?.includeBots ?? false;
+  let next_cursor;
+  const [out, dmMap] = await Promise.all([
+    (async () => {
+      const users = [];
+      let cursor = options?.cursor;
+      while (users.length < limit) {
+        const pageSize = Math.min(200, limit - users.length);
+        const resp = await client.api("users.list", { limit: pageSize, cursor });
+        const members = asArray(resp.members).filter(isRecord);
+        for (const m of members) {
+          const id = getString(m.id);
+          if (!id) {
+            continue;
+          }
+          if (!includeBots && m.is_bot) {
+            continue;
+          }
+          users.push(toCompactUser(m));
+          if (users.length >= limit) {
+            break;
+          }
         }
-        const { ref } = target;
-        warnOnTruncatedSlackUrl(ref);
-        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref.workspace_url);
-        const includeReactions2 = Boolean(input.options.includeReactions);
-        const msg = await fetchMessage(client2, { ref, includeReactions: includeReactions2 });
-        const rootTs2 = msg.thread_ts ?? msg.ts;
-        const threadMessages2 = await fetchThread(client2, {
-          channelId: ref.channel_id,
-          threadTs: rootTs2,
-          includeReactions: includeReactions2
-        });
-        const downloadedPaths2 = await downloadMessageFiles({ auth: auth2, messages: threadMessages2 });
-        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
-        return pruneEmpty({
-          messages: threadMessages2.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 })).map(toThreadListMessage)
-        });
-      }
-      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
-      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
-        workspaceUrl,
-        channels: [target.channel]
-      });
-      const channelId = await resolveChannelId(client, target.channel);
-      const threadTs = input.options.threadTs?.trim();
-      const ts = input.options.ts?.trim();
-      if (!threadTs && !ts) {
-        const includeReactions2 = Boolean(input.options.includeReactions);
-        const limit = parseLimit(input.options.limit);
-        const oldest = requireOldestWhenReactionFiltersUsed({
-          oldest: input.options.oldest,
-          withReactions,
-          withoutReactions
-        });
-        const channelMessages = await fetchChannelHistory(client, {
-          channelId,
-          limit,
-          latest: input.options.latest?.trim(),
-          oldest,
-          includeReactions: includeReactions2 || hasReactionFilters,
-          withReactions,
-          withoutReactions
-        });
-        const downloadedPaths2 = await downloadMessageFiles({ auth, messages: channelMessages });
-        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
-        return pruneEmpty({
-          channel_id: channelId,
-          messages: channelMessages.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 }))
-        });
-      }
-      if (hasReactionFilters) {
-        throw new Error("Reaction filters are only supported for channel history mode (without --thread-ts/--ts)");
+        const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
+        const next = meta ? getString(meta.next_cursor) : undefined;
+        if (!next) {
+          break;
+        }
+        cursor = next;
+        next_cursor = next;
       }
-      const rootTs = threadTs ?? await (async () => {
-        const ref = {
-          workspace_url: workspace_url ?? workspaceUrl ?? "",
-          channel_id: channelId,
-          message_ts: ts,
-          raw: input.targetInput
-        };
-        const includeReactions2 = Boolean(input.options.includeReactions);
-        const msg = await fetchMessage(client, { ref, includeReactions: includeReactions2 });
-        return msg.thread_ts ?? msg.ts;
-      })();
-      const includeReactions = Boolean(input.options.includeReactions);
-      const threadMessages = await fetchThread(client, {
-        channelId,
-        threadTs: rootTs,
-        includeReactions
-      });
-      const downloadedPaths = await downloadMessageFiles({ auth, messages: threadMessages });
-      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
-      return pruneEmpty({
-        messages: threadMessages.map((m) => toCompactMessage(m, { maxBodyChars, includeReactions, downloadedPaths })).map(toThreadListMessage)
-      });
+      return users;
+    })(),
+    fetchDmMap(client)
+  ]);
+  for (const u of out) {
+    const dmId = dmMap.get(u.id);
+    if (dmId) {
+      u.dm_id = dmId;
     }
-  });
-}
-
-// src/cli/message-actions.ts
-function parseLimit(raw) {
-  if (raw === undefined) {
-    return;
   }
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n < 1) {
-    throw new Error(`Invalid --limit value "${raw}": must be a positive integer`);
-  }
-  return n;
+  return { users: out, next_cursor };
 }
-function requireMessageTs(raw) {
-  const ts = raw?.trim();
-  if (!ts) {
-    throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+async function getUser(client, input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("User is empty");
   }
-  return ts;
-}
-function parseReactionFilters(raw) {
-  if (!Array.isArray(raw) || raw.length === 0) {
-    return [];
+  const userId = await resolveUserId(client, trimmed);
+  if (!userId) {
+    throw new Error(`Could not resolve user: ${input}`);
   }
-  const out = [];
-  for (const value of raw) {
-    const normalized = normalizeSlackReactionName(String(value));
-    if (!out.includes(normalized)) {
-      out.push(normalized);
-    }
+  const resp = await client.api("users.info", { user: userId });
+  const u = isRecord(resp.user) ? resp.user : null;
+  if (!u || !getString(u.id)) {
+    throw new Error("users.info returned no user");
   }
-  return out;
+  return toCompactUser(u);
 }
-function requireOldestWhenReactionFiltersUsed(input) {
-  const hasReactionFilters = input.withReactions.length > 0 || input.withoutReactions.length > 0;
-  const oldest = input.oldest?.trim();
-  if (!hasReactionFilters) {
-    return oldest;
+async function resolveUserId(client, input) {
+  const trimmed = input.trim();
+  if (/^U[A-Z0-9]{8,}$/.test(trimmed)) {
+    return trimmed;
   }
-  if (!oldest) {
-    throw new Error('Reaction filters require --oldest "<seconds>.<micros>" to bound scan size. Example: --oldest "1770165109.628379"');
+  const looksLikeEmail = /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(trimmed) && !trimmed.startsWith("@");
+  if (looksLikeEmail) {
+    try {
+      const byEmail = await client.api("users.lookupByEmail", { email: trimmed });
+      const user = isRecord(byEmail.user) ? byEmail.user : null;
+      const userId = user ? getString(user.id) : undefined;
+      if (userId) {
+        return userId;
+      }
+    } catch {}
   }
-  return oldest;
-}
+  const handle = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+  if (!handle) {
+    return null;
+  }
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("users.list", { limit: 200, cursor });
+    const members = asArray(resp.members).filter(isRecord);
+    const found = members.find((m) => {
+      if (getString(m.name) === handle) {
+        return true;
+      }
+      if (looksLikeEmail) {
+        const profile = isRecord(m.profile) ? m.profile : null;
+        const email = profile ? getString(profile.email) : undefined;
+        return Boolean(email) && email?.toLowerCase() === trimmed.toLowerCase();
+      }
+      return false;
+    });
+    if (found) {
+      const id = getString(found.id);
+      if (id) {
+        return id;
+      }
+    }
+    const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  return null;
+}
+async function fetchDmMap(client) {
+  const map = new Map;
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("conversations.list", {
+      types: "im",
+      limit: 200,
+      cursor
+    });
+    const channels = asArray(resp.channels).filter(isRecord);
+    for (const ch of channels) {
+      const id = getString(ch.id);
+      const user = getString(ch.user);
+      if (id && user) {
+        map.set(user, id);
+      }
+    }
+    const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  return map;
+}
+async function getDmChannelForUsers(client, inputs) {
+  if (!inputs || inputs.length === 0) {
+    throw new Error("At least one user is required");
+  }
+  if (inputs.length > 8) {
+    throw new Error("Slack supports a maximum of 8 users in a group DM");
+  }
+  const userIds = [];
+  for (const input of inputs) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const userId = await resolveUserId(client, trimmed);
+    if (!userId) {
+      throw new Error(`Could not resolve user: ${input}`);
+    }
+    userIds.push(userId);
+  }
+  if (userIds.length === 0) {
+    throw new Error("No valid users provided");
+  }
+  const resp = await client.api("conversations.open", { users: userIds.join(",") });
+  const channel = isRecord(resp.channel) ? resp.channel : null;
+  const channelId = channel ? getString(channel.id) : null;
+  if (!channelId) {
+    throw new Error("conversations.open returned no channel");
+  }
+  const channelType = channelId.startsWith("D") ? "dm" : "group_dm";
+  return {
+    user_ids: userIds,
+    dm_channel_id: channelId,
+    channel_type: channelType
+  };
+}
+function toCompactUser(u) {
+  const profile = isRecord(u.profile) ? u.profile : {};
+  return {
+    id: getString(u.id) ?? "",
+    name: getString(u.name) ?? undefined,
+    real_name: getString(u.real_name) ?? getString(profile.real_name) ?? undefined,
+    display_name: getString(profile.display_name) ?? undefined,
+    email: getString(profile.email) ?? undefined,
+    title: getString(profile.title) ?? undefined,
+    tz: getString(u.tz) ?? undefined,
+    is_bot: typeof u.is_bot === "boolean" ? u.is_bot : undefined,
+    deleted: typeof u.deleted === "boolean" ? u.deleted : undefined
+  };
+}
+
+// src/slack/user-cache.ts
+var CACHE_VERSION = 1;
+var USER_TTL_MS = 24 * 60 * 60 * 1000;
+var USER_ID_PATTERN = /^(U|W)[A-Z0-9]{8,}$/;
+var USER_MENTION_PATTERN = /<@((U|W)[A-Z0-9]{8,})(?:\|[^>]+)?>/g;
+async function resolveUsersById(input) {
+  const uniqueIds = dedupeUserIds(input.userIds);
+  if (uniqueIds.length === 0) {
+    return new Map;
+  }
+  const forceRefresh = input.forceRefresh ?? false;
+  const now = Date.now();
+  const workspaceKey = hashWorkspaceUrl(input.workspaceUrl);
+  const isUnknownWorkspace = workspaceKey === "unknown";
+  const cachePath = isUnknownWorkspace ? "" : join13(getAppDir(), `users-cache-${workspaceKey}.json`);
+  const diskCache = cachePath ? await loadCache(cachePath) : { version: CACHE_VERSION, entries: {} };
+  const out = new Map;
+  const missing = [];
+  for (const userId of uniqueIds) {
+    const cached = diskCache.entries[userId];
+    if (!forceRefresh && cached && now - cached.fetched_at < USER_TTL_MS) {
+      out.set(userId, cached.user);
+      continue;
+    }
+    missing.push(userId);
+  }
+  let cacheChanged = false;
+  if (missing.length > 0) {
+    const fetched = [];
+    const concurrency = 5;
+    for (let i = 0;i < missing.length; i += concurrency) {
+      const chunk = missing.slice(i, i + concurrency);
+      const results = await Promise.all(chunk.map(async (userId) => ({ userId, user: await fetchUserById(input.client, userId) })));
+      fetched.push(...results);
+    }
+    for (const item of fetched) {
+      if (!item.user) {
+        continue;
+      }
+      const entry = {
+        fetched_at: now,
+        user: item.user
+      };
+      diskCache.entries[item.userId] = entry;
+      out.set(item.userId, item.user);
+      cacheChanged = true;
+    }
+  }
+  if (cachePath) {
+    const prunedCache = pruneExpiredEntries(diskCache, now);
+    if (Object.keys(diskCache.entries).length !== Object.keys(prunedCache.entries).length) {
+      cacheChanged = true;
+    }
+    if (cacheChanged) {
+      await writeCache(cachePath, prunedCache);
+    }
+  }
+  return out;
+}
+function collectReferencedUserIds(messages, options) {
+  const ids = new Set;
+  const includeReactions = options?.includeReactions ?? false;
+  for (const message of messages) {
+    collectUserIdsFromMessage(message, ids, { includeReactions });
+  }
+  return Array.from(ids);
+}
+function toReferencedUsers(userIds, usersById) {
+  const out = {};
+  for (const userId of dedupeUserIds(userIds)) {
+    const user = usersById.get(userId);
+    if (!user) {
+      continue;
+    }
+    out[userId] = user;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function dedupeUserIds(ids) {
+  const seen = new Set;
+  for (const raw of ids) {
+    const userId = String(raw).trim();
+    if (!USER_ID_PATTERN.test(userId)) {
+      continue;
+    }
+    seen.add(userId);
+  }
+  return Array.from(seen);
+}
+function hashWorkspaceUrl(workspaceUrl) {
+  const trimmed = workspaceUrl.trim();
+  if (!trimmed) {
+    return "unknown";
+  }
+  let source = trimmed;
+  try {
+    source = new URL(trimmed).hostname.toLowerCase();
+  } catch {
+    source = trimmed.toLowerCase();
+  }
+  if (!source || source === "unknown") {
+    return "unknown";
+  }
+  return createHash("sha256").update(source).digest("hex").slice(0, 16);
+}
+async function loadCache(path) {
+  const file = await readJsonFile(path);
+  if (!file || file.version !== CACHE_VERSION || !isRecord(file.entries)) {
+    return { version: CACHE_VERSION, entries: {} };
+  }
+  const entries = {};
+  for (const [userId, rawEntry] of Object.entries(file.entries)) {
+    if (!USER_ID_PATTERN.test(userId) || !isRecord(rawEntry)) {
+      continue;
+    }
+    const fetchedAt = typeof rawEntry.fetched_at === "number" ? rawEntry.fetched_at : undefined;
+    const user = isRecord(rawEntry.user) ? toCompactUser(rawEntry.user) : null;
+    if (!fetchedAt || !user) {
+      continue;
+    }
+    entries[userId] = { fetched_at: fetchedAt, user };
+  }
+  return {
+    version: CACHE_VERSION,
+    entries
+  };
+}
+async function writeCache(path, file) {
+  try {
+    await writeJsonFile(path, file);
+  } catch {}
+}
+function pruneExpiredEntries(file, now) {
+  const next = {};
+  for (const [userId, entry] of Object.entries(file.entries)) {
+    if (now - entry.fetched_at >= USER_TTL_MS) {
+      continue;
+    }
+    next[userId] = entry;
+  }
+  return { version: CACHE_VERSION, entries: next };
+}
+async function fetchUserById(client, userId) {
+  try {
+    const resp = await client.api("users.info", { user: userId });
+    const user = isRecord(resp.user) ? resp.user : null;
+    if (!user) {
+      return;
+    }
+    return toCompactUser(user);
+  } catch {
+    return;
+  }
+}
+function collectUserIdsFromUnknown(value, out) {
+  if (typeof value === "string") {
+    collectMentionUserIds(value, out);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectUserIdsFromUnknown(item, out);
+    }
+    return;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if ((key === "user" || key === "user_id") && typeof child === "string") {
+      if (USER_ID_PATTERN.test(child)) {
+        out.add(child);
+      }
+      continue;
+    }
+    if (key === "users") {
+      for (const maybeUserId of asArray(child)) {
+        const userId = String(maybeUserId);
+        if (USER_ID_PATTERN.test(userId)) {
+          out.add(userId);
+        }
+      }
+      continue;
+    }
+    collectUserIdsFromUnknown(child, out);
+  }
+}
+function collectUserIdsFromMessage(message, out, options) {
+  if (message.user && USER_ID_PATTERN.test(message.user)) {
+    out.add(message.user);
+  }
+  if (typeof message.text === "string") {
+    collectMentionUserIds(message.text, out);
+  }
+  collectUserIdsFromUnknown(message.blocks, out);
+  collectUserIdsFromUnknown(message.attachments, out);
+  if (options.includeReactions) {
+    collectUserIdsFromUnknown(message.reactions, out);
+  }
+}
+function collectMentionUserIds(text, out) {
+  USER_MENTION_PATTERN.lastIndex = 0;
+  for (;; ) {
+    const match = USER_MENTION_PATTERN.exec(text);
+    if (!match) {
+      break;
+    }
+    const userId = match[1] ?? "";
+    if (USER_ID_PATTERN.test(userId)) {
+      out.add(userId);
+    }
+  }
+}
+
+// src/cli/message-read-actions.ts
+async function handleMessageGet(input) {
+  const target = parseMsgTarget(input.targetInput);
+  if (target.kind === "user") {
+    throw new Error("message get does not support user ID targets. Use a channel name, channel ID, or message URL.");
+  }
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  return input.ctx.withAutoRefresh({
+    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
+    work: async () => {
+      if (target.kind === "url") {
+        const { ref: ref2 } = target;
+        warnOnTruncatedSlackUrl(ref2);
+        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref2.workspace_url);
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg2 = await fetchMessage(client2, { ref: ref2, includeReactions: includeReactions2 });
+        const thread2 = await getThreadSummary(client2, { channelId: ref2.channel_id, msg: msg2 });
+        const downloadedPaths2 = await downloadMessageFiles({ auth: auth2, messages: [msg2] });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        const referencedUserIds2 = collectReferencedUserIds([msg2], {
+          includeReactions: includeReactions2
+        });
+        const usersById2 = input.options.resolveUsers || input.options.refreshUsers ? await resolveUsersById({
+          client: client2,
+          workspaceUrl: ref2.workspace_url,
+          userIds: referencedUserIds2,
+          forceRefresh: Boolean(input.options.refreshUsers)
+        }) : new Map;
+        const message2 = toCompactMessage(msg2, {
+          maxBodyChars: maxBodyChars2,
+          includeReactions: includeReactions2,
+          downloadedPaths: downloadedPaths2
+        });
+        return pruneEmpty({
+          message: message2,
+          thread: thread2,
+          referenced_users: toReferencedUsers(referencedUserIds2, usersById2)
+        });
+      }
+      const ts = input.options.ts?.trim();
+      if (!ts) {
+        throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+      }
+      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+        workspaceUrl,
+        channels: [target.channel]
+      });
+      const includeReactions = Boolean(input.options.includeReactions);
+      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const channelId = await resolveChannelId(client, target.channel);
+      const ref = {
+        workspace_url: workspace_url ?? workspaceUrl ?? "",
+        channel_id: channelId,
+        message_ts: ts,
+        thread_ts_hint: input.options.threadTs?.trim() || undefined,
+        raw: input.targetInput
+      };
+      const msg = await fetchMessage(client, { ref, includeReactions });
+      const thread = await getThreadSummary(client, { channelId, msg });
+      const downloadedPaths = await downloadMessageFiles({ auth, messages: [msg] });
+      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
+      const referencedUserIds = collectReferencedUserIds([msg], {
+        includeReactions
+      });
+      const usersById = input.options.resolveUsers || input.options.refreshUsers ? await resolveUsersById({
+        client,
+        workspaceUrl: ref.workspace_url,
+        userIds: referencedUserIds,
+        forceRefresh: Boolean(input.options.refreshUsers)
+      }) : new Map;
+      const message = toCompactMessage(msg, {
+        maxBodyChars,
+        includeReactions,
+        downloadedPaths
+      });
+      return pruneEmpty({
+        message,
+        thread,
+        referenced_users: toReferencedUsers(referencedUserIds, usersById)
+      });
+    }
+  });
+}
+async function handleMessageList(input) {
+  const target = parseMsgTarget(input.targetInput);
+  if (target.kind === "user") {
+    throw new Error("message list does not support user ID targets. Use a channel name, channel ID, or message URL.");
+  }
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  return input.ctx.withAutoRefresh({
+    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
+    work: async () => {
+      const withReactions = parseReactionFilters(input.options.withReaction);
+      const withoutReactions = parseReactionFilters(input.options.withoutReaction);
+      const hasReactionFilters = withReactions.length > 0 || withoutReactions.length > 0;
+      if (target.kind === "url") {
+        if (hasReactionFilters) {
+          throw new Error("Reaction filters are only supported for channel history mode (not message URL thread mode)");
+        }
+        const { ref } = target;
+        warnOnTruncatedSlackUrl(ref);
+        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref.workspace_url);
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg = await fetchMessage(client2, { ref, includeReactions: includeReactions2 });
+        const rootTs2 = msg.thread_ts ?? msg.ts;
+        const threadMessages2 = await fetchThread(client2, {
+          channelId: ref.channel_id,
+          threadTs: rootTs2,
+          includeReactions: includeReactions2
+        });
+        const downloadedPaths2 = await downloadMessageFiles({ auth: auth2, messages: threadMessages2 });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        const referencedUserIds2 = collectReferencedUserIds(threadMessages2, {
+          includeReactions: includeReactions2
+        });
+        const usersById2 = input.options.resolveUsers || input.options.refreshUsers ? await resolveUsersById({
+          client: client2,
+          workspaceUrl: ref.workspace_url,
+          userIds: referencedUserIds2,
+          forceRefresh: Boolean(input.options.refreshUsers)
+        }) : new Map;
+        return pruneEmpty({
+          messages: threadMessages2.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 })).map(toThreadListMessage),
+          referenced_users: toReferencedUsers(referencedUserIds2, usersById2)
+        });
+      }
+      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+        workspaceUrl,
+        channels: [target.channel]
+      });
+      const channelId = await resolveChannelId(client, target.channel);
+      const threadTs = input.options.threadTs?.trim();
+      const ts = input.options.ts?.trim();
+      if (!threadTs && !ts) {
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const limit = parseLimit(input.options.limit);
+        const oldest = requireOldestWhenReactionFiltersUsed({
+          oldest: input.options.oldest,
+          withReactions,
+          withoutReactions
+        });
+        const channelMessages = await fetchChannelHistory(client, {
+          channelId,
+          limit,
+          latest: input.options.latest?.trim(),
+          oldest,
+          includeReactions: includeReactions2 || hasReactionFilters,
+          withReactions,
+          withoutReactions
+        });
+        const downloadedPaths2 = await downloadMessageFiles({ auth, messages: channelMessages });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        const referencedUserIds2 = collectReferencedUserIds(channelMessages, {
+          includeReactions: includeReactions2
+        });
+        const usersById2 = input.options.resolveUsers || input.options.refreshUsers ? await resolveUsersById({
+          client,
+          workspaceUrl: workspace_url ?? workspaceUrl ?? "",
+          userIds: referencedUserIds2,
+          forceRefresh: Boolean(input.options.refreshUsers)
+        }) : new Map;
+        return pruneEmpty({
+          channel_id: channelId,
+          messages: channelMessages.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 })),
+          referenced_users: toReferencedUsers(referencedUserIds2, usersById2)
+        });
+      }
+      if (hasReactionFilters) {
+        throw new Error("Reaction filters are only supported for channel history mode (without --thread-ts/--ts)");
+      }
+      const rootTs = threadTs ?? await (async () => {
+        const ref = {
+          workspace_url: workspace_url ?? workspaceUrl ?? "",
+          channel_id: channelId,
+          message_ts: ts,
+          raw: input.targetInput
+        };
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg = await fetchMessage(client, { ref, includeReactions: includeReactions2 });
+        return msg.thread_ts ?? msg.ts;
+      })();
+      const includeReactions = Boolean(input.options.includeReactions);
+      const threadMessages = await fetchThread(client, {
+        channelId,
+        threadTs: rootTs,
+        includeReactions
+      });
+      const downloadedPaths = await downloadMessageFiles({ auth, messages: threadMessages });
+      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
+      const referencedUserIds = collectReferencedUserIds(threadMessages, {
+        includeReactions
+      });
+      const usersById = input.options.resolveUsers || input.options.refreshUsers ? await resolveUsersById({
+        client,
+        workspaceUrl: workspace_url ?? workspaceUrl ?? "",
+        userIds: referencedUserIds,
+        forceRefresh: Boolean(input.options.refreshUsers)
+      }) : new Map;
+      return pruneEmpty({
+        messages: threadMessages.map((m) => toCompactMessage(m, { maxBodyChars, includeReactions, downloadedPaths })).map(toThreadListMessage),
+        referenced_users: toReferencedUsers(referencedUserIds, usersById)
+      });
+    }
+  });
+}
+
+// src/cli/message-actions.ts
+function parseLimit(raw) {
+  if (raw === undefined) {
+    return;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new Error(`Invalid --limit value "${raw}": must be a positive integer`);
+  }
+  return n;
+}
+function requireMessageTs(raw) {
+  const ts = raw?.trim();
+  if (!ts) {
+    throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+  }
+  return ts;
+}
+function parseReactionFilters(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return [];
+  }
+  const out = [];
+  for (const value of raw) {
+    const normalized = normalizeSlackReactionName(String(value));
+    if (!out.includes(normalized)) {
+      out.push(normalized);
+    }
+  }
+  return out;
+}
+function requireOldestWhenReactionFiltersUsed(input) {
+  const hasReactionFilters = input.withReactions.length > 0 || input.withoutReactions.length > 0;
+  const oldest = input.oldest?.trim();
+  if (!hasReactionFilters) {
+    return oldest;
+  }
+  if (!oldest) {
+    throw new Error('Reaction filters require --oldest "<seconds>.<micros>" to bound scan size. Example: --oldest "1770165109.628379"');
+  }
+  return oldest;
+}
 async function sendMessage(input) {
   const target = parseMsgTarget(String(input.targetInput));
   const blocks = input.text ? textToRichTextBlocks(input.text) : null;
@@ -6322,7 +6827,7 @@ function collectOptionValue(value, previous = []) {
 }
 function registerMessageCommand(input) {
   const messageCmd = input.program.command("message").description("Read/write Slack messages (token-efficient JSON)");
-  messageCmd.command("get", { isDefault: true }).description("Fetch a single Slack message (with thread summary if any)").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when using #channel/channel id across multiple workspaces)").option("--ts <ts>", "Message ts (required when using #channel/channel id)").option("--thread-ts <ts>", "Thread root ts hint (useful for thread permalinks)").option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").action(async (...args) => {
+  messageCmd.command("get", { isDefault: true }).description("Fetch a single Slack message (with thread summary if any)").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when using #channel/channel id across multiple workspaces)").option("--ts <ts>", "Message ts (required when using #channel/channel id)").option("--thread-ts <ts>", "Thread root ts hint (useful for thread permalinks)").option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").option("--resolve-users", "Resolve user IDs to user profiles").option("--refresh-users", "Refresh user profile cache before resolving user IDs (implies --resolve-users)").action(async (...args) => {
     const [targetInput, options] = args;
     try {
       const payload = await handleMessageGet({ ctx: input.ctx, targetInput, options });
@@ -6332,7 +6837,7 @@ function registerMessageCommand(input) {
       process.exitCode = 1;
     }
   });
-  messageCmd.command("list").description("List recent channel messages, or fetch a full thread").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when using #channel/channel id across multiple workspaces)").option("--thread-ts <ts>", "Thread root ts (lists thread replies instead of channel history)").option("--ts <ts>", "Message ts (resolve message to its thread)").option("--limit <n>", "Max messages to return for channel history (default 25, max 200)").option("--oldest <ts>", "Only messages after this ts (channel history mode)").option("--latest <ts>", "Only messages before this ts (channel history mode)").option("--with-reaction <emoji>", "Only include messages with this reaction (repeatable; channel history mode; requires --oldest)", collectOptionValue, []).option("--without-reaction <emoji>", "Only include messages without this reaction (repeatable; channel history mode; requires --oldest)", collectOptionValue, []).option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").action(async (...args) => {
+  messageCmd.command("list").description("List recent channel messages, or fetch a full thread").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when using #channel/channel id across multiple workspaces)").option("--thread-ts <ts>", "Thread root ts (lists thread replies instead of channel history)").option("--ts <ts>", "Message ts (resolve message to its thread)").option("--limit <n>", "Max messages to return for channel history (default 25, max 200)").option("--oldest <ts>", "Only messages after this ts (channel history mode)").option("--latest <ts>", "Only messages before this ts (channel history mode)").option("--with-reaction <emoji>", "Only include messages with this reaction (repeatable; channel history mode; requires --oldest)", collectOptionValue, []).option("--without-reaction <emoji>", "Only include messages without this reaction (repeatable; channel history mode; requires --oldest)", collectOptionValue, []).option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").option("--resolve-users", "Resolve user IDs to user profiles").option("--refresh-users", "Refresh user profile cache before resolving user IDs (implies --resolve-users)").action(async (...args) => {
     const [targetInput, options] = args;
     try {
       const payload = await handleMessageList({ ctx: input.ctx, targetInput, options });
@@ -6524,7 +7029,7 @@ async function channelTokenForSearch(client, channel) {
   } catch {}
   return null;
 }
-async function resolveUserId(client, input) {
+async function resolveUserId2(client, input) {
   const trimmed = input.trim();
   if (!trimmed) {
     return;
@@ -6712,7 +7217,7 @@ async function searchFilesViaSearchApi(client, input) {
 }
 async function searchFilesInChannelsFallback(client, input) {
   const channelIds = await Promise.all(input.channels.map((c) => resolveChannelId(client, c)));
-  const userId = input.user ? await resolveUserId(client, input.user) : undefined;
+  const userId = input.user ? await resolveUserId2(client, input.user) : undefined;
   const queryLower = input.query.trim().toLowerCase();
   const ts_from = input.after ? dateToUnixSeconds(input.after, "start") : undefined;
   const ts_to = input.before ? dateToUnixSeconds(input.before, "end") : undefined;
@@ -6810,7 +7315,7 @@ function passesFileContentTypeFilter(f, contentType) {
 async function searchMessagesViaSearchApi(client, input) {
   const matches = input.rawMatches;
   if (matches.length === 0) {
-    return [];
+    return { messages: [] };
   }
   const messageRefs = [];
   for (const m of matches) {
@@ -6834,6 +7339,7 @@ async function searchMessagesViaSearchApi(client, input) {
   }
   const downloadedPaths = {};
   const downloadsDir = input.download ? await ensureDownloadsDir() : null;
+  const resolvedMessages = [];
   const out = [];
   for (const ref of messageRefs) {
     let full = null;
@@ -6872,21 +7378,36 @@ async function searchMessagesViaSearchApi(client, input) {
     if (!passesContentTypeFilter(compact, input.contentType)) {
       continue;
     }
-    out.push(stripThreadListFields(compact));
+    resolvedMessages.push(full);
+    out.push(toSearchCompactMessage(compact, ref.permalink));
     if (out.length >= input.limit) {
       break;
     }
   }
-  return out;
+  const referencedUserIds = collectReferencedUserIds(resolvedMessages, {
+    includeReactions: false
+  });
+  const shouldResolveUsers = input.resolveUsers || input.refreshUsers;
+  const usersById = shouldResolveUsers ? await resolveUsersById({
+    client,
+    workspaceUrl: input.workspace_url ?? "",
+    userIds: referencedUserIds,
+    forceRefresh: Boolean(input.refreshUsers)
+  }) : new Map;
+  return {
+    messages: out,
+    referenced_users: toReferencedUsers(referencedUserIds, usersById)
+  };
 }
 async function searchMessagesInChannelsFallback(client, input) {
   const channelIds = await Promise.all(input.channels.map((c) => resolveChannelId(client, c)));
   const queryLower = input.query.trim().toLowerCase();
-  const userId = input.user ? await resolveUserId(client, input.user) : undefined;
+  const userId = input.user ? await resolveUserId2(client, input.user) : undefined;
   const afterSec = input.after ? dateToUnixSeconds(input.after, "start") : null;
   const beforeSec = input.before ? dateToUnixSeconds(input.before, "end") : null;
   const downloadsDir = input.download ? await ensureDownloadsDir() : null;
   const downloadedPaths = {};
+  const matchedSummaries = [];
   const results = [];
   for (const channelId of channelIds) {
     let cursorLatest;
@@ -6934,9 +7455,22 @@ async function searchMessagesInChannelsFallback(client, input) {
         if (!passesContentTypeFilter(compact, input.contentType)) {
           continue;
         }
-        results.push(stripThreadListFields(compact));
+        matchedSummaries.push(summary);
+        results.push(toSearchCompactMessage(compact));
         if (results.length >= input.limit) {
-          return results;
+          const referencedUserIds2 = collectReferencedUserIds(matchedSummaries, {
+            includeReactions: false
+          });
+          const usersById2 = await resolveUsersById({
+            client,
+            workspaceUrl: input.workspace_url ?? "",
+            userIds: referencedUserIds2,
+            forceRefresh: Boolean(input.refreshUsers)
+          });
+          return {
+            messages: results,
+            referenced_users: toReferencedUsers(referencedUserIds2, usersById2)
+          };
         }
       }
       if (!cursorLatest) {
@@ -6949,7 +7483,20 @@ async function searchMessagesInChannelsFallback(client, input) {
       }
     }
   }
-  return results;
+  const referencedUserIds = collectReferencedUserIds(matchedSummaries, {
+    includeReactions: false
+  });
+  const shouldResolveUsers = input.resolveUsers || input.refreshUsers;
+  const usersById = shouldResolveUsers ? await resolveUsersById({
+    client,
+    workspaceUrl: input.workspace_url ?? "",
+    userIds: referencedUserIds,
+    forceRefresh: Boolean(input.refreshUsers)
+  }) : new Map;
+  return {
+    messages: results,
+    referenced_users: toReferencedUsers(referencedUserIds, usersById)
+  };
 }
 function passesContentTypeFilter(m, contentType) {
   if (contentType === "any") {
@@ -6973,9 +7520,9 @@ function passesContentTypeFilter(m, contentType) {
   }
   return true;
 }
-function stripThreadListFields(m) {
-  const { channel_id: _channelId, thread_ts: _threadTs, ...rest } = m;
-  return rest;
+function toSearchCompactMessage(m, permalink) {
+  const { thread_ts: _threadTs, ...rest } = m;
+  return permalink ? { ...rest, permalink } : rest;
 }
 async function downloadFilesForMessage(input) {
   for (const f of input.message.files ?? []) {
@@ -7067,8 +7614,9 @@ async function searchSlack(input) {
   const out = {};
   if (input.options.kind === "messages" || input.options.kind === "all") {
     if (input.options.channels?.length) {
-      out.messages = await searchMessagesInChannelsFallback(input.client, {
+      const messageResult = await searchMessagesInChannelsFallback(input.client, {
         auth: input.auth,
+        workspace_url: input.options.workspace_url,
         query: input.options.query,
         channels: input.options.channels,
         user: input.options.user,
@@ -7077,11 +7625,15 @@ async function searchSlack(input) {
         limit,
         maxContentChars,
         contentType,
-        download
+        download,
+        resolveUsers: input.options.resolve_users,
+        refreshUsers: input.options.refresh_users
       });
+      out.messages = messageResult.messages;
+      out.referenced_users = messageResult.referenced_users;
     } else {
       const rawMatches = await searchMessagesRaw(input.client, { query: slackQuery, limit });
-      out.messages = await searchMessagesViaSearchApi(input.client, {
+      const messageResult = await searchMessagesViaSearchApi(input.client, {
         auth: input.auth,
         workspace_url: input.options.workspace_url,
         slack_query: slackQuery,
@@ -7089,8 +7641,12 @@ async function searchSlack(input) {
         maxContentChars,
         contentType,
         download,
-        rawMatches
+        rawMatches,
+        resolveUsers: input.options.resolve_users,
+        refreshUsers: input.options.refresh_users
       });
+      out.messages = messageResult.messages;
+      out.referenced_users = messageResult.referenced_users;
     }
   }
   if (input.options.kind === "files" || input.options.kind === "all") {
@@ -7121,7 +7677,7 @@ async function searchSlack(input) {
 
 // src/cli/search-command.ts
 function addSearchOptions(cmd) {
-  return cmd.option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when searching across multiple workspaces)").option("--channel <channel...>", "Channel filter (#name, name, or id). Repeatable.").option("--user <user>", "User filter (@name, name, or user id U...)").option("--after <date>", "Only results after YYYY-MM-DD").option("--before <date>", "Only results before YYYY-MM-DD").option("--content-type <type>", "Filter content type: any|text|image|snippet|file (default any)").option("--limit <n>", "Max results (default 20)", "20").option("--max-content-chars <n>", "Max message content characters (default 4000, -1 for unlimited)", "4000");
+  return cmd.option("--workspace <url>", "Workspace selector (full URL or unique substring; needed when searching across multiple workspaces)").option("--channel <channel...>", "Channel filter (#name, name, or id). Repeatable.").option("--user <user>", "User filter (@name, name, or user id U...)").option("--after <date>", "Only results after YYYY-MM-DD").option("--before <date>", "Only results before YYYY-MM-DD").option("--content-type <type>", "Filter content type: any|text|image|snippet|file (default any)").option("--limit <n>", "Max results (default 20)", "20").option("--max-content-chars <n>", "Max message content characters (default 4000, -1 for unlimited)", "4000").option("--resolve-users", "Resolve user IDs to user profiles").option("--refresh-users", "Refresh user profile cache before resolving referenced users (implies --resolve-users)");
 }
 async function runSearch(input) {
   const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
@@ -7148,39 +7704,604 @@ async function runSearch(input) {
           content_type: contentType,
           limit,
           max_content_chars: maxContentChars,
-          download: true
+          download: true,
+          resolve_users: Boolean(input.options.resolveUsers || input.options.refreshUsers),
+          refresh_users: Boolean(input.options.refreshUsers)
+        }
+      });
+    }
+  });
+  console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+}
+function registerSearchCommand(input) {
+  const searchCmd = input.program.command("search").description("Search Slack messages and files (token-efficient JSON)");
+  const create = (spec) => addSearchOptions(searchCmd.command(spec.name).description(spec.desc)).argument("<query>", "Search query").action(async (...args) => {
+    const [query, options] = args;
+    try {
+      await runSearch({ ctx: input.ctx, kind: spec.kind, query, options });
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  create({ kind: "all", name: "all", desc: "Search messages and files" });
+  create({ kind: "messages", name: "messages", desc: "Search messages" });
+  create({ kind: "files", name: "files", desc: "Search files" });
+}
+
+// src/slack/later.ts
+async function fetchLaterItems(client, options) {
+  const stateFilter = options?.state ?? "in_progress";
+  const limit = options?.limit ?? 20;
+  const maxBodyChars = options?.maxBodyChars ?? 4000;
+  const countsOnly = options?.countsOnly ?? false;
+  let currentCursor = options?.cursor;
+  let allRawItems = [];
+  let counts = {};
+  let nextCursor;
+  while (true) {
+    const resp = await client.api("saved.list", {
+      limit: 50,
+      cursor: currentCursor
+    });
+    if (!currentCursor) {
+      counts = isRecord5(resp.counts) ? resp.counts : {};
+    }
+    const pageRawItems = asArray2(resp.saved_items).filter(isRecord5);
+    allRawItems.push(...pageRawItems);
+    const meta = isRecord5(resp.response_metadata) ? resp.response_metadata : null;
+    nextCursor = meta ? getString5(meta.next_cursor) : undefined;
+    if (countsOnly) {
+      break;
+    }
+    let filtered2 = allRawItems.filter((item) => getString5(item.item_type) === "message");
+    if (stateFilter !== "all") {
+      filtered2 = filtered2.filter((item) => getString5(item.state) === stateFilter);
+    }
+    if (filtered2.length >= limit || !nextCursor) {
+      break;
+    }
+    currentCursor = nextCursor;
+  }
+  const result = {
+    counts: {
+      in_progress: getNumber3(counts.uncompleted_count) ?? 0,
+      archived: getNumber3(counts.archived_count) ?? 0,
+      completed: getNumber3(counts.completed_count) ?? 0,
+      total: getNumber3(counts.total_count) ?? 0
+    },
+    items: [],
+    next_cursor: nextCursor
+  };
+  if (countsOnly) {
+    return result;
+  }
+  let filtered = allRawItems.filter((item) => getString5(item.item_type) === "message");
+  if (stateFilter !== "all") {
+    filtered = filtered.filter((item) => getString5(item.state) === stateFilter);
+  }
+  filtered = filtered.slice(0, limit);
+  result.items = await Promise.all(filtered.map(async (item) => {
+    const channelId = getString5(item.item_id) ?? "";
+    const ts = getString5(item.ts) ?? "";
+    const state = getString5(item.state) ?? "in_progress";
+    const dateSaved = getNumber3(item.date_created) ?? 0;
+    const dateCompleted = getNumber3(item.date_completed);
+    let channelName;
+    let message;
+    try {
+      const info = await client.api("conversations.info", {
+        channel: channelId
+      });
+      const ch = isRecord5(info.channel) ? info.channel : null;
+      if (ch) {
+        channelName = getString5(ch.name) ?? getString5(ch.name_normalized) ?? undefined;
+        if (ch.is_im && !channelName) {
+          const userId = getString5(ch.user);
+          if (userId) {
+            try {
+              const userInfo = await client.api("users.info", { user: userId });
+              const u = isRecord5(userInfo.user) ? userInfo.user : null;
+              const profile = u && isRecord5(u.profile) ? u.profile : null;
+              channelName = getString5(profile?.display_name) || getString5(u?.real_name) || getString5(u?.name) || undefined;
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+    if (ts) {
+      try {
+        const history = await client.api("conversations.history", {
+          channel: channelId,
+          latest: ts,
+          inclusive: true,
+          limit: 1
+        });
+        const msgs = asArray2(history.messages).filter(isRecord5);
+        const msg = msgs.find((m) => getString5(m.ts) === ts);
+        if (msg) {
+          const rendered = renderSlackMessageContent(msg);
+          const content = maxBodyChars >= 0 && rendered.length > maxBodyChars ? `${rendered.slice(0, maxBodyChars)}
+…` : rendered;
+          message = {
+            author: getString5(msg.user) || getString5(msg.bot_id) ? {
+              user_id: getString5(msg.user) ?? undefined,
+              bot_id: getString5(msg.bot_id) ?? undefined
+            } : undefined,
+            content: content || undefined,
+            thread_ts: getString5(msg.thread_ts) ?? undefined,
+            reply_count: getNumber3(msg.reply_count) ?? undefined
+          };
+        }
+      } catch {}
+    }
+    return {
+      channel_id: channelId,
+      channel_name: channelName,
+      ts,
+      state,
+      date_saved: dateSaved,
+      date_completed: dateCompleted && dateCompleted > 0 ? dateCompleted : undefined,
+      message
+    };
+  }));
+  return result;
+}
+async function updateLaterMark(client, input) {
+  await client.apiMultipart("saved.update", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts,
+    mark: input.mark
+  });
+}
+async function saveLater(client, input) {
+  await client.api("saved.add", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts
+  });
+}
+async function removeLater(client, input) {
+  await client.api("saved.delete", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts
+  });
+}
+async function setLaterReminder(client, input) {
+  await client.apiMultipart("saved.update", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts,
+    date_due: String(input.dateDue)
+  });
+}
+function parseReminderDuration(input) {
+  const now = Math.floor(Date.now() / 1000);
+  const trimmed = input.trim().toLowerCase();
+  const relMatch = trimmed.match(/^(\d+(?:\.\d+)?)\s*(m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)$/);
+  if (relMatch) {
+    const amount = Number.parseFloat(relMatch[1]);
+    const unit = relMatch[2].charAt(0);
+    if (unit === "m") {
+      return now + amount * 60;
+    }
+    if (unit === "h") {
+      return now + amount * 3600;
+    }
+    if (unit === "d") {
+      return now + amount * 86400;
+    }
+  }
+  const tomorrow9am = getNext9am(1);
+  if (trimmed === "tomorrow") {
+    return tomorrow9am;
+  }
+  const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+  const dayIndex = dayNames.indexOf(trimmed);
+  if (dayIndex >= 0) {
+    const today = new Date;
+    const currentDay = today.getDay();
+    let daysUntil = dayIndex - currentDay;
+    if (daysUntil <= 0) {
+      daysUntil += 7;
+    }
+    return getNext9am(daysUntil);
+  }
+  const asNum = Number(trimmed);
+  if (!Number.isNaN(asNum) && asNum > 1e9) {
+    return asNum;
+  }
+  throw new Error(`Invalid duration: "${input}". Use: 30m, 1h, 3h, 2d, tomorrow, monday, or a unix timestamp.`);
+}
+function getNext9am(daysFromNow) {
+  const date = new Date;
+  date.setDate(date.getDate() + daysFromNow);
+  date.setHours(9, 0, 0, 0);
+  return Math.floor(date.getTime() / 1000);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString5(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber3(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/cli/later-command.ts
+function resolveTargetRef(input) {
+  const { targetInput, options, ctx } = input;
+  const target = parseMsgTarget(targetInput);
+  if (target.kind === "url") {
+    return {
+      workspaceUrl: target.ref.workspace_url,
+      getChannelAndTs: async () => ({
+        channelId: target.ref.channel_id,
+        ts: target.ref.message_ts
+      })
+    };
+  }
+  const workspaceUrl = ctx.effectiveWorkspaceUrl(options.workspace);
+  const ts = options.ts?.trim();
+  if (!ts) {
+    throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+  }
+  return {
+    workspaceUrl,
+    getChannelAndTs: async (client) => {
+      const channelId = await resolveChannelId(client, target.kind === "channel" ? target.channel : targetInput);
+      return { channelId, ts };
+    }
+  };
+}
+function registerLaterCommand(input) {
+  const laterCmd = input.program.command("later").description("Manage saved-for-later messages (Slack's Later tab)");
+  laterCmd.command("list", { isDefault: true }).description("List saved-for-later messages").option("--workspace <url>", "Workspace URL (defaults to your configured workspace)").option("--state <state>", "Filter by state: in_progress (default), archived, completed, all", "in_progress").option("--limit <n>", "Max items to show (default 20)", "20").option("--max-body-chars <n>", "Max content characters per message (default 4000, -1 for unlimited)", "4000").option("--counts-only", "Only show counts per state, skip message content").action(async (options) => {
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const state = parseState(options.state ?? "in_progress");
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return fetchLaterItems(client, {
+            state,
+            limit: Number.parseInt(options.limit ?? "20", 10),
+            maxBodyChars: Number.parseInt(options.maxBodyChars ?? "4000", 10),
+            countsOnly: options.countsOnly
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("complete").description("Mark a saved message as completed").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await updateLaterMark(client, { channelId, ts, mark: "completed" });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("archive").description("Archive a saved message").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await updateLaterMark(client, { channelId, ts, mark: "archived" });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("reopen").description("Move a saved message back to in-progress").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await Promise.allSettled([
+            updateLaterMark(client, { channelId, ts, mark: "uncompleted" }),
+            updateLaterMark(client, { channelId, ts, mark: "unarchived" })
+          ]);
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("save").description("Save a message for later").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await saveLater(client, { channelId, ts });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("remove").description("Remove a message from Later entirely").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await removeLater(client, { channelId, ts });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("remind").description("Set a reminder for a saved message").argument("<target>", "Slack message URL or channel ID").requiredOption("--in <duration>", "When to remind: 30m, 1h, 3h, 2d, tomorrow, monday, etc.").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      const reminderTime = parseReminderDuration(options.in);
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await setLaterReminder(client, { channelId, ts, dateDue: reminderTime });
+        }
+      });
+      console.log(JSON.stringify({
+        ok: true,
+        remind_at: reminderTime
+      }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+function parseState(value) {
+  const v = value.toLowerCase().trim();
+  if (v === "in_progress" || v === "in-progress" || v === "active" || v === "open") {
+    return "in_progress";
+  }
+  if (v === "archived" || v === "archive") {
+    return "archived";
+  }
+  if (v === "completed" || v === "complete" || v === "done") {
+    return "completed";
+  }
+  if (v === "all") {
+    return "all";
+  }
+  return "in_progress";
+}
+
+// src/slack/unreads.ts
+async function fetchUnreads(client, options) {
+  const includeMessages = options?.includeMessages ?? true;
+  const maxMessages = options?.maxMessagesPerChannel ?? 10;
+  const maxBodyChars = options?.maxBodyChars ?? 4000;
+  const skipSystem = options?.skipSystemMessages ?? true;
+  const resp = await client.api("client.counts", {
+    thread_count_by_channel: true
+  });
+  const channels = asArray3(resp.channels).filter(isRecord6);
+  const mpims = asArray3(resp.mpims).filter(isRecord6);
+  const ims = asArray3(resp.ims).filter(isRecord6);
+  const allEntries = [
+    ...channels.map((c) => ({ ...c, type: "channel" })),
+    ...mpims.map((c) => ({ ...c, type: "mpim" })),
+    ...ims.map((c) => ({ ...c, type: "dm" }))
+  ];
+  const withUnreads = allEntries.filter((c) => c.has_unreads);
+  const channelInfos = await Promise.all(withUnreads.map(async (entry) => {
+    const channelInfoPromise = (async () => {
+      let name;
+      let { type } = entry;
+      try {
+        const info = await client.api("conversations.info", {
+          channel: entry.id
+        });
+        const ch = isRecord6(info.channel) ? info.channel : null;
+        if (ch) {
+          name = getString6(ch.name) ?? getString6(ch.name_normalized) ?? undefined;
+          if (ch.is_im) {
+            type = "dm";
+            const userId = getString6(ch.user);
+            if (userId && !name) {
+              try {
+                const userInfo = await client.api("users.info", { user: userId });
+                const u = isRecord6(userInfo.user) ? userInfo.user : null;
+                const profile = u && isRecord6(u.profile) ? u.profile : null;
+                name = getString6(profile?.display_name) || getString6(u?.real_name) || getString6(u?.name) || undefined;
+              } catch {}
+            }
+          } else if (ch.is_mpim) {
+            type = "mpim";
+          } else if (ch.is_group || ch.is_private) {
+            type = "channel";
+          } else {
+            type = "channel";
+          }
         }
-      });
+      } catch {}
+      return { name, type };
+    })();
+    const historyPromise = (async () => {
+      let messages;
+      let unreadCount = entry.unread_count_display ?? entry.unread_count ?? (entry.has_unreads ? 1 : 0);
+      if (includeMessages && entry.last_read) {
+        try {
+          const history = await client.api("conversations.history", {
+            channel: entry.id,
+            oldest: entry.last_read,
+            limit: maxMessages,
+            inclusive: false
+          });
+          let msgs = asArray3(history.messages).filter(isRecord6);
+          if (skipSystem) {
+            msgs = msgs.filter((m) => {
+              const subtype = getString6(m.subtype);
+              if (!subtype) {
+                return true;
+              }
+              const systemSubtypes = [
+                "channel_join",
+                "channel_leave",
+                "channel_topic",
+                "channel_purpose",
+                "channel_name",
+                "channel_archive",
+                "channel_unarchive",
+                "group_join",
+                "group_leave",
+                "group_topic",
+                "group_purpose",
+                "group_name",
+                "group_archive",
+                "group_unarchive"
+              ];
+              return !systemSubtypes.includes(subtype);
+            });
+          }
+          if (entry.unread_count_display === undefined && entry.unread_count === undefined) {
+            unreadCount = msgs.length;
+            if (history.has_more) {
+              unreadCount = Math.max(unreadCount, 2);
+            }
+          }
+          messages = msgs.map((m) => {
+            const rendered = renderSlackMessageContent(m);
+            const content = maxBodyChars >= 0 && rendered.length > maxBodyChars ? `${rendered.slice(0, maxBodyChars)}
+...` : rendered;
+            return {
+              ts: getString6(m.ts) ?? "",
+              author: getString6(m.user) || getString6(m.bot_id) ? {
+                user_id: getString6(m.user) ?? undefined,
+                bot_id: getString6(m.bot_id) ?? undefined
+              } : undefined,
+              content: content || undefined,
+              thread_ts: getString6(m.thread_ts) ?? undefined,
+              reply_count: getNumber4(m.reply_count) ?? undefined
+            };
+          });
+          messages.sort((a, b) => Number.parseFloat(a.ts) - Number.parseFloat(b.ts));
+        } catch {}
+      }
+      return { messages, unreadCount };
+    })();
+    const [channelData, historyData] = await Promise.all([channelInfoPromise, historyPromise]);
+    return {
+      channel_id: entry.id,
+      channel_name: channelData.name,
+      channel_type: channelData.type,
+      unread_count: historyData.unreadCount,
+      mention_count: entry.mention_count ?? 0,
+      messages: historyData.messages
+    };
+  }));
+  channelInfos.sort((a, b) => {
+    if (a.mention_count !== b.mention_count) {
+      return b.mention_count - a.mention_count;
     }
+    return b.unread_count - a.unread_count;
   });
-  console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+  const threads = isRecord6(resp.threads) ? resp.threads : null;
+  const threadInfo = threads?.has_unreads ? {
+    has_unreads: true,
+    mention_count: threads.mention_count ?? 0
+  } : null;
+  return { channels: channelInfos, threads: threadInfo };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
 }
-function registerSearchCommand(input) {
-  const searchCmd = input.program.command("search").description("Search Slack messages and files (token-efficient JSON)");
-  const create = (spec) => addSearchOptions(searchCmd.command(spec.name).description(spec.desc)).argument("<query>", "Search query").action(async (...args) => {
-    const [query, options] = args;
+function asArray3(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString6(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber4(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/cli/unreads-command.ts
+function registerUnreadsCommand(input) {
+  input.program.command("unreads").description("Show all unread messages across channels, DMs, and threads").option("--workspace <url>", "Workspace URL (defaults to your configured workspace)").option("--counts-only", "Only show unread counts, do not fetch message content").option("--max-messages <n>", "Max unread messages to fetch per channel (default 10)", "10").option("--max-body-chars <n>", "Max content characters per message (default 4000, -1 for unlimited)", "4000").option("--include-system", "Include system messages (joins, leaves, topic changes, etc.)").action(async (options) => {
     try {
-      await runSearch({ ctx: input.ctx, kind: spec.kind, query, options });
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return fetchUnreads(client, {
+            includeMessages: !options.countsOnly,
+            maxMessagesPerChannel: Number.parseInt(options.maxMessages ?? "10", 10),
+            maxBodyChars: Number.parseInt(options.maxBodyChars ?? "4000", 10),
+            skipSystemMessages: !options.includeSystem
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
     } catch (err) {
       console.error(input.ctx.errorMessage(err));
       process.exitCode = 1;
     }
   });
-  create({ kind: "all", name: "all", desc: "Search messages and files" });
-  create({ kind: "messages", name: "messages", desc: "Search messages" });
-  create({ kind: "files", name: "files", desc: "Search files" });
 }
 
 // src/lib/update.ts
 import { execSync as execSync2 } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { chmod, copyFile as copyFile2, mkdir as mkdir5, readFile as readFile7, rename, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename3, join as join13 } from "node:path";
+import { basename as basename3, join as join14 } from "node:path";
 var REPO = "stablyai/agent-slack";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function getCachePath() {
-  return join13(getAppDir(), "update-check.json");
+  return join14(getAppDir(), "update-check.json");
 }
 function compareSemver(a, b) {
   const pa = a.replace(/^v/, "").split(".").map(Number);
@@ -7276,16 +8397,16 @@ function detectPlatformAsset() {
 }
 async function sha256(filePath) {
   const data = await readFile7(filePath);
-  return createHash("sha256").update(data).digest("hex");
+  return createHash2("sha256").update(data).digest("hex");
 }
 async function performUpdate(latest) {
   const asset = detectPlatformAsset();
   const tag = `v${latest}`;
   const baseUrl = `https://github.com/${REPO}/releases/download/${tag}`;
-  const tmp = join13(tmpdir5(), `agent-slack-update-${Date.now()}`);
+  const tmp = join14(tmpdir5(), `agent-slack-update-${Date.now()}`);
   await mkdir5(tmp, { recursive: true });
-  const binTmp = join13(tmp, asset);
-  const sumsTmp = join13(tmp, "checksums-sha256.txt");
+  const binTmp = join14(tmp, asset);
+  const sumsTmp = join14(tmp, "checksums-sha256.txt");
   try {
     const [binResp, sumsResp] = await Promise.all([
       fetch(`${baseUrl}/${asset}`, { signal: AbortSignal.timeout(120000) }),
@@ -7300,288 +8421,100 @@ async function performUpdate(latest) {
     await writeFile4(binTmp, Buffer.from(await binResp.arrayBuffer()));
     const sumsText = await sumsResp.text();
     await writeFile4(sumsTmp, sumsText);
-    const expected = sumsText.split(`
-`).map((line) => line.trim().split(/\s+/)).find((parts) => parts[1] === asset)?.[0];
-    if (!expected) {
-      return { success: false, message: `Checksum not found for ${asset} in release checksums` };
-    }
-    const actual = await sha256(binTmp);
-    if (actual !== expected) {
-      return { success: false, message: `Checksum mismatch: expected ${expected}, got ${actual}` };
-    }
-    const currentBin = process.execPath;
-    const backupPath = `${currentBin}.bak`;
-    await rename(currentBin, backupPath);
-    try {
-      await copyFile2(binTmp, currentBin);
-      await chmod(currentBin, 493);
-      await rm3(backupPath, { force: true });
-    } catch (err) {
-      try {
-        await rename(backupPath, currentBin);
-      } catch {}
-      throw err;
-    }
-    return { success: true, message: `Updated agent-slack to ${latest}` };
-  } finally {
-    await rm3(tmp, { recursive: true, force: true }).catch(() => {});
-  }
-}
-async function backgroundUpdateCheck() {
-  if (process.env.AGENT_SLACK_NO_UPDATE_CHECK === "1") {
-    return;
-  }
-  try {
-    const result = await checkForUpdate();
-    if (result?.update_available) {
-      const cmd = getUpdateCommand();
-      process.stderr.write(`
-Update available: ${result.current} → ${result.latest}. Run "${cmd}" to upgrade.
-`);
-    }
-  } catch {}
-}
-
-// src/cli/update-command.ts
-function registerUpdateCommand(input) {
-  input.program.command("update").description("Update agent-slack to the latest version").option("--check", "Only check for updates (don't install)").action(async (...args) => {
-    const [options] = args;
-    const method = detectInstallMethod();
-    try {
-      const result = await checkForUpdate(true);
-      if (!result) {
-        console.error("Could not check for updates. Check your network connection.");
-        process.exitCode = 1;
-        return;
-      }
-      if (!result.update_available) {
-        console.log(JSON.stringify(pruneEmpty({ ...result, install_method: method, status: "up_to_date" }), null, 2));
-        return;
-      }
-      if (options.check) {
-        console.log(JSON.stringify(pruneEmpty({
-          ...result,
-          install_method: method,
-          update_command: getUpdateCommand(method),
-          status: "update_available"
-        }), null, 2));
-        return;
-      }
-      process.stderr.write(`Updating agent-slack ${result.current} → ${result.latest}...
-`);
-      let outcome;
-      if (method === "npm" || method === "bun") {
-        process.stderr.write(`Detected install method: ${method}
-`);
-        outcome = performPackageManagerUpdate(method);
-      } else {
-        outcome = await performUpdate(result.latest);
-      }
-      if (!outcome.success) {
-        console.error(outcome.message);
-        process.exitCode = 1;
-        return;
-      }
-      console.log(JSON.stringify(pruneEmpty({
-        status: "updated",
-        install_method: method,
-        previous_version: result.current,
-        new_version: result.latest,
-        message: outcome.message
-      }), null, 2));
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err));
-      process.exitCode = 1;
-    }
-  });
-}
-
-// src/slack/users.ts
-async function listUsers(client, options) {
-  const limit = Math.min(Math.max(options?.limit ?? 200, 1), 1000);
-  const includeBots = options?.includeBots ?? false;
-  let next_cursor;
-  const [out, dmMap] = await Promise.all([
-    (async () => {
-      const users = [];
-      let cursor = options?.cursor;
-      while (users.length < limit) {
-        const pageSize = Math.min(200, limit - users.length);
-        const resp = await client.api("users.list", { limit: pageSize, cursor });
-        const members = asArray(resp.members).filter(isRecord);
-        for (const m of members) {
-          const id = getString(m.id);
-          if (!id) {
-            continue;
-          }
-          if (!includeBots && m.is_bot) {
-            continue;
-          }
-          users.push(toCompactUser(m));
-          if (users.length >= limit) {
-            break;
-          }
-        }
-        const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
-        const next = meta ? getString(meta.next_cursor) : undefined;
-        if (!next) {
-          break;
-        }
-        cursor = next;
-        next_cursor = next;
-      }
-      return users;
-    })(),
-    fetchDmMap(client)
-  ]);
-  for (const u of out) {
-    const dmId = dmMap.get(u.id);
-    if (dmId) {
-      u.dm_id = dmId;
-    }
-  }
-  return { users: out, next_cursor };
-}
-async function getUser(client, input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("User is empty");
-  }
-  const userId = await resolveUserId2(client, trimmed);
-  if (!userId) {
-    throw new Error(`Could not resolve user: ${input}`);
-  }
-  const resp = await client.api("users.info", { user: userId });
-  const u = isRecord(resp.user) ? resp.user : null;
-  if (!u || !getString(u.id)) {
-    throw new Error("users.info returned no user");
-  }
-  return toCompactUser(u);
-}
-async function resolveUserId2(client, input) {
-  const trimmed = input.trim();
-  if (/^U[A-Z0-9]{8,}$/.test(trimmed)) {
-    return trimmed;
-  }
-  const looksLikeEmail = /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(trimmed) && !trimmed.startsWith("@");
-  if (looksLikeEmail) {
-    try {
-      const byEmail = await client.api("users.lookupByEmail", { email: trimmed });
-      const user = isRecord(byEmail.user) ? byEmail.user : null;
-      const userId = user ? getString(user.id) : undefined;
-      if (userId) {
-        return userId;
-      }
-    } catch {}
-  }
-  const handle = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
-  if (!handle) {
-    return null;
-  }
-  let cursor;
-  for (;; ) {
-    const resp = await client.api("users.list", { limit: 200, cursor });
-    const members = asArray(resp.members).filter(isRecord);
-    const found = members.find((m) => {
-      if (getString(m.name) === handle) {
-        return true;
-      }
-      if (looksLikeEmail) {
-        const profile = isRecord(m.profile) ? m.profile : null;
-        const email = profile ? getString(profile.email) : undefined;
-        return Boolean(email) && email?.toLowerCase() === trimmed.toLowerCase();
-      }
-      return false;
-    });
-    if (found) {
-      const id = getString(found.id);
-      if (id) {
-        return id;
-      }
-    }
-    const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
-    const next = meta ? getString(meta.next_cursor) : undefined;
-    if (!next) {
-      break;
+    const expected = sumsText.split(`
+`).map((line) => line.trim().split(/\s+/)).find((parts) => parts[1] === asset)?.[0];
+    if (!expected) {
+      return { success: false, message: `Checksum not found for ${asset} in release checksums` };
     }
-    cursor = next;
-  }
-  return null;
-}
-async function fetchDmMap(client) {
-  const map = new Map;
-  let cursor;
-  for (;; ) {
-    const resp = await client.api("conversations.list", {
-      types: "im",
-      limit: 200,
-      cursor
-    });
-    const channels = asArray(resp.channels).filter(isRecord);
-    for (const ch of channels) {
-      const id = getString(ch.id);
-      const user = getString(ch.user);
-      if (id && user) {
-        map.set(user, id);
-      }
+    const actual = await sha256(binTmp);
+    if (actual !== expected) {
+      return { success: false, message: `Checksum mismatch: expected ${expected}, got ${actual}` };
     }
-    const meta = isRecord(resp.response_metadata) ? resp.response_metadata : null;
-    const next = meta ? getString(meta.next_cursor) : undefined;
-    if (!next) {
-      break;
+    const currentBin = process.execPath;
+    const backupPath = `${currentBin}.bak`;
+    await rename(currentBin, backupPath);
+    try {
+      await copyFile2(binTmp, currentBin);
+      await chmod(currentBin, 493);
+      await rm3(backupPath, { force: true });
+    } catch (err) {
+      try {
+        await rename(backupPath, currentBin);
+      } catch {}
+      throw err;
     }
-    cursor = next;
+    return { success: true, message: `Updated agent-slack to ${latest}` };
+  } finally {
+    await rm3(tmp, { recursive: true, force: true }).catch(() => {});
   }
-  return map;
 }
-async function getDmChannelForUsers(client, inputs) {
-  if (!inputs || inputs.length === 0) {
-    throw new Error("At least one user is required");
-  }
-  if (inputs.length > 8) {
-    throw new Error("Slack supports a maximum of 8 users in a group DM");
+async function backgroundUpdateCheck() {
+  if (process.env.AGENT_SLACK_NO_UPDATE_CHECK === "1") {
+    return;
   }
-  const userIds = [];
-  for (const input of inputs) {
-    const trimmed = input.trim();
-    if (!trimmed) {
-      continue;
-    }
-    const userId = await resolveUserId2(client, trimmed);
-    if (!userId) {
-      throw new Error(`Could not resolve user: ${input}`);
+  try {
+    const result = await checkForUpdate();
+    if (result?.update_available) {
+      const cmd = getUpdateCommand();
+      process.stderr.write(`
+Update available: ${result.current} → ${result.latest}. Run "${cmd}" to upgrade.
+`);
     }
-    userIds.push(userId);
-  }
-  if (userIds.length === 0) {
-    throw new Error("No valid users provided");
-  }
-  const resp = await client.api("conversations.open", { users: userIds.join(",") });
-  const channel = isRecord(resp.channel) ? resp.channel : null;
-  const channelId = channel ? getString(channel.id) : null;
-  if (!channelId) {
-    throw new Error("conversations.open returned no channel");
-  }
-  const channelType = channelId.startsWith("D") ? "dm" : "group_dm";
-  return {
-    user_ids: userIds,
-    dm_channel_id: channelId,
-    channel_type: channelType
-  };
+  } catch {}
 }
-function toCompactUser(u) {
-  const profile = isRecord(u.profile) ? u.profile : {};
-  return {
-    id: getString(u.id) ?? "",
-    name: getString(u.name) ?? undefined,
-    real_name: getString(u.real_name) ?? getString(profile.real_name) ?? undefined,
-    display_name: getString(profile.display_name) ?? undefined,
-    email: getString(profile.email) ?? undefined,
-    title: getString(profile.title) ?? undefined,
-    tz: getString(u.tz) ?? undefined,
-    is_bot: typeof u.is_bot === "boolean" ? u.is_bot : undefined,
-    deleted: typeof u.deleted === "boolean" ? u.deleted : undefined
-  };
+
+// src/cli/update-command.ts
+function registerUpdateCommand(input) {
+  input.program.command("update").description("Update agent-slack to the latest version").option("--check", "Only check for updates (don't install)").action(async (...args) => {
+    const [options] = args;
+    const method = detectInstallMethod();
+    try {
+      const result = await checkForUpdate(true);
+      if (!result) {
+        console.error("Could not check for updates. Check your network connection.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!result.update_available) {
+        console.log(JSON.stringify(pruneEmpty({ ...result, install_method: method, status: "up_to_date" }), null, 2));
+        return;
+      }
+      if (options.check) {
+        console.log(JSON.stringify(pruneEmpty({
+          ...result,
+          install_method: method,
+          update_command: getUpdateCommand(method),
+          status: "update_available"
+        }), null, 2));
+        return;
+      }
+      process.stderr.write(`Updating agent-slack ${result.current} → ${result.latest}...
+`);
+      let outcome;
+      if (method === "npm" || method === "bun") {
+        process.stderr.write(`Detected install method: ${method}
+`);
+        outcome = performPackageManagerUpdate(method);
+      } else {
+        outcome = await performUpdate(result.latest);
+      }
+      if (!outcome.success) {
+        console.error(outcome.message);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(JSON.stringify(pruneEmpty({
+        status: "updated",
+        install_method: method,
+        previous_version: result.current,
+        new_version: result.latest,
+        message: outcome.message
+      }), null, 2));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+  });
 }
 
 // src/cli/user-command.ts
@@ -7768,7 +8701,7 @@ function registerChannelCommand(input) {
           }
           let userId;
           if (options.user) {
-            const resolvedUserId = await resolveUserId2(client, options.user);
+            const resolvedUserId = await resolveUserId(client, options.user);
             if (!resolvedUserId) {
               throw new Error(`Could not resolve user: ${options.user}`);
             }
@@ -7851,7 +8784,7 @@ function registerChannelCommand(input) {
           const resolvedUserIds = [];
           const unresolvedUsers = [];
           for (const userInput of userInputs) {
-            const userId = await resolveUserId2(client, userInput);
+            const userId = await resolveUserId(client, userInput);
             if (!userId) {
               unresolvedUsers.push(userInput);
               continue;
@@ -7921,6 +8854,274 @@ function registerChannelCommand(input) {
   });
 }
 
+// src/slack/workflows.ts
+async function listChannelWorkflows(client, channelId) {
+  const [bookmarked, featured] = await Promise.all([
+    listBookmarkedWorkflows(client, channelId),
+    listFeaturedWorkflows(client, channelId)
+  ]);
+  const featuredIds = new Set(featured.map((f) => f.trigger_id));
+  const seen = new Set;
+  const workflows = [];
+  for (const bk of bookmarked) {
+    if (bk.trigger_id) {
+      seen.add(bk.trigger_id);
+    }
+    workflows.push({
+      title: bk.title,
+      trigger_id: bk.trigger_id ?? "",
+      link: bk.link,
+      app_id: bk.app_id,
+      featured: bk.trigger_id ? featuredIds.has(bk.trigger_id) : false
+    });
+  }
+  for (const ft of featured) {
+    if (!seen.has(ft.trigger_id)) {
+      workflows.push({
+        title: ft.title,
+        trigger_id: ft.trigger_id,
+        featured: true
+      });
+    }
+  }
+  return { channel_id: channelId, workflows };
+}
+async function listBookmarkedWorkflows(client, channelId) {
+  const resp = await client.api("bookmarks.list", {
+    channel_id: channelId
+  });
+  return asArray(resp.bookmarks).filter(isRecord).filter((b) => {
+    const link = getString(b.link) ?? "";
+    const shortcutId = getString(b.shortcut_id);
+    return shortcutId || link.includes("slack.com/shortcuts/");
+  }).map((b) => {
+    const link = getString(b.link);
+    const shortcutId = getString(b.shortcut_id);
+    const triggerId = shortcutId || extractTriggerId(link);
+    return {
+      title: getString(b.title) ?? "",
+      trigger_id: triggerId,
+      link,
+      app_id: getString(b.app_id)
+    };
+  });
+}
+async function listFeaturedWorkflows(client, channelId) {
+  try {
+    const resp = await client.api("workflows.featured.list", {
+      channel_ids: JSON.stringify([channelId])
+    });
+    const entries = asArray(resp.featured_workflows).filter(isRecord);
+    const entry = entries.find((e) => getString(e.channel_id) === channelId);
+    if (!entry) {
+      return [];
+    }
+    return asArray(entry.triggers).filter(isRecord).map((t) => ({
+      trigger_id: getString(t.id) ?? "",
+      title: getString(t.title) ?? ""
+    })).filter((t) => t.trigger_id);
+  } catch {
+    return [];
+  }
+}
+async function previewWorkflow(client, triggerId) {
+  const resp = await client.api("workflows.triggers.preview", {
+    trigger_ids: triggerId
+  });
+  const triggers = asArray(resp.triggers).filter(isRecord);
+  if (triggers.length === 0) {
+    const rejected = asArray(resp.rejected_triggers);
+    if (rejected.length > 0) {
+      throw new Error(`Trigger ${triggerId} was rejected — you may not have access`);
+    }
+    throw new Error(`No preview data returned for trigger ${triggerId}`);
+  }
+  const t = triggers[0];
+  const wf = isRecord(t.workflow) ? t.workflow : {};
+  const wfApp = isRecord(wf.app) ? wf.app : {};
+  const details = isRecord(t.workflow_details) ? t.workflow_details : {};
+  return {
+    trigger_id: getString(t.id) ?? triggerId,
+    type: getString(t.type) ?? "",
+    name: getString(t.name) ?? "",
+    description: getString(t.description) ?? "",
+    shortcut_url: getString(t.shortcut_url),
+    workflow: {
+      id: getString(wf.workflow_id) ?? "",
+      title: getString(wf.title) ?? "",
+      description: getString(wf.description) ?? "",
+      app_id: getString(wf.app_id) ?? getString(wfApp.id) ?? "",
+      app_name: getString(wfApp.name) ?? ""
+    },
+    collaborators: asArray(details.collaborators).map((c) => typeof c === "string" ? c : "").filter(Boolean)
+  };
+}
+async function runWorkflow(client, input) {
+  const clientToken = `cli-${Date.now()}`;
+  const resp = await client.api("workflows.triggers.trip", {
+    url: input.shortcutUrl,
+    client_token: clientToken,
+    context: JSON.stringify({
+      location: "bookmark",
+      channel_id: input.channelId,
+      trigger_id: input.triggerId
+    }),
+    run_precheck: true
+  });
+  return {
+    function_execution_id: getString(resp.function_execution_id) ?? "",
+    trigger_execution_id: getString(resp.trigger_execution_id) ?? "",
+    is_slow_workflow: resp.is_slow_workflow === true
+  };
+}
+async function resolveShortcutUrl(client, input) {
+  const { channelId, triggerId } = input;
+  const resp = await client.api("bookmarks.list", {
+    channel_id: channelId
+  });
+  const bookmarks = asArray(resp.bookmarks).filter(isRecord);
+  for (const b of bookmarks) {
+    const shortcutId = getString(b.shortcut_id);
+    if (shortcutId === triggerId) {
+      const link = getString(b.link);
+      if (link) {
+        return link;
+      }
+    }
+  }
+  throw new Error(`Could not find shortcut URL for trigger ${triggerId} in channel bookmarks`);
+}
+async function getWorkflowSchema(client, workflowId) {
+  const resp = await client.api("workflows.get", { workflow_id: workflowId });
+  const wf = isRecord(resp.workflow) ? resp.workflow : null;
+  if (!wf) {
+    throw new Error(`No workflow found for ID ${workflowId}`);
+  }
+  const steps = asArray(wf.steps).filter(isRecord);
+  const stepSummaries = [];
+  let fields = [];
+  let formTitle;
+  for (const step of steps) {
+    const fn = isRecord(step.function) ? step.function : {};
+    const callbackId = getString(fn.callback_id) ?? "";
+    const title = getString(fn.title) ?? callbackId;
+    stepSummaries.push(title);
+    if (callbackId === "open_form") {
+      const inputs = isRecord(step.inputs) ? step.inputs : {};
+      const titleInput = isRecord(inputs.title) ? inputs.title : {};
+      formTitle = getString(titleInput.value);
+      const fieldsInput = isRecord(inputs.fields) ? inputs.fields : {};
+      const fieldsValue = isRecord(fieldsInput.value) ? fieldsInput.value : {};
+      const elements = asArray(fieldsValue.elements).filter(isRecord);
+      const required = new Set(asArray(fieldsValue.required).map((r) => typeof r === "string" ? r : "").filter(Boolean));
+      fields = elements.map((el) => ({
+        name: getString(el.name) ?? "",
+        title: getString(el.title) ?? "",
+        type: getString(el.type) ?? "string",
+        description: getString(el.description) ?? "",
+        required: required.has(getString(el.name) ?? ""),
+        long: el.long === true ? true : undefined
+      }));
+    }
+  }
+  return {
+    workflow_id: getString(wf.id) ?? workflowId,
+    title: getString(wf.title) ?? "",
+    description: getString(wf.description) ?? "",
+    form_title: formTitle,
+    fields,
+    steps: stepSummaries
+  };
+}
+function extractTriggerId(link) {
+  if (!link) {
+    return;
+  }
+  const match = link.match(/slack\.com\/shortcuts\/(Ft[A-Za-z0-9]+)/);
+  return match?.[1];
+}
+
+// src/cli/workflow-command.ts
+function registerWorkflowCommand(input) {
+  const workflowCmd = input.program.command("workflow").description("Discover and interact with Slack workflows");
+  workflowCmd.command("list").description("List workflows bookmarked or featured in a channel").argument("<channel>", "Channel id or name (#channel, channel, C...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [channel, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const channelId = await resolveChannelId(client, channel);
+          return await listChannelWorkflows(client, channelId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("preview").description("Get workflow metadata from a trigger ID (no side effects)").argument("<trigger-id>", "Trigger ID (Ft...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [triggerId, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return await previewWorkflow(client, triggerId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("get").description("Get workflow definition including form fields and steps (accepts Ft... or Wf...)").argument("<id>", "Trigger ID (Ft...) or Workflow ID (Wf...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [id, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          let workflowId = id;
+          if (id.startsWith("Ft")) {
+            const preview = await previewWorkflow(client, id);
+            workflowId = preview.workflow.id;
+          }
+          return await getWorkflowSchema(client, workflowId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("run").description("Trip a workflow trigger").argument("<trigger-id>", "Trigger ID (Ft...)").requiredOption("--channel <id-or-name>", "Channel where the workflow is bookmarked").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [triggerId, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const channelId = await resolveChannelId(client, options.channel);
+          const shortcutUrl = await resolveShortcutUrl(client, { channelId, triggerId });
+          return await runWorkflow(client, { shortcutUrl, channelId, triggerId });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/index.ts
 var program = new Command;
 program.name("agent-slack").description("Slack automation CLI for AI agents").version(getPackageVersion());
@@ -7929,9 +9130,12 @@ registerAuthCommand({ program, ctx });
 registerMessageCommand({ program, ctx });
 registerCanvasCommand({ program, ctx });
 registerSearchCommand({ program, ctx });
+registerLaterCommand({ program, ctx });
+registerUnreadsCommand({ program, ctx });
 registerUpdateCommand({ program });
 registerUserCommand({ program, ctx });
 registerChannelCommand({ program, ctx });
+registerWorkflowCommand({ program, ctx });
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();
@@ -7941,5 +9145,5 @@ if (subcommand && subcommand !== "update") {
   backgroundUpdateCheck();
 }
 
-//# debugId=3EBC31FAC3ADA2FD64756E2164756E21
+//# debugId=4F295E0EDEFC23F164756E2164756E21
 //# sourceMappingURL=index.js.map