@sentry/junior 0.147.0 → 0.149.0

package/dist/{chunk-7A4M7PCV.js → chunk-DK5UT6PQ.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-X5UY34KT.js";
+} from "./chunk-XPYWWMHR.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -32,7 +32,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-Q4R73I43.js";
+} from "./chunk-RB26T3LU.js";
 import {
   RetryableDeliveryError,
   actorFromRouting,
@@ -40,7 +40,7 @@ import {
   isAgentRunFeatureDisabled,
   surfaceFromRouting,
   toolInvocationDestination
-} from "./chunk-R776HKPK.js";
+} from "./chunk-GDFF3BQG.js";
 import {
   addReactionToMessage,
   deliverOAuthAuthorization,
@@ -48,76 +48,7 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-7UQIVT6G.js";
-import {
-  estimateTextTokens,
-  getAgentContextCompactionTriggerTokens,
-  getAgentContextInputLimitTokens
-} from "./chunk-K4SZAP3K.js";
-import {
-  AGENTS_REMOVAL_NOTICE,
-  AGENTS_REPLACEMENT_NOTICE,
-  CooperativeTurnYieldError,
-  DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
-  MAX_TEXT_CHARS,
-  NO_REPLY_MARKER,
-  RIPGREP_EXCLUDED_GLOBS,
-  TURN_CONTEXT_TAG,
-  TurnInputCommitLostError,
-  TurnSliceLimitExceededError,
-  abandonReplacedPendingAuth,
-  buildAgentsInstructionsMessage,
-  canReusePendingAuthLink,
-  collectFiles,
-  containsNoReplyMarker,
-  continuableMessages,
-  decideReply,
-  extractAssistantText,
-  findSingleRepositoryDirectory,
-  findVisibleAgentsInstructions,
-  getAssistantReplyText,
-  getPiMessageRole,
-  getRipgrepSearchLocation,
-  getTerminalAssistantMessages,
-  getUserMessageInstructionText,
-  hasRuntimeTurnContext,
-  historyItemFromPiMessage,
-  isAssistantMessage,
-  isContinuablePiBoundary,
-  isMissingPathError,
-  isNoReplyMarker,
-  isToolResultError,
-  isToolResultMessage,
-  isTurnInputCommitLostError,
-  loadConnectedMcpProviders,
-  loadConversationProjection,
-  loadTurnCheckpoint,
-  loadTurnRoute,
-  missingPathSearchResult,
-  normalizeToLf,
-  normalizeToolNameFromResult,
-  openConversationProjection,
-  piMessageFromHistoryItem,
-  positiveInteger,
-  recordAgentsInstructionsUpdated,
-  recordAuthorizationRequested,
-  recordGuardianActionReviewed,
-  recordMcpProviderConnected,
-  recordToolExecutionStarted,
-  recordTurnRoute,
-  renderAgentsInstructions,
-  resolveRepositoryInstructions,
-  resolveWorkspacePath,
-  retainRuntimeTurnContext,
-  sanitizeAssistantText,
-  saveTurnCheckpoint,
-  stripRuntimeTurnContext,
-  trimTrailingAssistantMessages,
-  truncateText
-} from "./chunk-AIOK6LAG.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
+} from "./chunk-JMH3DBM5.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -146,7 +77,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-AVZDSUFB.js";
+} from "./chunk-2P6BQQER.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -178,20 +109,83 @@ import {
   saveEventTask,
   scheduledTaskAttributes,
   writableEventTask
-} from "./chunk-EFLJ2WJH.js";
+} from "./chunk-URDCZAL4.js";
 import {
   parseSlackThreadId
-} from "./chunk-CSZINQJ2.js";
+} from "./chunk-MEMURSBG.js";
 import {
+  AGENTS_REMOVAL_NOTICE,
+  AGENTS_REPLACEMENT_NOTICE,
+  CooperativeTurnYieldError,
+  DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
+  MAX_TEXT_CHARS,
+  NO_REPLY_MARKER,
+  RIPGREP_EXCLUDED_GLOBS,
   SHORT_TITLE_MAX_LENGTH,
-  generateShortTitle,
-  resolveTaskTitle
-} from "./chunk-Z4YU7Z4L.js";
-import {
+  TURN_CONTEXT_TAG,
   ToolInputError,
+  TurnInputCommitLostError,
+  TurnSliceLimitExceededError,
+  abandonReplacedPendingAuth,
   addAgentTurnUsage,
-  hasAgentTurnUsage
-} from "./chunk-HLXXQI5Q.js";
+  buildAgentsInstructionsMessage,
+  canReusePendingAuthLink,
+  collectFiles,
+  containsNoReplyMarker,
+  continuableMessages,
+  decideReply,
+  estimateTextTokens,
+  extractAssistantText,
+  findSingleRepositoryDirectory,
+  findVisibleAgentsInstructions,
+  generateShortTitle,
+  getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
+  getAssistantReplyText,
+  getPiMessageRole,
+  getRipgrepSearchLocation,
+  getTerminalAssistantMessages,
+  getUserMessageInstructionText,
+  hasAgentTurnUsage,
+  hasRuntimeTurnContext,
+  historyItemFromPiMessage,
+  isAssistantMessage,
+  isContinuablePiBoundary,
+  isMissingPathError,
+  isNoReplyMarker,
+  isToolResultError,
+  isToolResultMessage,
+  isTurnInputCommitLostError,
+  loadConnectedMcpProviders,
+  loadConversationProjection,
+  loadTurnCheckpoint,
+  loadTurnRoute,
+  missingPathSearchResult,
+  normalizeToLf,
+  normalizeToolNameFromResult,
+  openConversationProjection,
+  piMessageFromHistoryItem,
+  positiveInteger,
+  recordAgentsInstructionsUpdated,
+  recordAuthorizationRequested,
+  recordGuardianActionReviewed,
+  recordMcpProviderConnected,
+  recordToolExecutionStarted,
+  recordTurnRoute,
+  renderAgentsInstructions,
+  resolveRepositoryInstructions,
+  resolveTaskTitle,
+  resolveWorkspacePath,
+  retainRuntimeTurnContext,
+  sanitizeAssistantText,
+  saveTurnCheckpoint,
+  stripRuntimeTurnContext,
+  trimTrailingAssistantMessages,
+  truncateText
+} from "./chunk-EW2LNCRL.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -204,7 +198,7 @@ import {
   getSlackToolContext,
   readActorIdentity,
   resolveChannelCapabilities
-} from "./chunk-YHDERDRO.js";
+} from "./chunk-7BH46NB4.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -213,7 +207,7 @@ import {
   isConversationScopedChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-SGZO7UWH.js";
+} from "./chunk-SWHPVZBV.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -225,10 +219,10 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-YSB2N563.js";
+} from "./chunk-3GYZ5YEH.js";
 import {
   juniorIdentities
-} from "./chunk-DU74WPIC.js";
+} from "./chunk-3I2IVWSZ.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -240,7 +234,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-ORO3PWKQ.js";
+} from "./chunk-25SC7D6Z.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -273,7 +267,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-7NVJVJID.js";
+} from "./chunk-32CXPIZE.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -283,16 +277,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-RXBVB2JM.js";
+} from "./chunk-3KGQOKIG.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-YBVXBNSV.js";
+} from "./chunk-4JGM7FXO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JUUKWRBE.js";
+} from "./chunk-X22XXSZA.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -300,7 +294,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-GGB4WL5A.js";
+} from "./chunk-2JHKISQA.js";
 import {
   credentialUserSubjectId
 } from "./chunk-RUIXF3YQ.js";
@@ -330,7 +324,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-4LJO56OJ.js";
+} from "./chunk-RLVZIWNQ.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -1903,19 +1897,22 @@ function buildRuntimeSection(params) {
   return renderTagBlock("runtime", lines.join("\n"));
 }
 function formatSourceLines(source) {
-  if (source.platform === "local") {
-    return [
-      "- source.platform: local",
-      `- source.conversation_id: ${escapeXml(source.conversationId)}`
-    ];
+  switch (source.platform) {
+    case "web":
+    case "local":
+      return [
+        `- source.platform: ${source.platform}`,
+        `- source.conversation_id: ${escapeXml(source.conversationId)}`
+      ];
+    case "slack":
+      return [
+        "- source.platform: slack",
+        `- source.team_id: ${escapeXml(source.teamId)}`,
+        `- source.channel_id: ${escapeXml(source.channelId)}`,
+        ...source.messageTs ? [`- source.message_ts: ${escapeXml(source.messageTs)}`] : [],
+        ...source.threadTs ? [`- source.thread_ts: ${escapeXml(source.threadTs)}`] : []
+      ];
   }
-  return [
-    "- source.platform: slack",
-    `- source.team_id: ${escapeXml(source.teamId)}`,
-    `- source.channel_id: ${escapeXml(source.channelId)}`,
-    ...source.messageTs ? [`- source.message_ts: ${escapeXml(source.messageTs)}`] : [],
-    ...source.threadTs ? [`- source.thread_ts: ${escapeXml(source.threadTs)}`] : []
-  ];
 }
 function formatDestinationLines(destination) {
   if (destination.platform === "local") {
@@ -2059,7 +2056,8 @@ var STATIC_SYSTEM_PROMPTS = {
   slack: buildStaticSystemPrompt("slack")
 };
 function buildSystemPrompt(params) {
-  return STATIC_SYSTEM_PROMPTS[params.source.platform];
+  const platform = params.source.platform === "slack" ? "slack" : "local";
+  return STATIC_SYSTEM_PROMPTS[platform];
 }
 function buildTurnContextPrompt(params) {
   const includeSessionContext = params.includeSessionContext ?? true;
@@ -9638,94 +9636,382 @@ async function listThreadReplies(input) {
   }
   return replies.slice(0, targetLimit);
 }
-
-// src/chat/slack/timestamp-param.ts
-import { z as z35 } from "zod";
-function slackTimestampParam(description) {
-  return z35.preprocess(
-    (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z35.string().min(1)
-  ).describe(description);
-}
-function optionalSlackTimestampParam(description) {
-  return slackTimestampParam(description).optional();
-}
-function parseSlackTimestampParam(field, value) {
-  if (!value) {
-    return { ok: true, value: void 0 };
-  }
-  const timestamp = parseSlackMessageTs(String(value));
-  if (timestamp) {
-    return { ok: true, value: timestamp };
+async function getConversationInfo(channelId) {
+  const client = getSlackClient();
+  const response = await withSlackRetries(
+    () => client.conversations.info({
+      channel: channelId
+    }),
+    3,
+    { action: "conversations.info", idempotent: true }
+  );
+  const channel = response.channel;
+  if (!channel || typeof channel !== "object") {
+    throw new Error(`Slack conversations.info returned no channel for ${channelId}`);
   }
+  const record2 = channel;
   return {
-    ok: false,
-    error: `Invalid \`${field}\` Slack timestamp. Use a numeric Slack ts like \`1712345678.123456\`.`
+    id: channelId,
+    ...typeof record2.name === "string" && record2.name ? { name: record2.name } : {},
+    isChannel: record2.is_channel === true,
+    isPrivate: record2.is_private === true,
+    isIm: record2.is_im === true,
+    isMpim: record2.is_mpim === true,
+    ...typeof record2.is_member === "boolean" ? { isMember: record2.is_member } : {}
   };
 }
-function parseRequiredSlackTimestampParam(field, value) {
-  const timestamp = parseSlackMessageTs(String(value));
-  if (timestamp) {
-    return { ok: true, value: timestamp };
+async function joinPublicChannel(channelId) {
+  const client = getSlackClient();
+  await withSlackRetries(
+    () => client.conversations.join({
+      channel: channelId
+    }),
+    3,
+    { action: "conversations.join", idempotent: true }
+  );
+}
+async function listPublicChannels(input = {}) {
+  const client = getSlackClient();
+  const targetLimit = Math.max(1, Math.min(input.limit ?? 1e3, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 10, 20));
+  const channels = [];
+  let cursor;
+  let pages = 0;
+  while (channels.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - channels.length));
+    const response = await withSlackRetries(
+      () => client.conversations.list({
+        types: "public_channel",
+        exclude_archived: true,
+        limit: pageLimit,
+        cursor
+      }),
+      3,
+      { action: "conversations.list", idempotent: true }
+    );
+    const batch = response.channels ?? [];
+    for (const item of batch) {
+      if (typeof item.id !== "string" || !item.id) {
+        continue;
+      }
+      if (item.is_private === true) {
+        continue;
+      }
+      channels.push({
+        id: item.id,
+        ...typeof item.name === "string" && item.name ? { name: item.name } : {},
+        ...typeof item.is_member === "boolean" ? { isMember: item.is_member } : {},
+        ...typeof item.is_archived === "boolean" ? { isArchived: item.is_archived } : {}
+      });
+    }
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor) {
+      break;
+    }
   }
-  return {
-    ok: false,
-    error: `Invalid \`${field}\` Slack timestamp. Use a numeric Slack ts like \`1712345678.123456\`.`
-  };
+  return channels.slice(0, targetLimit);
 }
-
-// src/chat/slack/tools/channel-list-messages.ts
-import { z as z36 } from "zod";
-var booleanInput2 = (description) => z36.preprocess(
-  (value) => value === "true" ? true : value === "false" ? false : value,
-  z36.boolean()
-).describe(description);
-function normalizeRangeTimestamp(field, value, targetChannelId) {
-  if (value === void 0) {
-    return { ok: true, value: void 0 };
+async function resolvePublicChannelByName(channelName) {
+  const normalized = channelName.trim().replace(/^#/, "").toLowerCase();
+  if (!normalized) {
+    return void 0;
   }
-  const trimmed = String(value).trim();
-  if (!trimmed) {
-    return parseSlackTimestampParam(field, value);
+  const channels = await listPublicChannels();
+  return channels.find(
+    (channel) => channel.name?.trim().toLowerCase() === normalized
+  );
+}
+
+// src/chat/slack/tool-support/channel-access.ts
+var DENIED_PRIVATE = "Cannot read this Slack conversation because it is private. Only the current conversation or public channels are readable.";
+var DENIED_NOT_FOUND = "Cannot read this Slack conversation because the channel was not found or the bot cannot see it.";
+var DENIED_NOT_IN_CHANNEL = "Cannot read this Slack conversation because the bot is not in the channel.";
+var DENIED_MISSING_SCOPE = "Cannot verify Slack channel access because this installation is missing channel read scopes.";
+function deny(reason, error) {
+  return { allowed: false, reason, error };
+}
+async function checkSlackChannelReadAccess(args) {
+  const currentChannels = args.currentChannelIds.filter(
+    (channelId) => Boolean(channelId)
+  );
+  if (currentChannels.includes(args.targetChannelId)) {
+    return { allowed: true, isMember: true };
   }
-  const timestamp = parseSlackTimestampParam(field, trimmed);
-  if (timestamp.ok && timestamp.value) {
-    return timestamp;
+  const visibility = await getConversationStore().getDestinationVisibility({
+    provider: "slack",
+    providerTenantId: args.teamId,
+    providerDestinationId: args.targetChannelId
+  });
+  if (visibility === "private") {
+    return deny("private", DENIED_PRIVATE);
   }
-  const threadId = parseSlackThreadId(trimmed);
-  const threadTimestamp = threadId ? parseSlackTimestampParam(field, threadId.threadTs) : void 0;
-  if (threadId && threadTimestamp?.ok && threadTimestamp.value) {
-    if (threadId.channelId === targetChannelId) {
-      return threadTimestamp;
+  try {
+    const info = await getConversationInfo(args.targetChannelId);
+    const isPublicChannel = info.isChannel && !info.isPrivate && !info.isIm && !info.isMpim;
+    if (!isPublicChannel) {
+      return deny("private", DENIED_PRIVATE);
+    }
+    return {
+      allowed: true,
+      isPublic: true,
+      ...info.name ? { channelName: info.name } : {},
+      ...typeof info.isMember === "boolean" ? { isMember: info.isMember } : {}
+    };
+  } catch (error) {
+    if (error instanceof SlackActionError) {
+      if (error.code === "not_found") {
+        return deny("not_found", DENIED_NOT_FOUND);
+      }
+      if (error.code === "not_in_channel") {
+        return deny("not_in_channel", DENIED_NOT_IN_CHANNEL);
+      }
+      if (error.code === "missing_scope") {
+        return deny("missing_scope", DENIED_MISSING_SCOPE);
+      }
     }
+    throw error;
   }
-  return timestamp;
 }
-function createSlackChannelListMessagesTool(context) {
-  return zodTool({
-    description: "List channel messages from Slack history in the active channel context. Use when the user asks for recent or historical channel context outside this thread. Do not use for live monitoring or when current thread context already answers the question.",
-    annotations: {
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: true,
-      readOnlyHint: true
-    },
-    inputSchema: z36.object({
-      limit: z36.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z36.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
-      oldest: optionalSlackTimestampParam(
-        "Optional oldest message timestamp (Slack ts) for range filtering."
-      ),
-      latest: optionalSlackTimestampParam(
-        "Optional latest message timestamp (Slack ts) for range filtering."
-      ),
-      inclusive: booleanInput2(
-        "Whether oldest/latest bounds should be inclusive."
-      ).optional(),
-      max_pages: z36.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
-    }),
-    outputSchema: juniorToolOutputSchema,
+async function joinPublicChannelForRead(args) {
+  try {
+    await joinPublicChannel(args.targetChannelId);
+    return {
+      ok: true,
+      ...args.channelName ? { channelName: args.channelName } : {}
+    };
+  } catch (error) {
+    if (error instanceof SlackActionError) {
+      if (error.code === "missing_scope") {
+        return {
+          ok: false,
+          reason: "missing_scope",
+          error: "Cannot join this public Slack channel because this installation is missing the `channels:join` scope."
+        };
+      }
+      if (error.code === "not_found") {
+        return {
+          ok: false,
+          reason: "not_found",
+          error: DENIED_NOT_FOUND
+        };
+      }
+      if (error.apiError === "method_not_supported_for_channel_type" || error.apiError === "is_archived" || error.apiError === "cant_invite_self") {
+        return {
+          ok: false,
+          reason: "private",
+          error: DENIED_PRIVATE
+        };
+      }
+      return {
+        ok: false,
+        reason: "not_in_channel",
+        error: "Could not join this public Slack channel. Ask an admin to add the bot, then retry."
+      };
+    }
+    throw error;
+  }
+}
+
+// src/chat/slack/tool-support/channel-target.ts
+import { z as z35 } from "zod";
+var slackChannelRefParam = z35.string().trim().min(1).max(80).describe("Slack channel ID or public channel name.");
+async function resolveSlackChannelRef(input) {
+  const trimmed = input.value.trim();
+  if (!trimmed) {
+    throw new ToolInputError(
+      `Invalid \`${input.field}\`. Provide a Slack channel id like \`C123\` or a public channel name like \`#proj-foo\`.`
+    );
+  }
+  const channelId = parseSlackChannelId(trimmed);
+  if (channelId) {
+    return {
+      channelId,
+      resolvedFromName: false
+    };
+  }
+  const match = await resolvePublicChannelByName(trimmed);
+  if (!match) {
+    throw new ToolInputError(
+      `No public Slack channel named \`${trimmed}\` was found. Use an exact public channel name or a channel id.`
+    );
+  }
+  return {
+    channelId: match.id,
+    ...match.name ? { channelName: match.name } : {},
+    resolvedFromName: true
+  };
+}
+async function resolveOptionalSlackChannelRef(input) {
+  if (input.value !== void 0) {
+    return resolveSlackChannelRef({
+      field: input.field ?? "channel_id",
+      value: input.value
+    });
+  }
+  if (input.defaultChannelId) {
+    return {
+      channelId: input.defaultChannelId,
+      resolvedFromName: false
+    };
+  }
+  throw new ToolInputError(
+    "Provide `channel_id`, or use this tool in an active Slack channel context."
+  );
+}
+
+// src/chat/slack/tools/channel-join.ts
+import { z as z36 } from "zod";
+function createSlackChannelJoinTool(context) {
+  return zodTool({
+    description: "Join a public Slack channel.",
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    inputSchema: z36.object({
+      channel_id: slackChannelRefParam
+    }),
+    outputSchema: juniorToolOutputSchema,
+    execute: async ({ channel_id }) => {
+      const target = await resolveSlackChannelRef({
+        field: "channel_id",
+        value: channel_id
+      });
+      const access = await checkSlackChannelReadAccess({
+        currentChannelIds: [
+          context.destinationChannelId,
+          context.sourceChannelId
+        ],
+        targetChannelId: target.channelId,
+        teamId: context.teamId
+      });
+      if (!access.allowed) {
+        throw new ToolInputError(access.error);
+      }
+      if (access.isMember === true) {
+        return {
+          channel_id: target.channelId,
+          ...access.channelName || target.channelName ? { channel_name: access.channelName ?? target.channelName } : {},
+          joined: false,
+          already_member: true
+        };
+      }
+      try {
+        await joinPublicChannel(target.channelId);
+      } catch (error) {
+        if (error instanceof SlackActionError) {
+          if (error.code === "missing_scope") {
+            throw new ToolInputError(
+              "Cannot join this public Slack channel because this installation is missing the `channels:join` scope.",
+              { cause: error }
+            );
+          }
+          throw new ToolInputError(
+            "Could not join this public Slack channel. Confirm it is public and retry, or ask an admin to add the bot.",
+            { cause: error }
+          );
+        }
+        throw error;
+      }
+      return {
+        channel_id: target.channelId,
+        ...access.channelName || target.channelName ? { channel_name: access.channelName ?? target.channelName } : {},
+        joined: true,
+        already_member: false
+      };
+    }
+  });
+}
+
+// src/chat/slack/timestamp-param.ts
+import { z as z37 } from "zod";
+function slackTimestampParam(description) {
+  return z37.preprocess(
+    (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
+    z37.string().min(1)
+  ).describe(description);
+}
+function parseSlackTimestampParam(field, value) {
+  if (!value) {
+    return { ok: true, value: void 0 };
+  }
+  const timestamp = parseSlackMessageTs(String(value));
+  if (timestamp) {
+    return { ok: true, value: timestamp };
+  }
+  return {
+    ok: false,
+    error: `Invalid \`${field}\` Slack timestamp. Use a numeric Slack ts like \`1712345678.123456\`.`
+  };
+}
+function parseRequiredSlackTimestampParam(field, value) {
+  const timestamp = parseSlackMessageTs(String(value));
+  if (timestamp) {
+    return { ok: true, value: timestamp };
+  }
+  return {
+    ok: false,
+    error: `Invalid \`${field}\` Slack timestamp. Use a numeric Slack ts like \`1712345678.123456\`.`
+  };
+}
+
+// src/chat/slack/tools/channel-list-messages.ts
+import { z as z38 } from "zod";
+var booleanInput2 = (description) => z38.preprocess(
+  (value) => value === "true" ? true : value === "false" ? false : value,
+  z38.boolean()
+).describe(description);
+function normalizeRangeTimestamp(field, value, targetChannelId) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  const trimmed = String(value).trim();
+  if (!trimmed) {
+    return parseSlackTimestampParam(field, value);
+  }
+  const timestamp = parseSlackTimestampParam(field, trimmed);
+  if (timestamp.ok && timestamp.value) {
+    return timestamp;
+  }
+  const threadId = parseSlackThreadId(trimmed);
+  const threadTimestamp = threadId ? parseSlackTimestampParam(field, threadId.threadTs) : void 0;
+  if (threadId && threadTimestamp?.ok && threadTimestamp.value) {
+    if (threadId.channelId === targetChannelId) {
+      return threadTimestamp;
+    }
+  }
+  return timestamp;
+}
+function createSlackChannelListMessagesTool(context) {
+  return zodTool({
+    description: "List messages from Slack channel history. Defaults to the active channel. Pass `channel_id` to read another public channel.",
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    inputSchema: z38.object({
+      channel_id: slackChannelRefParam.optional(),
+      limit: z38.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z38.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+      oldest: slackTimestampParam(
+        "Oldest message timestamp (Slack ts) for range filtering."
+      ).optional(),
+      latest: slackTimestampParam(
+        "Latest message timestamp (Slack ts) for range filtering."
+      ).optional(),
+      inclusive: booleanInput2(
+        "Whether oldest/latest bounds should be inclusive."
+      ).optional(),
+      max_pages: z38.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+    }),
+    outputSchema: juniorToolOutputSchema,
     execute: async ({
+      channel_id,
       limit,
       cursor,
       oldest,
@@ -9733,9 +10019,22 @@ function createSlackChannelListMessagesTool(context) {
       inclusive,
       max_pages
     }) => {
-      const targetChannelId = context.destinationChannelId;
-      if (!targetChannelId) {
-        throw new ToolInputError("No active Slack destination is available.");
+      const target = await resolveOptionalSlackChannelRef({
+        field: "channel_id",
+        value: channel_id,
+        defaultChannelId: context.destinationChannelId
+      });
+      const targetChannelId = target.channelId;
+      const access = await checkSlackChannelReadAccess({
+        currentChannelIds: [
+          context.destinationChannelId,
+          context.sourceChannelId
+        ],
+        targetChannelId,
+        teamId: context.teamId
+      });
+      if (!access.allowed) {
+        throw new ToolInputError(access.error);
       }
       const normalizedOldest = normalizeRangeTimestamp(
         "oldest",
@@ -9753,39 +10052,84 @@ function createSlackChannelListMessagesTool(context) {
       if (!normalizedLatest.ok) {
         throw new ToolInputError(normalizedLatest.error);
       }
+      const readHistory = async () => listChannelMessages({
+        channelId: targetChannelId,
+        limit: limit ?? 100,
+        cursor,
+        oldest: normalizedOldest.value,
+        latest: normalizedLatest.value,
+        inclusive,
+        maxPages: max_pages
+      });
       let result;
+      let joined = false;
+      let channelName = access.channelName ?? target.channelName;
+      let readError;
       try {
-        result = await listChannelMessages({
-          channelId: targetChannelId,
-          limit: limit ?? 100,
-          cursor,
-          oldest: normalizedOldest.value,
-          latest: normalizedLatest.value,
-          inclusive,
-          maxPages: max_pages
-        });
+        result = await readHistory();
       } catch (error) {
+        readError = error;
+        const canJoin = error instanceof SlackActionError && error.code === "not_in_channel" && access.isMember !== true;
+        if (canJoin) {
+          const joinResult = await joinPublicChannelForRead({
+            channelName,
+            targetChannelId
+          });
+          if (!joinResult.ok) {
+            throw new ToolInputError(joinResult.error);
+          }
+          joined = true;
+          channelName = joinResult.channelName ?? channelName;
+          try {
+            result = await readHistory();
+            readError = void 0;
+          } catch (retryError) {
+            readError = retryError;
+          }
+        }
+      }
+      if (!result) {
+        const error = readError;
         if (error instanceof SlackActionError && error.apiError === "invalid_cursor") {
           throw new ToolInputError(
             "The supplied Slack history cursor is no longer valid. Retry the lookup without `cursor` to start from the newest page again.",
             { cause: error }
           );
         }
+        if (error instanceof SlackActionError) {
+          if (error.code === "not_in_channel") {
+            throw new ToolInputError(
+              "Could not read this Slack channel history because the bot is not in the channel.",
+              { cause: error }
+            );
+          }
+          if (error.code === "missing_scope") {
+            throw new ToolInputError(
+              "Could not read this Slack channel history because this installation is missing history scopes.",
+              { cause: error }
+            );
+          }
+          throw new ToolInputError(
+            "Could not read this Slack channel history.",
+            { cause: error }
+          );
+        }
         throw error;
       }
-      const summary = {
+      return {
         channel_id: targetChannelId,
+        ...channelName ? { channel_name: channelName } : {},
+        ...joined ? { joined_channel: true } : {},
         count: result.messages.length,
         messages: result.messages,
         ...result.nextCursor ? { next_cursor: result.nextCursor } : {}
       };
-      return summary;
     }
   });
 }
 
 // src/chat/slack/tools/conversation-message-search.ts
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 
 // src/chat/conversations/tool-source.ts
 var CONVERSATIONS_TOOL_SOURCE = {
@@ -9796,35 +10140,32 @@ var CONVERSATIONS_TOOL_SOURCE = {
 // src/chat/slack/tools/conversation-message-search.ts
 var DEFAULT_LIMIT = 5;
 var conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
-  channel_id: z37.string().min(1).optional(),
-  count: z37.number().int().nonnegative(),
-  query: z37.string().optional(),
-  matches: z37.array(
-    z37.object({
-      channel_id: z37.string().min(1),
-      channel_name: z37.string().min(1).optional(),
-      conversation_id: z37.string().min(1),
-      excerpt: z37.string(),
-      message_id: z37.string().min(1),
-      message_role: z37.enum(["assistant", "user"]),
-      message_timestamp: z37.string().datetime(),
-      permalink: z37.string().url().optional(),
-      thread_ts: z37.string().min(1)
+  channel_id: z39.string().min(1).optional(),
+  count: z39.number().int().nonnegative(),
+  query: z39.string().optional(),
+  matches: z39.array(
+    z39.object({
+      channel_id: z39.string().min(1),
+      channel_name: z39.string().min(1).optional(),
+      conversation_id: z39.string().min(1),
+      excerpt: z39.string(),
+      message_id: z39.string().min(1),
+      message_role: z39.enum(["assistant", "user"]),
+      message_timestamp: z39.string().datetime(),
+      permalink: z39.string().url().optional(),
+      thread_ts: z39.string().min(1)
     }).strict()
   )
 });
-function resolveSearchFilters(input) {
+async function resolveSearchFilters(input) {
   const query = input.query?.trim() || void 0;
   let channelId;
-  if (input.channel_id != null) {
-    const parsed = parseRequiredSlackChannelIdParam(
-      "channel_id",
-      input.channel_id
-    );
-    if (!parsed.ok) {
-      throw new ToolInputError(parsed.error);
-    }
-    channelId = parsed.value;
+  if (input.channel_id != null && input.channel_id.trim() !== "") {
+    const target = await resolveSlackChannelRef({
+      field: "channel_id",
+      value: input.channel_id
+    });
+    channelId = target.channelId;
   }
   if (!query && !channelId) {
     throw new ToolInputError(
@@ -9836,9 +10177,9 @@ function resolveSearchFilters(input) {
     ...query ? { query } : {}
   };
 }
-function createSlackConversationMessageSearchTool(scope, currentConversationId, deps = {}) {
+function createSlackConversationMessageSearchTool(scope, currentConversationId) {
   return zodTool({
-    description: "Search retained user and assistant messages in public Junior conversations across the current Slack workspace. Excludes the current conversation.",
+    description: "Search retained user and assistant messages from public conversations in this Slack workspace. Excludes the current conversation. Not live Slack workspace search.",
     exposure: "deferred",
     source: CONVERSATIONS_TOOL_SOURCE,
     annotations: {
@@ -9847,24 +10188,21 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId,
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z37.object({
-      channel_id: slackChannelIdParam(
-        "Destination Slack channel ID; no active-channel default."
-      ).nullable().optional(),
-      query: z37.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
-      limit: z37.number().int().min(1).max(10).describe(`Maximum matches. Default ${DEFAULT_LIMIT}; max 10.`).nullable().optional()
+    inputSchema: z39.object({
+      channel_id: slackChannelRefParam.nullable().optional(),
+      query: z39.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
+      limit: z39.number().int().min(1).max(10).describe(`Maximum matches. Default ${DEFAULT_LIMIT}; max 10.`).nullable().optional()
     }).strict(),
     outputSchema: conversationMessageSearchOutputSchema,
     execute: async (input) => {
-      const filters = resolveSearchFilters(input);
-      const store = deps.store ?? getConversationMessageSearchStore();
+      const filters = await resolveSearchFilters(input);
+      const store = getConversationMessageSearchStore();
       const matches = await store.search({
         currentConversationId,
         filters,
         limit: input.limit ?? DEFAULT_LIMIT,
         scope
       });
-      const getPermalink = deps.getPermalink ?? getSlackMessagePermalink;
       const matchesOutput = await Promise.all(
         matches.map(async (match) => {
           const reference = parseSlackThreadId(match.conversationId);
@@ -9873,7 +10211,7 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId,
               "Stored Slack conversation search returned an invalid destination"
             );
           }
-          const permalink = await getPermalink({
+          const permalink = await getSlackMessagePermalink({
             channelId: reference.channelId,
             messageTs: reference.threadTs
           });
@@ -9901,35 +10239,238 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId,
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z38.preprocess(
-  (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z38.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
-);
-var searchMessageSchema = z38.object({
-  author_name: z38.string().optional(),
-  author_user_id: z38.string().optional(),
-  channel_id: z38.string().min(1),
-  channel_name: z38.string().optional(),
-  message_ts: z38.string().min(1),
-  content: z38.string(),
-  is_author_bot: z38.boolean().optional(),
-  permalink: z38.string().url()
+var DEFAULT_CONTENT_TYPES = ["messages"];
+var CONTENT_TYPES = ["messages", "files", "channels", "users"];
+var unixTimestampParam = z40.coerce.number().int().nonnegative();
+function optionalUnixTimestampParam(description) {
+  return z40.preprocess(
+    (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
+    unixTimestampParam.optional()
+  ).describe(description);
+}
+function normalizeOptionalUnixTimestamp(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  return unixTimestampParam.parse(value);
+}
+var searchMessageSchema = z40.object({
+  author_name: z40.string().min(1).optional().describe("Author display name."),
+  author_user_id: z40.string().min(1).optional().describe("Author user ID."),
+  channel_id: z40.string().min(1).describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  message_ts: z40.string().min(1).describe("Message timestamp."),
+  content: z40.string().describe("Message text."),
+  is_author_bot: z40.boolean().optional().describe("Whether the author is a bot."),
+  permalink: z40.string().url().describe("Message permalink.")
+});
+var searchFileSchema = z40.object({
+  file_id: z40.string().min(1).describe("File ID."),
+  title: z40.string().min(1).optional().describe("File title."),
+  name: z40.string().min(1).optional().describe("File name."),
+  filetype: z40.string().min(1).optional().describe("File type."),
+  user_id: z40.string().min(1).optional().describe("Uploader user ID."),
+  user_name: z40.string().min(1).optional().describe("Uploader user name."),
+  channel_id: z40.string().min(1).optional().describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  permalink: z40.string().url().optional().describe("File permalink."),
+  content: z40.string().min(1).optional().describe("File preview or content snippet.")
+});
+var searchChannelSchema = z40.object({
+  channel_id: z40.string().min(1).describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  is_private: z40.boolean().optional().describe("Whether the channel is private."),
+  is_member: z40.boolean().optional().describe("Whether the bot is a member."),
+  topic: z40.string().min(1).optional().describe("Channel topic."),
+  purpose: z40.string().min(1).optional().describe("Channel purpose."),
+  permalink: z40.string().url().optional().describe("Channel permalink.")
+});
+var searchUserSchema = z40.object({
+  user_id: z40.string().min(1).describe("User ID."),
+  user_name: z40.string().min(1).optional().describe("Username."),
+  real_name: z40.string().min(1).optional().describe("Real name."),
+  display_name: z40.string().min(1).optional().describe("Display name."),
+  title: z40.string().min(1).optional().describe("Profile title."),
+  permalink: z40.string().url().optional().describe("Profile permalink.")
 });
 var publicSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z38.string(),
-  count: z38.number().int().nonnegative(),
-  messages: z38.array(searchMessageSchema),
-  next_cursor: z38.string().optional()
+  query: z40.string().describe("Search query."),
+  content_types: z40.array(z40.enum(CONTENT_TYPES)).describe("Content types included in the search."),
+  count: z40.number().int().nonnegative().describe("Total matched results."),
+  messages: z40.array(searchMessageSchema).describe("Matched messages."),
+  files: z40.array(searchFileSchema).describe("Matched files."),
+  channels: z40.array(searchChannelSchema).describe("Matched channels."),
+  users: z40.array(searchUserSchema).describe("Matched users."),
+  next_cursor: z40.string().min(1).optional().describe("Cursor for the next result page.")
 });
-function normalizeMessage(value) {
-  const parsed = searchMessageSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
+var nonEmptyString = z40.string().trim().min(1);
+var optionalWireString = z40.preprocess((value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}, nonEmptyString.optional());
+var optionalWireUrl = z40.preprocess((value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    new URL(trimmed);
+    return trimmed;
+  } catch {
+    return void 0;
+  }
+}, z40.string().url().optional());
+var optionalWireBoolean = z40.preprocess(
+  (value) => typeof value === "boolean" ? value : void 0,
+  z40.boolean().optional()
+);
+var slackSearchMessageWireSchema = z40.object({
+  author_name: optionalWireString,
+  author_user_id: optionalWireString,
+  channel_id: nonEmptyString,
+  channel_name: optionalWireString,
+  message_ts: nonEmptyString,
+  content: z40.string(),
+  is_author_bot: optionalWireBoolean,
+  permalink: z40.string().url()
+}).transform(
+  (value) => ({
+    channel_id: value.channel_id,
+    message_ts: value.message_ts,
+    content: value.content,
+    permalink: value.permalink,
+    ...value.author_name ? { author_name: value.author_name } : {},
+    ...value.author_user_id ? { author_user_id: value.author_user_id } : {},
+    ...value.channel_name ? { channel_name: value.channel_name } : {},
+    ...value.is_author_bot !== void 0 ? { is_author_bot: value.is_author_bot } : {}
+  })
+);
+var slackSearchFileWireSchema = z40.object({
+  id: optionalWireString,
+  file_id: optionalWireString,
+  title: optionalWireString,
+  name: optionalWireString,
+  filetype: optionalWireString,
+  file_type: optionalWireString,
+  user: optionalWireString,
+  user_id: optionalWireString,
+  username: optionalWireString,
+  user_name: optionalWireString,
+  channel_id: optionalWireString,
+  channel_name: optionalWireString,
+  permalink: optionalWireUrl,
+  content: optionalWireString,
+  preview: optionalWireString
+}).transform((value) => {
+  const fileId = value.file_id ?? value.id;
+  if (!fileId) {
+    return void 0;
+  }
+  return {
+    file_id: fileId,
+    ...value.title ? { title: value.title } : {},
+    ...value.name ? { name: value.name } : {},
+    ...value.filetype ?? value.file_type ? { filetype: value.filetype ?? value.file_type } : {},
+    ...value.user_id ?? value.user ? { user_id: value.user_id ?? value.user } : {},
+    ...value.user_name ?? value.username ? { user_name: value.user_name ?? value.username } : {},
+    ...value.channel_id ? { channel_id: value.channel_id } : {},
+    ...value.channel_name ? { channel_name: value.channel_name } : {},
+    ...value.permalink ? { permalink: value.permalink } : {},
+    ...value.content ?? value.preview ? { content: value.content ?? value.preview } : {}
+  };
+});
+var slackSearchChannelWireSchema = z40.object({
+  id: optionalWireString,
+  channel_id: optionalWireString,
+  name: optionalWireString,
+  channel_name: optionalWireString,
+  is_private: optionalWireBoolean,
+  is_member: optionalWireBoolean,
+  topic: optionalWireString,
+  purpose: optionalWireString,
+  permalink: optionalWireUrl
+}).transform((value) => {
+  const channelId = value.channel_id ?? value.id;
+  if (!channelId) {
+    return void 0;
+  }
+  return {
+    channel_id: channelId,
+    ...value.channel_name ?? value.name ? { channel_name: value.channel_name ?? value.name } : {},
+    ...value.is_private !== void 0 ? { is_private: value.is_private } : {},
+    ...value.is_member !== void 0 ? { is_member: value.is_member } : {},
+    ...value.topic ? { topic: value.topic } : {},
+    ...value.purpose ? { purpose: value.purpose } : {},
+    ...value.permalink ? { permalink: value.permalink } : {}
+  };
+});
+var slackSearchUserWireSchema = z40.object({
+  id: optionalWireString,
+  user_id: optionalWireString,
+  name: optionalWireString,
+  username: optionalWireString,
+  user_name: optionalWireString,
+  real_name: optionalWireString,
+  display_name: optionalWireString,
+  title: optionalWireString,
+  permalink: optionalWireUrl
+}).transform((value) => {
+  const userId = value.user_id ?? value.id;
+  if (!userId) {
+    return void 0;
+  }
+  return {
+    user_id: userId,
+    ...value.user_name ?? value.name ?? value.username ? { user_name: value.user_name ?? value.name ?? value.username } : {},
+    ...value.real_name ? { real_name: value.real_name } : {},
+    ...value.display_name ? { display_name: value.display_name } : {},
+    ...value.title ? { title: value.title } : {},
+    ...value.permalink ? { permalink: value.permalink } : {}
+  };
+});
+var slackSearchResponseSchema = z40.object({
+  results: z40.object({
+    messages: z40.array(z40.unknown()).default([]),
+    files: z40.array(z40.unknown()).default([]),
+    channels: z40.array(z40.unknown()).default([]),
+    users: z40.array(z40.unknown()).default([]),
+    // Slack often returns "" on the final page; omit rather than fail the parse.
+    next_cursor: optionalWireString
+  }).default({
+    messages: [],
+    files: [],
+    channels: [],
+    users: []
+  })
+});
+function parseItems(values, schema) {
+  const items = [];
+  for (const value of values) {
+    const parsed = schema.safeParse(value);
+    if (parsed.success && parsed.data !== void 0) {
+      items.push(parsed.data);
+    }
+  }
+  return items;
 }
 function explicitSearchError(error) {
   if (error.code === "missing_scope") {
-    return "Public Slack search is unavailable because this installation is missing the `search:read.public` scope.";
+    const needed = error.needed?.trim();
+    if (needed) {
+      return `Public Slack search is unavailable because this installation is missing the \`${needed}\` scope.`;
+    }
+    return "Public Slack search is unavailable because this installation is missing a required search scope (`search:read.public`, and `search:read.files` / `search:read.users` when those content types are requested).";
   }
   if (error.code === "feature_unavailable") {
     return "Public Slack search is not available for this Slack workspace or app installation.";
@@ -9939,33 +10480,33 @@ function explicitSearchError(error) {
   }
   return void 0;
 }
+function normalizeContentTypes(contentTypes) {
+  const selected = contentTypes?.length ? contentTypes : [...DEFAULT_CONTENT_TYPES];
+  return [...new Set(selected)];
+}
 function createSlackPublicSearchTool(actionToken) {
   return zodTool({
-    description: "Search public Slack channel messages across the current workspace. Use when the user asks about company activity, announcements, public mentions, or context outside the active channel. Search only when requested or clearly needed, prefer focused keywords and time bounds, and cite returned permalinks. This never searches private channels or DMs.",
+    description: "Search live public Slack content across the workspace. Defaults to messages; optionally include files, channels, or users. Private channels and DMs are never searched.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z38.object({
-      query: z38.string().trim().min(1).max(500).describe(
-        "A focused Slack search query, including Slack search filters when useful."
-      ),
-      after: optionalTimestampSchema.describe(
-        "Optional Unix timestamp lower bound."
-      ),
-      before: optionalTimestampSchema.describe(
-        "Optional Unix timestamp upper bound."
-      ),
-      cursor: z38.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z38.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z38.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z38.enum(["asc", "desc"]).describe("Sort direction.").optional()
+    inputSchema: z40.object({
+      query: z40.string().trim().min(1).max(500).describe("Slack search query."),
+      content_types: z40.array(z40.enum(CONTENT_TYPES)).min(1).max(4).describe("Content types to include. Defaults to messages.").optional(),
+      after: optionalUnixTimestampParam("Unix timestamp lower bound."),
+      before: optionalUnixTimestampParam("Unix timestamp upper bound."),
+      cursor: z40.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z40.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z40.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z40.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
       query,
+      content_types,
       after,
       before,
       cursor,
@@ -9973,36 +10514,63 @@ function createSlackPublicSearchTool(actionToken) {
       sort,
       sort_dir
     }) => {
+      if (!actionToken) {
+        throw new ToolInputError(
+          "Public Slack search needs a fresh interactive mention or DM. Slack only issues the short-lived action token on those turns, so resumes and scheduled runs cannot search the workspace. Ask again in a new message, or use channel history / thread read when you already know the channel."
+        );
+      }
       try {
-        const normalizedAfter = optionalTimestampSchema.parse(after);
-        const normalizedBefore = optionalTimestampSchema.parse(before);
-        const response = await withSlackRetries(
-          () => getSlackClient().apiCall("assistant.search.context", {
-            action_token: actionToken,
-            query,
-            channel_types: ["public_channel"],
-            content_types: ["messages"],
-            include_bots: true,
-            limit: limit ?? DEFAULT_LIMIT2,
-            ...normalizedAfter !== void 0 ? { after: normalizedAfter } : {},
-            ...normalizedBefore !== void 0 ? { before: normalizedBefore } : {},
-            ...cursor ? { cursor } : {},
-            ...sort ? { sort } : {},
-            ...sort_dir ? { sort_dir } : {}
-          }),
-          3,
-          {
-            action: "assistant.search.context",
-            idempotent: true
-          }
+        const normalizedContentTypes = normalizeContentTypes(content_types);
+        const normalizedAfter = normalizeOptionalUnixTimestamp(after);
+        const normalizedBefore = normalizeOptionalUnixTimestamp(before);
+        const response = slackSearchResponseSchema.parse(
+          await withSlackRetries(
+            () => getSlackClient().apiCall("assistant.search.context", {
+              action_token: actionToken,
+              query,
+              channel_types: ["public_channel"],
+              content_types: normalizedContentTypes,
+              include_bots: true,
+              limit: limit ?? DEFAULT_LIMIT2,
+              ...normalizedAfter !== void 0 ? { after: normalizedAfter } : {},
+              ...normalizedBefore !== void 0 ? { before: normalizedBefore } : {},
+              ...cursor ? { cursor } : {},
+              ...sort ? { sort } : {},
+              ...sort_dir ? { sort_dir } : {}
+            }),
+            3,
+            {
+              action: "assistant.search.context",
+              idempotent: true
+            }
+          )
+        );
+        const messages = parseItems(
+          response.results.messages,
+          slackSearchMessageWireSchema
+        );
+        const files = parseItems(
+          response.results.files,
+          slackSearchFileWireSchema
         );
-        const messages = (response.results?.messages ?? []).map(normalizeMessage).filter((message) => Boolean(message));
-        const nextCursor = response.results?.next_cursor;
+        const channels = parseItems(
+          response.results.channels,
+          slackSearchChannelWireSchema
+        );
+        const users = parseItems(
+          response.results.users,
+          slackSearchUserWireSchema
+        );
+        const count = messages.length + files.length + channels.length + users.length;
         return {
           query,
-          count: messages.length,
+          content_types: normalizedContentTypes,
+          count,
           messages,
-          ...typeof nextCursor === "string" && nextCursor ? { next_cursor: nextCursor } : {}
+          files,
+          channels,
+          users,
+          ...response.results.next_cursor ? { next_cursor: response.results.next_cursor } : {}
         };
       } catch (error) {
         if (error instanceof SlackActionError) {
@@ -10018,7 +10586,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -10048,9 +10616,9 @@ function createSlackMessageAddReactionTool(context, state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Add an emoji reaction to the current inbound Slack message. Use for explicit reaction requests and for non-text acknowledgements on the current message when no thread reply is needed. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: z39.object({
-      emoji: z39.string().min(1).max(64).describe(
+    description: "Add an emoji reaction to the current inbound Slack message.",
+    inputSchema: z41.object({
+      emoji: z41.string().min(1).max(64).describe(
         "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
       )
     }),
@@ -10099,14 +10667,14 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash4 } from "crypto";
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  target: z40.string().min(1),
-  channel_id: z40.string().min(1),
-  deduplicated: z40.boolean().optional(),
-  file_count: z40.number().int().nonnegative(),
-  file_ids: z40.array(z40.string().min(1)).optional(),
-  thread_ts: z40.string().min(1)
+  target: z42.string().min(1),
+  channel_id: z42.string().min(1),
+  deduplicated: z42.boolean().optional(),
+  file_count: z42.number().int().nonnegative(),
+  file_ids: z42.array(z42.string().min(1)).optional(),
+  thread_ts: z42.string().min(1)
 });
 function normalizeFiles(files) {
   return files.map((file) => ({
@@ -10135,9 +10703,9 @@ function createSendFilesTool(context, state, materializeFile) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Send one or more sandbox files into the active Slack conversation. Use when the user asks to attach, send, or share files here, in this conversation, or in this thread. Do not use for ordinary assistant text, top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
-    inputSchema: z40.object({
-      files: z40.array(sandboxFileReferenceSchema).min(1).describe(
+    description: "Send one or more sandbox files into the active Slack conversation.",
+    inputSchema: z42.object({
+      files: z42.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -10223,7 +10791,7 @@ function extractCanvasId(input) {
   }
 }
 
-// src/chat/slack/tools/canvas/markdown.ts
+// src/chat/slack/tool-support/canvas/markdown.ts
 function getListType(marker) {
   return /^\d/.test(marker) ? "numbered" : "bullet";
 }
@@ -10372,7 +10940,7 @@ function normalizeCanvasMarkdown(markdown) {
   };
 }
 
-// src/chat/slack/tools/canvas/api.ts
+// src/chat/slack/tool-support/canvas/api.ts
 async function createCanvas(input) {
   const client = getSlackClient();
   const normalizedChannelId = normalizeSlackConversationId(input.channelId);
@@ -10530,7 +11098,7 @@ async function readCanvas(canvasIdOrUrl) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -10539,10 +11107,10 @@ function createSlackCanvasCreateTool(context, state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
-    inputSchema: z41.object({
-      title: z41.string().min(1).max(160).describe("Canvas title."),
-      markdown: z41.string().min(1).describe("Canvas markdown body content.")
+    description: "Create a Slack canvas in the active channel.",
+    inputSchema: z43.object({
+      title: z43.string().min(1).max(160).describe("Canvas title."),
+      markdown: z43.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ title, markdown }) => {
@@ -10585,7 +11153,9 @@ function createSlackCanvasCreateTool(context, state) {
   });
 }
 
-// src/chat/slack/tools/canvas/context.ts
+// src/chat/slack/tool-support/canvas/context.ts
+import { z as z44 } from "zod";
+var slackCanvasRefParam = z44.string().min(1).describe("Slack canvas/file ID or canvas/docs URL.");
 function resolveCanvasTarget(canvas) {
   const canvasId = extractCanvasId(canvas);
   if (!canvasId) {
@@ -10598,26 +11168,26 @@ function resolveCanvasTarget(canvas) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z42 } from "zod";
+import { z as z45 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z42.object({
-  oldText: z42.string().min(1).describe(
+var editReplacementSchema2 = z45.object({
+  oldText: z45.string().min(1).describe(
     "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
   ),
-  newText: z42.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z45.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z42.string().optional(),
-  title: z42.string().optional(),
-  permalink: z42.string().optional(),
-  diff: z42.string().optional(),
-  first_changed_line: z42.number().int().positive().optional(),
-  replacements: z42.number().int().nonnegative().optional(),
-  normalized_heading_count: z42.number().int().nonnegative().optional(),
-  summary: z42.string().optional(),
-  deduplicated: z42.boolean().optional()
+  canvas_id: z45.string().optional(),
+  title: z45.string().optional(),
+  permalink: z45.string().optional(),
+  diff: z45.string().optional(),
+  first_changed_line: z45.number().int().positive().optional(),
+  replacements: z45.number().int().nonnegative().optional(),
+  normalized_heading_count: z45.number().int().nonnegative().optional(),
+  summary: z45.string().optional(),
+  deduplicated: z45.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -10627,12 +11197,12 @@ function createSlackCanvasEditTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content; prefer this over slackCanvasWrite for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same canvas: use one edits[] call.",
+    description: "Edit a Slack canvas with exact markdown replacements. Returns a diff.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z42.object({
-      canvas: z42.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z42.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z45.object({
+      canvas: slackCanvasRefParam,
+      edits: z45.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -10685,34 +11255,32 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z43 } from "zod";
+import { z as z46 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z43.string().optional(),
-  title: z43.string().optional(),
-  permalink: z43.string().optional(),
-  mimetype: z43.string().optional(),
-  filetype: z43.string().optional(),
-  original_byte_length: z43.number().int().nonnegative().optional(),
-  content: z43.string().optional(),
-  start_line: z43.number().int().positive().optional(),
-  end_line: z43.number().int().nonnegative().optional(),
-  total_lines: z43.number().int().nonnegative().optional()
+  canvas_id: z46.string().optional(),
+  title: z46.string().optional(),
+  permalink: z46.string().optional(),
+  mimetype: z46.string().optional(),
+  filetype: z46.string().optional(),
+  original_byte_length: z46.number().int().nonnegative().optional(),
+  content: z46.string().optional(),
+  start_line: z46.number().int().positive().optional(),
+  end_line: z46.number().int().nonnegative().optional(),
+  total_lines: z46.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
-    description: "Read a bounded line range from a Slack canvas as markdown. Use when you need exact Canvas contents to verify facts or make edits safely. Do not use for generic web pages \u2014 use webFetch for those.",
+    description: "Read a bounded line range from a Slack canvas as markdown.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z43.object({
-      canvas: z43.string().min(1).describe(
-        "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
-      ),
-      offset: z43.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z43.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+    inputSchema: z46.object({
+      canvas: slackCanvasRefParam,
+      offset: z46.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z46.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -10748,7 +11316,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z44 } from "zod";
+import { z as z47 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -10757,11 +11325,11 @@ function createSlackCanvasWriteTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation; use slackCanvasEdit for targeted changes to existing canvas content.",
+    description: "Replace the full markdown body of a Slack canvas.",
     executionMode: "sequential",
-    inputSchema: z44.object({
-      canvas: z44.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z44.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z47.object({
+      canvas: slackCanvasRefParam,
+      content: z47.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ canvas, content }) => {
@@ -10795,7 +11363,7 @@ function createSlackCanvasWriteTool(state) {
   });
 }
 
-// src/chat/slack/tools/list/api.ts
+// src/chat/slack/tool-support/list/api.ts
 function normalizeKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "_");
 }
@@ -10982,8 +11550,13 @@ async function updateListItem(input) {
   );
 }
 
+// src/chat/slack/tool-support/list/params.ts
+import { z as z48 } from "zod";
+var slackListIdParam = z48.string().min(1).describe("Slack list ID.");
+var slackListItemIdParam = z48.string().min(1).describe("Slack list item ID.");
+
 // src/chat/slack/tools/list/add-items.ts
-import { z as z45 } from "zod";
+import { z as z49 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -10992,14 +11565,14 @@ function createSlackListAddItemsTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Add tasks to a Slack list. Use the list_id from the list create result or conversation history.",
-    inputSchema: z45.object({
-      list_id: z45.string().min(1).describe("ID of the Slack list to update."),
-      items: z45.array(z45.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    description: "Add tasks to a Slack list.",
+    inputSchema: z49.object({
+      list_id: slackListIdParam,
+      items: z49.array(z49.string().min(1)).min(1).max(25).describe("List item titles to create."),
       assignee_user_id: slackUserIdParam(
         "Optional Slack user ID assigned to all created items."
       ).optional(),
-      due_date: z45.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z49.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, items, assignee_user_id, due_date }) => {
@@ -11038,7 +11611,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z46 } from "zod";
+import { z as z50 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -11047,9 +11620,9 @@ function createSlackListCreateTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: z46.object({
-      name: z46.string().min(1).max(160).describe("Name for the new Slack list.")
+    description: "Create a Slack todo list.",
+    inputSchema: z50.object({
+      name: z50.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ name }) => {
@@ -11074,19 +11647,19 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z47 } from "zod";
+import { z as z51 } from "zod";
 function createSlackListGetItemsTool() {
   return zodTool({
-    description: "Read items from a Slack list. Use the list_id from a prior tool result or conversation history.",
+    description: "Read items from a Slack list.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z47.object({
-      list_id: z47.string().min(1).describe("ID of the Slack list to read."),
-      limit: z47.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z51.object({
+      list_id: slackListIdParam,
+      limit: z51.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, limit }) => {
@@ -11101,23 +11674,23 @@ function createSlackListGetItemsTool() {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z48 } from "zod";
-var booleanInput3 = (description) => z48.preprocess(
+import { z as z52 } from "zod";
+var booleanInput3 = (description) => z52.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z48.boolean()
+  z52.boolean()
 ).describe(description);
-var updateListItemInputSchema = z48.union([
-  z48.object({
-    list_id: z48.string().min(1).describe("ID of the Slack list to update."),
-    item_id: z48.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z52.union([
+  z52.object({
+    list_id: slackListIdParam,
+    item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update."),
-    title: z48.string().min(1).describe("Optional new item title.").optional()
+    title: z52.string().min(1).describe("Optional new item title.").optional()
   }),
-  z48.object({
-    list_id: z48.string().min(1).describe("ID of the Slack list to update."),
-    item_id: z48.string().min(1).describe("ID of the Slack list item to update."),
+  z52.object({
+    list_id: slackListIdParam,
+    item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z48.string().min(1).describe("Optional new item title.")
+    title: z52.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -11128,7 +11701,7 @@ function createSlackListUpdateItemTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Update an item in a Slack list. Use list_id and item_id from prior tool results or conversation history.",
+    description: "Update an item in a Slack list.",
     inputSchema: updateListItemInputSchema,
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, item_id, completed, title }) => {
@@ -11164,33 +11737,10 @@ function createSlackListUpdateItemTool(state) {
   });
 }
 
-// src/chat/slack/tools/channel-access.ts
-async function checkSlackChannelReadAccess(args) {
-  const currentChannels = args.currentChannelIds.filter(
-    (channelId) => Boolean(channelId)
-  );
-  if (currentChannels.includes(args.targetChannelId)) {
-    return { allowed: true };
-  }
-  const store = args.store ?? getConversationStore();
-  const visibility = await store.getDestinationVisibility({
-    provider: "slack",
-    providerTenantId: args.teamId,
-    providerDestinationId: args.targetChannelId
-  });
-  if (visibility === "public") {
-    return { allowed: true };
-  }
-  return {
-    allowed: false,
-    error: "Cannot read this Slack conversation: only the current conversation or public channels Junior has seen in this workspace are readable."
-  };
-}
-
 // src/chat/slack/tools/thread-read.ts
-import { z as z49 } from "zod";
+import { z as z53 } from "zod";
 
-// src/chat/slack/tools/slack-message-url.ts
+// src/chat/slack/tool-support/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
 var ARCHIVE_PATH_PATTERN = /^\/archives\/([CDG][A-Z0-9]+)\/p(\d{10})(\d{6})$/;
 function pTimestampToTs(seconds, micros) {
@@ -11445,27 +11995,23 @@ function truncateMessages(messages, maxChars) {
   }
   return { messages: kept, omitted: messages.length - kept.length };
 }
-function createSlackThreadReadTool(context, deps = {}) {
+function createSlackThreadReadTool(context) {
   return zodTool({
-    description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Only the current conversation and public channels Junior has seen in this workspace are readable.",
+    description: "Read a Slack thread from a shared archive URL or explicit channel + timestamp. Works for the current conversation and public channels.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z49.object({
-      url: z49.string().min(1).describe(
-        "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
-      ).optional(),
-      channel_id: slackChannelIdParam(
-        "Slack channel/conversation ID (e.g. C123). Use with `ts` as an alternative to `url`."
-      ).optional(),
+    inputSchema: z53.object({
+      url: z53.string().min(1).describe("Slack message archive URL.").optional(),
+      channel_id: slackChannelRefParam.optional(),
       ts: slackTimestampParam(
-        "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
+        "Slack message timestamp. May be the thread root or any message in the thread."
       ).optional(),
-      limit: z49.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z49.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z53.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z53.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -11485,14 +12031,11 @@ function createSlackThreadReadTool(context, deps = {}) {
         if (!parsedTs.ok) {
           throw new ToolInputError(parsedTs.error);
         }
-        const parsedChannelId = parseRequiredSlackChannelIdParam(
-          "channel_id",
-          channel_id
-        );
-        if (!parsedChannelId.ok) {
-          throw new ToolInputError(parsedChannelId.error);
-        }
-        channelId = parsedChannelId.value;
+        const target = await resolveSlackChannelRef({
+          field: "channel_id",
+          value: channel_id
+        });
+        channelId = target.channelId;
         messageTs = parsedTs.value;
       } else {
         throw new ToolInputError(
@@ -11504,7 +12047,6 @@ function createSlackThreadReadTool(context, deps = {}) {
           context.destinationChannelId,
           context.sourceChannelId
         ],
-        store: deps.visibilityStore,
         targetChannelId: channelId,
         teamId: context.teamId
       });
@@ -11512,20 +12054,57 @@ function createSlackThreadReadTool(context, deps = {}) {
         throw new ToolInputError(access.error);
       }
       const lookupTs = threadTs ?? messageTs;
+      const readReplies = async () => listThreadReplies({
+        channelId,
+        threadTs: lookupTs,
+        limit: limit ?? 1e3,
+        maxPages: max_pages
+      });
       let replies;
+      let joined = false;
+      let channelName = access.channelName;
+      let readError;
       try {
-        replies = await listThreadReplies({
-          channelId,
-          threadTs: lookupTs,
-          limit: limit ?? 1e3,
-          maxPages: max_pages
-        });
+        replies = await readReplies();
       } catch (error) {
+        readError = error;
+        const canJoin = error instanceof SlackActionError && error.code === "not_in_channel" && access.isMember !== true;
+        if (canJoin) {
+          const joinResult = await joinPublicChannelForRead({
+            channelName,
+            targetChannelId: channelId
+          });
+          if (!joinResult.ok) {
+            throw new ToolInputError(joinResult.error);
+          }
+          joined = true;
+          channelName = joinResult.channelName ?? channelName;
+          try {
+            replies = await readReplies();
+            readError = void 0;
+          } catch (retryError) {
+            readError = retryError;
+          }
+        }
+      }
+      if (!replies) {
+        const error = readError;
         if (error instanceof SlackActionError) {
-          throw new ToolInputError(
-            "Could not read this Slack thread. The bot may not be in the channel or may lack history scopes.",
-            { cause: error }
-          );
+          if (error.code === "not_in_channel") {
+            throw new ToolInputError(
+              "Could not read this Slack thread because the bot is not in the channel.",
+              { cause: error }
+            );
+          }
+          if (error.code === "missing_scope") {
+            throw new ToolInputError(
+              "Could not read this Slack thread because this installation is missing history scopes.",
+              { cause: error }
+            );
+          }
+          throw new ToolInputError("Could not read this Slack thread.", {
+            cause: error
+          });
         }
         throw error;
       }
@@ -11541,6 +12120,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       );
       return {
         channel_id: channelId,
+        ...channelName ? { channel_name: channelName } : {},
+        ...joined ? { joined_channel: true } : {},
         target_message_ts: messageTs,
         thread_ts: resolvedThreadTs,
         count: messages.length,
@@ -11556,7 +12137,7 @@ function createSlackThreadReadTool(context, deps = {}) {
 // src/chat/tools/user-lookup.ts
 import { and, eq, or, sql } from "drizzle-orm";
 import { alias } from "drizzle-orm/pg-core";
-import { z as z50 } from "zod";
+import { z as z54 } from "zod";
 var linkedSlackIdentity = alias(juniorIdentities, "user_lookup_slack_identity");
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found" || error.code === "not_found") {
@@ -11705,9 +12286,9 @@ function createUserLookupTool(teamId, providers) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z50.object({
-      provider: z50.enum(providers).describe("Enabled identity provider to query."),
-      query: z50.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
+    inputSchema: z54.object({
+      provider: z54.enum(providers).describe("Enabled identity provider to query."),
+      query: z54.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
     }).strict(),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ provider, query }) => {
@@ -11727,18 +12308,18 @@ function createUserLookupTool(teamId, providers) {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z51 } from "zod";
-var systemTimeInputSchema = z51.object({
-  timezone: z51.string().trim().min(1).optional().describe(
+import { z as z55 } from "zod";
+var systemTimeInputSchema = z55.object({
+  timezone: z55.string().trim().min(1).optional().describe(
     "Optional IANA timezone, for example America/Los_Angeles. When set, iso_local and timezone_offset_minutes are for that zone."
   )
 });
 var systemTimeOutputSchema = juniorToolOutputSchema.extend({
-  unix_ms: z51.number(),
-  iso_utc: z51.string(),
-  iso_local: z51.string(),
-  timezone: z51.string().nullable(),
-  timezone_offset_minutes: z51.number()
+  unix_ms: z55.number(),
+  iso_utc: z55.string(),
+  iso_local: z55.string(),
+  timezone: z55.string().nullable(),
+  timezone_offset_minutes: z55.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -11818,27 +12399,27 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
 }
 
 // src/chat/tools/search-conversation-events.ts
-import { z as z52 } from "zod";
+import { z as z56 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
 var MAX_EVENTS_JSON_BYTES = 2e4;
 var MAX_IDENTITY_CHARS = 256;
 var textEncoder = new TextEncoder();
-var knownEventTypeSchema = z52.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z52.object({
-  seq: z52.number().int().nonnegative().describe("Stable event position for pagination."),
-  history_version: z52.number().int().nonnegative().describe("Agent history generation after replacement."),
-  created_at: z52.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z52.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
-  data: z52.record(z52.string(), z52.unknown()).describe("Bounded event data.")
+var knownEventTypeSchema = z56.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z56.object({
+  seq: z56.number().int().nonnegative().describe("Stable event position for pagination."),
+  history_version: z56.number().int().nonnegative().describe("Agent history generation after replacement."),
+  created_at: z56.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z56.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
+  data: z56.record(z56.string(), z56.unknown()).describe("Bounded event data.")
 }).strict();
 var searchConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z52.string().min(1),
-  events: z52.array(projectedEventSchema),
-  has_older: z52.boolean().describe("Whether matching older events exist."),
-  has_newer: z52.boolean().describe("Whether matching newer events exist."),
-  omitted_event_count: z52.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
+  conversation_id: z56.string().min(1),
+  events: z56.array(projectedEventSchema),
+  has_older: z56.boolean().describe("Whether matching older events exist."),
+  has_newer: z56.boolean().describe("Whether matching newer events exist."),
+  omitted_event_count: z56.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
 });
 function createSearchConversationEventsTool(context) {
   return zodTool({
@@ -11851,16 +12432,16 @@ function createSearchConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z52.object({
-      conversation_id: z52.string().trim().min(1).nullable().describe(
+    inputSchema: z56.object({
+      conversation_id: z56.string().trim().min(1).nullable().describe(
         "Conversation ID to search. Omit or null for the current conversation."
       ).optional(),
-      after_seq: z52.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
-      before_seq: z52.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
-      limit: z52.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      after_seq: z56.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
+      before_seq: z56.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
+      limit: z56.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events. Default ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z52.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
+      types: z56.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
     }).strict(),
     outputSchema: searchConversationEventsOutputSchema,
     execute: async (input) => {
@@ -12106,10 +12687,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z53 } from "zod";
+import { z as z57 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z53.enum(handoff.profiles);
+  const profileSchema = z57.enum(handoff.profiles);
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -12123,7 +12704,7 @@ function createHandoffTool(handoff) {
     },
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z53.object({
+    inputSchema: z57.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -12144,7 +12725,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z54 } from "zod";
+import { z as z58 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -12587,9 +13168,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z54.object({
-      url: z54.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z54.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z58.object({
+      url: z58.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z58.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, max_chars }) => {
@@ -12634,7 +13215,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z55 } from "zod";
+import { z as z59 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -12676,9 +13257,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z55.object({
-      query: z55.string().min(1).max(500).describe("Search query."),
-      max_results: z55.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z59.object({
+      query: z59.string().min(1).max(500).describe("Search query."),
+      max_results: z59.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -12720,7 +13301,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z56 } from "zod";
+import { z as z60 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -12731,9 +13312,9 @@ function createWriteFileTool() {
     },
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or deliberate full-file replacement after validation; use editFile instead for targeted changes to existing files. Do not use for exploratory analysis-only turns.",
     executionMode: "sequential",
-    inputSchema: z56.object({
-      path: z56.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z56.string().describe("UTF-8 file content to write.")
+    inputSchema: z60.object({
+      path: z60.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z60.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -12825,6 +13406,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
     tools.slackCanvasEdit = createSlackCanvasEditTool(state);
     tools.slackCanvasWrite = createSlackCanvasWriteTool(state);
     tools.slackThreadRead = createSlackThreadReadTool(slackContext);
+    tools.slackChannelJoin = createSlackChannelJoinTool(slackContext);
     if (context.conversationId && slackContext.source.visibility === "public") {
       tools.searchConversationMessages = createSlackConversationMessageSearchTool(
         {
@@ -12835,7 +13417,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
         context.conversationId
       );
     }
-    if (context.source.platform === "slack" && context.slackActionToken) {
+    if (context.source.platform === "slack") {
       tools.slackPublicSearch = createSlackPublicSearchTool(
         context.slackActionToken
       );
@@ -12870,9 +13452,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
         (input) => readSandboxFileUpload(context.workspace, input)
       );
     }
-    if (outputCapabilities?.canPostToChannel) {
-      tools.slackChannelListMessages = createSlackChannelListMessagesTool(slackContext);
-    }
+    tools.slackChannelListMessages = createSlackChannelListMessagesTool(slackContext);
     if (rawChannelCapabilities.canAddReactions) {
       tools.addReaction = createSlackMessageAddReactionTool(
         slackContext,
@@ -13431,7 +14011,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z57 } from "zod";
+import { z as z61 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -13443,11 +14023,11 @@ function createExecuteToolTool() {
     },
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z57.object({
-      tool_name: z57.string().min(1).describe(
+    inputSchema: z61.object({
+      tool_name: z61.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z57.record(z57.string(), z57.unknown()).describe(
+      arguments: z61.record(z61.string(), z61.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -13487,7 +14067,7 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z58 } from "zod";
+import { z as z62 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
@@ -13532,29 +14112,29 @@ var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
   "you",
   "your"
 ]);
-var searchToolsSourceSchema = z58.object({
-  id: z58.string(),
-  description: z58.string()
+var searchToolsSourceSchema = z62.object({
+  id: z62.string(),
+  description: z62.string()
 }).strict();
-var searchToolsToolSchema = z58.object({
-  tool_name: z58.string(),
-  description: z58.string(),
-  exposure: z58.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z58.string().optional(),
-  input_schema: z58.unknown(),
-  call_notes: z58.array(z58.string()),
-  annotations: z58.record(z58.string(), z58.unknown())
+var searchToolsToolSchema = z62.object({
+  tool_name: z62.string(),
+  description: z62.string(),
+  exposure: z62.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z62.string().optional(),
+  input_schema: z62.unknown(),
+  call_notes: z62.array(z62.string()),
+  annotations: z62.record(z62.string(), z62.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z58.string().nullable(),
-  source: z58.string().nullable(),
-  sources: z58.array(searchToolsSourceSchema),
-  total_catalog_tools: z58.number().int().nonnegative(),
-  total_eligible_tools: z58.number().int().nonnegative(),
-  total_matches: z58.number().int().nonnegative(),
-  returned_tools: z58.number().int().nonnegative(),
-  execution_tool: z58.literal("executeTool"),
-  tools: z58.array(searchToolsToolSchema)
+  query: z62.string().nullable(),
+  source: z62.string().nullable(),
+  sources: z62.array(searchToolsSourceSchema),
+  total_catalog_tools: z62.number().int().nonnegative(),
+  total_eligible_tools: z62.number().int().nonnegative(),
+  total_matches: z62.number().int().nonnegative(),
+  returned_tools: z62.number().int().nonnegative(),
+  execution_tool: z62.literal("executeTool"),
+  tools: z62.array(searchToolsToolSchema)
 }).strict();
 function terms(value) {
   const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
@@ -13765,14 +14345,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z58.object({
-      query: z58.string().nullable().describe(
+    inputSchema: z62.object({
+      query: z62.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z58.string().nullable().describe(
+      source: z62.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z58.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z62.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -15014,7 +15594,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z59 } from "zod";
+import { z as z63 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -15082,17 +15662,17 @@ Assess the exact action's intrinsic risk and whether the user's intent authorize
 - Keep the reason to one concise, specific sentence grounded in the main risk or authorization fact. For ask, name the exact action, target, and material side effects the user must confirm.`;
 
 // src/chat/services/guardian-action-review.ts
-var guardianDecisionSchema = z59.object({
-  decision: z59.enum(["allow", "ask", "deny"]),
-  reason: z59.string().trim().min(1).max(500),
-  riskLevel: z59.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z59.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z63.object({
+  decision: z63.enum(["allow", "ask", "deny"]),
+  reason: z63.string().trim().min(1).max(500),
+  riskLevel: z63.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z63.enum(["high", "medium", "low", "unknown"])
 }).strict();
 var GUARDIAN_REVIEW_TIMEOUT_MS = 6e4;
 var GUARDIAN_REVIEW_MAX_TOKENS = 2e3;
 var MAX_PROPOSAL_CHARS = 192e3;
 function guardianPrompt(proposal) {
-  const proposalJson = JSON.stringify(z59.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z63.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -15337,6 +15917,38 @@ async function tryRecordSkillLoadStat(skill) {
     });
   }
 }
+function resolveToolRuntimeRoute(args) {
+  const destination = toolInvocationDestination(args.routing);
+  switch (args.routing.source.platform) {
+    case "slack": {
+      if (destination.platform !== "slack") {
+        throw new TypeError("Slack tool runtime requires a Slack destination");
+      }
+      return {
+        destination,
+        actor: args.actor?.platform === "slack" ? args.actor : void 0,
+        source: args.routing.source,
+        slackActionToken: args.routing.slackActionToken
+      };
+    }
+    case "local": {
+      if (destination.platform !== "local") {
+        throw new TypeError("Local tool runtime requires a local destination");
+      }
+      return {
+        destination,
+        actor: args.actor?.platform === "local" ? args.actor : void 0,
+        source: args.routing.source
+      };
+    }
+    case "web":
+      return {
+        destination,
+        actor: args.actor?.platform === "web" ? args.actor : void 0,
+        source: args.routing.source
+      };
+  }
+}
 async function wireAgentTools(args) {
   const runSource = args.routing.source;
   const credentialUserId = args.routing.credentialContext ? credentialUserSubjectId(args.routing.credentialContext) : void 0;
@@ -15453,36 +16065,20 @@ async function wireAgentTools(args) {
     ...args.durability.spawnAgent ? { spawnAgent: args.durability.spawnAgent } : {},
     ...args.requestHandoff ? { handoff: args.requestHandoff } : {}
   };
-  const toolDestination = toolInvocationDestination(args.routing);
-  let toolRuntimeContext;
-  if (runSource.platform === "slack") {
-    if (toolDestination.platform !== "slack") {
-      throw new TypeError("Slack tool runtime requires a Slack destination");
-    }
-    toolRuntimeContext = {
-      ...commonToolRuntimeContext,
-      destination: toolDestination,
-      actor: args.currentActor?.platform === "slack" ? args.currentActor : void 0,
-      source: runSource,
-      slackActionToken: args.routing.slackActionToken
-    };
-  } else {
-    if (toolDestination.platform !== "local") {
-      throw new TypeError("Local tool runtime requires a local destination");
-    }
-    toolRuntimeContext = {
-      ...commonToolRuntimeContext,
-      destination: toolDestination,
-      actor: args.currentActor?.platform === "local" ? args.currentActor : void 0,
-      source: runSource
-    };
-  }
+  const toolRoute = resolveToolRuntimeRoute({
+    actor: args.currentActor,
+    routing: args.routing
+  });
+  const toolRuntimeContext = {
+    ...commonToolRuntimeContext,
+    ...toolRoute
+  };
   const actionReview = createToolActionReview({
     context: {
       actor: args.currentActor,
       conversationId: args.conversationId,
       credentialContext: args.routing.credentialContext,
-      destination: toolDestination,
+      destination: toolRoute.destination,
       source: runSource,
       userIntent: args.currentUserIntent,
       evidence: () => buildToolActionEvidence(args.currentAgentMessages())
@@ -15688,6 +16284,7 @@ function createResumeState(args) {
     destination: args.destination,
     destinationVisibility: args.destinationVisibility,
     dispatchId: args.dispatchId,
+    publishExternally: args.publishExternally,
     source: args.runSource,
     actor: args.actor,
     surface: args.surface
@@ -16496,6 +17093,12 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
   let connectedMcpProviders = /* @__PURE__ */ new Set();
   let turnUsage;
   let priorPhaseUsage;
+  let agent;
+  let acceptedToolFreeAssistant = false;
+  const generatedFiles = [];
+  const toolCalls = [];
+  let shouldTrace = false;
+  let getSandboxRef;
   const configuredReasoningLevel = policy.reasoningLevel ?? botConfig.reasoningLevel;
   let turnRoute = configuredReasoningLevel ? configuredTurnRoute(
     STANDARD_MODEL_PROFILE,
@@ -16534,7 +17137,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     activeModelProfile = projection.modelProfile;
     activeModelId = modelIdForProfile(botConfig, activeModelProfile);
     let durableModelProfile = projection.modelProfile;
-    const shouldTrace = shouldEmitDevAgentTrace();
+    shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = { modelId: activeModelId };
     const availableSkills = await discoverRunSkills({
       skillDirs: policy.skillDirs
@@ -16591,6 +17194,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       ...routing.dispatch?.id ? { dispatchId: routing.dispatch.id } : {},
       durability,
       recordActiveMcpProviders,
+      publishExternally: checkpoint.record?.publishExternally ?? routing.publishExternally ?? false,
       actor,
       runSource,
       conversationId,
@@ -16716,9 +17320,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     }
     activeModelProfile = routedModelProfile;
     activeModelId = routedModelId;
-    const generatedFiles = [];
-    const toolCalls = [];
-    let agent;
     let pendingPiHookError;
     let pendingHandoff;
     const currentAgentMessages = () => agent ? [...agent.state.messages] : [];
@@ -16857,6 +17458,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     });
     mcpToolManager = wiring.mcpToolManager;
     closeTools = wiring.close;
+    getSandboxRef = () => wiring.getSandboxRef();
     const initialRepositoryInstructions = wiring.getSandboxRef() ? await wiring.captureRepositoryInstructions() : void 0;
     const recordAgentsTransition = async (instructions) => {
       try {
@@ -17038,6 +17640,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       }
       try {
         await delivery(message);
+        acceptedToolFreeAssistant = true;
       } catch (error) {
         assistantMessageDeliveryError = new AssistantMessageDeliveryError(
           error
@@ -17521,6 +18124,27 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     if (resume && runError instanceof AuthorizationPauseError) {
       return await resume.parkForAuth(runError, turnUsage);
     }
+    if (resume?.timedOut && acceptedToolFreeAssistant && agent && turnRoute) {
+      await recordActiveMcpProviders();
+      const piMessages = [...agent.state.messages];
+      return {
+        status: "completed",
+        result: buildTurnResult({
+          newMessages: piMessages.slice(resume.beforeMessageCount),
+          userInput,
+          toolCalls,
+          sandboxRef: getSandboxRef?.() ?? lastKnownSandboxRef,
+          piMessages,
+          durationMs: Date.now() - replyStartedAtMs,
+          generatedFileCount: generatedFiles.length,
+          shouldTrace,
+          usage: turnUsage,
+          executionProfile: turnRoute,
+          assistantUserName: botConfig.userName,
+          modelId: activeModelId
+        })
+      };
+    }
     if (resume) {
       const outcome = await resume.translateSuspension({
         currentUsage: turnUsage,