@sentry/junior 0.146.0 → 0.148.0

package/dist/{chunk-BLETMLRX.js → chunk-VMNRXKAH.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-FEKQHPVA.js";
+} from "./chunk-EINWQFXI.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -21,14 +21,18 @@ import {
   getMcpAwareErrorType,
   getMcpAwareTelemetryMessage,
   getMcpProviderErrorAttributes,
+  getOAuthAccountProviders,
   hasEgressCredentialHooks,
   issuePluginCredential,
   issueProviderCredentialLease,
+  lookupSlackUserByEmail,
+  lookupSlackUserProfile,
   onPluginEgressResponse,
   patchMcpAuthSession,
+  searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-47OSH2ZO.js";
+} from "./chunk-XJ42NBP5.js";
 import {
   RetryableDeliveryError,
   actorFromRouting,
@@ -36,7 +40,7 @@ import {
   isAgentRunFeatureDisabled,
   surfaceFromRouting,
   toolInvocationDestination
-} from "./chunk-R776HKPK.js";
+} from "./chunk-GDFF3BQG.js";
 import {
   addReactionToMessage,
   deliverOAuthAuthorization,
@@ -44,77 +48,7 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-ZDGHGY74.js";
-import {
-  estimateTextTokens,
-  getAgentContextCompactionTriggerTokens,
-  getAgentContextInputLimitTokens
-} from "./chunk-T5GXFFLA.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,
-  mergeArtifactsState,
-  missingPathSearchResult,
-  normalizeToLf,
-  normalizeToolNameFromResult,
-  openConversationProjection,
-  piMessageFromHistoryItem,
-  positiveInteger,
-  recordAgentsInstructionsUpdated,
-  recordAuthorizationRequested,
-  recordGuardianActionReviewed,
-  recordMcpProviderConnected,
-  recordToolExecutionStarted,
-  recordTurnRoute,
-  renderAgentsInstructions,
-  resolveRepositoryInstructions,
-  resolveWorkspacePath,
-  retainRuntimeTurnContext,
-  sanitizeAssistantText,
-  saveTurnCheckpoint,
-  stripRuntimeTurnContext,
-  trimTrailingAssistantMessages,
-  truncateText
-} from "./chunk-GDQEU4I7.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
+} from "./chunk-WCN4YSH7.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -143,7 +77,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-FXDDDSPL.js";
+} from "./chunk-VY6W3T43.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -175,20 +109,85 @@ import {
   saveEventTask,
   scheduledTaskAttributes,
   writableEventTask
-} from "./chunk-X22KCSCO.js";
+} from "./chunk-GXYDVZKM.js";
 import {
   parseSlackThreadId
-} from "./chunk-PH4Q3A6W.js";
+} from "./chunk-WOONT5ZP.js";
 import {
   SHORT_TITLE_MAX_LENGTH,
+  estimateTextTokens,
   generateShortTitle,
+  getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
   resolveTaskTitle
-} from "./chunk-W65V465O.js";
+} from "./chunk-4EA2SFK2.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,
   ToolInputError,
+  TurnInputCommitLostError,
+  TurnSliceLimitExceededError,
+  abandonReplacedPendingAuth,
   addAgentTurnUsage,
-  hasAgentTurnUsage
-} from "./chunk-HLXXQI5Q.js";
+  buildAgentsInstructionsMessage,
+  canReusePendingAuthLink,
+  collectFiles,
+  containsNoReplyMarker,
+  continuableMessages,
+  decideReply,
+  extractAssistantText,
+  findSingleRepositoryDirectory,
+  findVisibleAgentsInstructions,
+  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,
+  resolveWorkspacePath,
+  retainRuntimeTurnContext,
+  sanitizeAssistantText,
+  saveTurnCheckpoint,
+  stripRuntimeTurnContext,
+  trimTrailingAssistantMessages,
+  truncateText
+} from "./chunk-VCYSOXON.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -201,7 +200,7 @@ import {
   getSlackToolContext,
   readActorIdentity,
   resolveChannelCapabilities
-} from "./chunk-SCGVWUZX.js";
+} from "./chunk-ZCHIC2GM.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -210,7 +209,7 @@ import {
   isConversationScopedChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-V6SRLKUB.js";
+} from "./chunk-V2FXMOEA.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -221,12 +220,11 @@ import {
   getSqlExecutor,
   instructionActors,
   instructionProvenanceFor,
-  sameActorIdentity,
-  upsertIdentity
-} from "./chunk-37EVZP66.js";
+  sameActorIdentity
+} from "./chunk-VRHTNBA6.js";
 import {
   juniorIdentities
-} from "./chunk-MCFIXAV5.js";
+} from "./chunk-D3WPMGEX.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -238,7 +236,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-GYEKOX7N.js";
+} from "./chunk-2B3PT3V2.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -271,7 +269,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-MKRIZ4VG.js";
+} from "./chunk-4GXJUYJV.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -281,16 +279,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-QG7OOKIN.js";
+} from "./chunk-LE5H7LMT.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-FGHADGIC.js";
+} from "./chunk-4AQZYNHM.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PB222GIA.js";
+} from "./chunk-HWQGBIH7.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -298,7 +296,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-37JJDS4H.js";
+} from "./chunk-POSZWRGL.js";
 import {
   credentialUserSubjectId
 } from "./chunk-RUIXF3YQ.js";
@@ -328,7 +326,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-B63BF443.js";
+} from "./chunk-EAI67NTM.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -810,7 +808,6 @@ import { isRetryableAssistantError } from "@earendil-works/pi-ai";
 function buildTurnResult(input) {
   const {
     newMessages,
-    artifactStatePatch,
     toolCalls,
     sandboxRef,
     durationMs,
@@ -906,7 +903,6 @@ function buildTurnResult(input) {
   };
   return {
     text: primaryText,
-    artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
     sandboxRef,
     piMessages: input.piMessages,
     diagnostics: resolvedDiagnostics
@@ -986,27 +982,22 @@ function getDiscardedRetryUsage(messages, retryMessages) {
   return hasAgentTurnUsage(usage) ? usage : void 0;
 }
 
-// src/chat/tool-support/turn-deadline-result.ts
-var TURN_DEADLINE_INTERRUPTION = {
-  cause: "turn_deadline",
-  scope: "execution_slice",
-  task_status: "active"
-};
-function annotateTurnDeadlineToolResult(result) {
-  if (!result.details || typeof result.details !== "object" || Array.isArray(result.details) || !("aborted" in result.details) || result.details.aborted !== true) {
+// src/chat/tool-support/timed-out-tool-result.ts
+function projectTimedOutToolResult(result) {
+  const details = result.details;
+  if (!details || typeof details !== "object" || Array.isArray(details) || !("aborted" in details) || details.aborted !== true) {
     return void 0;
   }
-  const details = {
-    ...result.details,
-    interruption: TURN_DEADLINE_INTERRUPTION
-  };
-  const envelope = makeStructuredToolOutput(details, {
-    content: result.content.slice(1)
+  const record2 = details;
+  const target = typeof record2.target === "string" && record2.target.length > 0 ? record2.target : void 0;
+  const envelope = makeStructuredToolOutput({
+    ...target ? { target } : {},
+    timed_out: true
   });
   return {
     content: envelope.content,
     details: envelope.details,
-    isError: true
+    isError: false
   };
 }
 
@@ -1227,13 +1218,15 @@ async function classifyTurn(args) {
       prompt: args.prompt,
       thinkingLevel: "low",
       system: buildClassifierSystemPrompt(Object.keys(args.profiles)),
-      temperature: 0
+      temperature: 0,
+      promptName: "junior.thinking_route"
     });
     const parsed = schema.parse(result.object);
     const reason = parsed.reason.trim();
     if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
       return {
         confidence: parsed.confidence,
+        ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {},
         profile: STANDARD_MODEL_PROFILE,
         reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
         reason: `low_confidence_medium_default:${reason}`,
@@ -1242,6 +1235,7 @@ async function classifyTurn(args) {
     }
     return {
       confidence: parsed.confidence,
+      ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {},
       profile: parsed.profile,
       reasoningLevel: parsed.reasoning_level,
       reason,
@@ -1764,34 +1758,6 @@ function formatReferenceFilesLines() {
     return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
   });
 }
-function formatArtifactsLines(artifactState) {
-  if (!artifactState) return null;
-  const lines = [];
-  if (artifactState.lastCanvasId) {
-    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
-  }
-  if (artifactState.lastCanvasUrl) {
-    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
-  }
-  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
-    lines.push("- recent_canvases:");
-    for (const canvas of artifactState.recentCanvases) {
-      lines.push(`  - id: ${escapeXml(canvas.id)}`);
-      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
-      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
-      if (canvas.createdAt) {
-        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
-      }
-    }
-  }
-  if (artifactState.lastListId) {
-    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
-  }
-  if (artifactState.lastListUrl) {
-    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
-  }
-  return lines.length > 0 ? lines : null;
-}
 function formatConfigurationLines(configuration) {
   const keys = Object.keys(configuration ?? {}).sort(
     (a, b) => a.localeCompare(b)
@@ -1842,7 +1808,7 @@ var EXECUTION_CONTRACT_RULES = [
   "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
   "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
   "- Use `reportProgress` only for work with multiple substantive phases or a materially long wait. Skip short lookups and routine commands; after an initial update, call it again only when the major phase changes.",
-  "- When a tool outcome is unknown and may include side effects, inspect authoritative state before retrying. If state already reflects the intended result, do not repeat the mutation."
+  "- A tool result with `timed_out: true` means that attempt did not finish. Continue the active task. Before retrying work that may have side effects, inspect authoritative state and do not repeat a mutation that already applied."
 ];
 var CONVERSATION_RULES = [
   "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
@@ -1933,19 +1899,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") {
@@ -2004,10 +1973,6 @@ function buildContextSection(params) {
   if (dispatchLines) {
     blocks.push(dispatchLines);
   }
-  const artifactLines = formatArtifactsLines(params.artifactState);
-  if (artifactLines) {
-    blocks.push(renderTag("artifacts", artifactLines));
-  }
   const configLines = formatConfigurationLines(params.configuration);
   if (configLines) {
     blocks.push(
@@ -2093,7 +2058,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;
@@ -2112,7 +2078,6 @@ function buildTurnContextPrompt(params) {
     pluginPromptContributions,
     includeSessionContext ? buildContextSection({
       actor: params.actor,
-      artifactState: params.artifactState,
       configuration: params.configuration,
       dispatch: params.dispatch
     }) : null,
@@ -2410,7 +2375,6 @@ async function assemblePrompt(args) {
       source
     } : void 0,
     actor: isUserActor(args.currentActor) ? args.currentActor : void 0,
-    artifactState: args.artifactState,
     configuration: args.configurationValues
   }) : null;
   const turnContextParts = turnContextPrompt ? [{ type: "text", text: turnContextPrompt }] : [];
@@ -2496,9 +2460,9 @@ function commandResult(input) {
     exitCode: input.exitCode
   };
 }
-function requireChannelConfiguration(deps) {
-  if (deps.channelConfiguration) {
-    return { ok: true, configuration: deps.channelConfiguration };
+function requireLocationConfiguration(deps) {
+  if (deps.locationConfiguration) {
+    return { ok: true, configuration: deps.locationConfiguration };
   }
   return {
     ok: false,
@@ -2544,7 +2508,7 @@ async function handleConfigCommand(args, deps) {
     "jr-rpc config list [--prefix <value>]"
   ].join("\n");
   const subverb = (args[0] ?? "").trim();
-  const configurationResult = requireChannelConfiguration(deps);
+  const configurationResult = requireLocationConfiguration(deps);
   if (!configurationResult.ok) {
     return configurationResult.result;
   }
@@ -6039,7 +6003,7 @@ function createAgentSandbox(options) {
         if (command) {
           const result = await maybeExecuteJrRpcCustomCommand(command, {
             activeSkill: options.getActiveSkill(),
-            channelConfiguration: options.channelConfiguration,
+            locationConfiguration: options.locationConfiguration,
             actorId: isUserActor(options.actor) ? options.actor.userId : void 0,
             onConfigurationValueChanged: (key, value) => {
               if (value === void 0) {
@@ -6924,7 +6888,8 @@ async function enrichImagePrompt(rawPrompt) {
       modelId: botConfig.fastModelId,
       system: ENRICHMENT_SYSTEM_PROMPT,
       messages: [{ role: "user", content: rawPrompt, timestamp: Date.now() }],
-      maxTokens: 1024
+      maxTokens: 1024,
+      promptName: "junior.image_prompt_enrichment"
     });
     if (text && text.trim().length > 0) {
       logInfo("image.prompt.enriched", {
@@ -9673,94 +9638,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
-    },
+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({
-      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."
-      ),
+      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: z36.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").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,
@@ -9768,9 +10021,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",
@@ -9788,39 +10054,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 = {
@@ -9831,35 +10142,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(
@@ -9871,9 +10179,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: {
@@ -9882,24 +10190,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);
@@ -9908,7 +10213,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
           });
@@ -9936,35 +10241,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.";
@@ -9974,33 +10482,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,
@@ -10008,36 +10516,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 = (response.results?.messages ?? []).map(normalizeMessage).filter((message) => Boolean(message));
-        const nextCursor = response.results?.next_cursor;
+        const messages = parseItems(
+          response.results.messages,
+          slackSearchMessageWireSchema
+        );
+        const files = parseItems(
+          response.results.files,
+          slackSearchFileWireSchema
+        );
+        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) {
@@ -10053,7 +10588,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) {
@@ -10083,9 +10618,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."
       )
     }),
@@ -10134,14 +10669,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) => ({
@@ -10170,9 +10705,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."
       )
     }),
@@ -10258,7 +10793,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";
 }
@@ -10407,7 +10942,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);
@@ -10564,47 +11099,8 @@ async function readCanvas(canvasIdOrUrl) {
   };
 }
 
-// src/chat/slack/tools/canvas/context.ts
-var MAX_RECENT_CANVASES = 5;
-function mergeRecentCanvases(existing, created) {
-  const nextEntry = {
-    id: created.id,
-    title: created.title,
-    url: created.url,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const prior = existing ?? [];
-  const deduped = prior.filter((entry) => entry.id !== created.id);
-  return [nextEntry, ...deduped].slice(0, MAX_RECENT_CANVASES);
-}
-function resolveCanvasTarget(canvas) {
-  const canvasId = extractCanvasId(canvas);
-  if (!canvasId) {
-    return {
-      ok: false,
-      error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
-    };
-  }
-  return { ok: true, canvasId };
-}
-function storedCanvasUrl(state, canvasId) {
-  const lastCanvasUrl = state.artifactState.lastCanvasUrl;
-  if (lastCanvasUrl && extractCanvasId(lastCanvasUrl) === canvasId) {
-    return lastCanvasUrl;
-  }
-  for (const canvas of state.artifactState.recentCanvases ?? []) {
-    if (extractCanvasId(canvas.id) === canvasId) {
-      return canvas.url;
-    }
-    if (canvas.url && extractCanvasId(canvas.url) === canvasId) {
-      return canvas.url;
-    }
-  }
-  return void 0;
-}
-
 // 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: {
@@ -10613,10 +11109,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 }) => {
@@ -10648,18 +11144,6 @@ function createSlackCanvasCreateTool(context, state) {
         markdown,
         channelId: targetChannelId
       });
-      await state.patchArtifactState({
-        lastCanvasId: created.canvasId,
-        lastCanvasUrl: created.permalink,
-        recentCanvases: mergeRecentCanvases(
-          state.artifactState.recentCanvases,
-          {
-            id: created.canvasId,
-            title,
-            url: created.permalink
-          }
-        )
-      });
       const response = {
         canvas_id: created.canvasId,
         permalink: created.permalink,
@@ -10671,27 +11155,41 @@ function createSlackCanvasCreateTool(context, state) {
   });
 }
 
+// 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) {
+    return {
+      ok: false,
+      error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+    };
+  }
+  return { ok: true, canvasId };
+}
+
 // 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({
@@ -10701,12 +11199,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."
       )
     }),
@@ -10738,10 +11236,6 @@ function createSlackCanvasEditTool(state) {
         canvasId: target.canvasId,
         markdown: newContent
       });
-      await state.patchArtifactState({
-        lastCanvasId: target.canvasId,
-        lastCanvasUrl: current.permalink ?? state.artifactState.lastCanvasUrl
-      });
       const diff = buildCompactDiff(
         normalizeCanvasMarkdown(baseContent).markdown,
         written.markdown
@@ -10763,34 +11257,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 }) => {
@@ -10826,7 +11318,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: {
@@ -10835,11 +11327,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 }) => {
@@ -10862,10 +11354,6 @@ function createSlackCanvasWriteTool(state) {
         canvasId: target.canvasId,
         markdown: content
       });
-      await state.patchArtifactState({
-        lastCanvasId: target.canvasId,
-        lastCanvasUrl: storedCanvasUrl(state, target.canvasId)
-      });
       const response = {
         canvas_id: target.canvasId,
         normalized_heading_count: written.normalizedHeadingCount,
@@ -10877,7 +11365,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, "_");
 }
@@ -10950,9 +11438,19 @@ async function createTodoList(name) {
     permalink
   };
 }
+async function getListColumnMap(listId) {
+  const client = getSlackClient();
+  const response = await withSlackRetries(
+    () => client.files.info({ file: listId }),
+    3,
+    { action: "files.info", idempotent: true }
+  );
+  const file = response.file;
+  return inferListColumnMap(file?.list_metadata?.schema ?? []);
+}
 async function addListItems(input) {
   const client = getSlackClient();
-  const listColumnMap = input.listColumnMap ?? {};
+  const listColumnMap = input.listColumnMap ?? await getListColumnMap(input.listId);
   if (!listColumnMap.titleColumnId) {
     throw new Error(
       "Cannot add list items because title column could not be inferred"
@@ -11021,19 +11519,20 @@ async function listItems(listId, limit = 100) {
 }
 async function updateListItem(input) {
   const client = getSlackClient();
+  const listColumnMap = Object.keys(input.listColumnMap).length > 0 ? input.listColumnMap : await getListColumnMap(input.listId);
   const cells = [];
-  if (typeof input.completed === "boolean" && input.listColumnMap.completedColumnId) {
+  if (typeof input.completed === "boolean" && listColumnMap.completedColumnId) {
     cells.push({
       row_id: input.itemId,
-      column_id: input.listColumnMap.completedColumnId,
+      column_id: listColumnMap.completedColumnId,
       checkbox: input.completed
     });
   }
-  if (typeof input.title === "string" && input.title.trim() && input.listColumnMap.titleColumnId) {
+  if (typeof input.title === "string" && input.title.trim() && listColumnMap.titleColumnId) {
     cells.push({
       row_id: input.itemId,
       ...richTextField(
-        input.listColumnMap.titleColumnId,
+        listColumnMap.titleColumnId,
         input.title
       )
     });
@@ -11053,8 +11552,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: {
@@ -11063,26 +11567,23 @@ function createSlackListAddItemsTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: z45.object({
-      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 ({ items, assignee_user_id, due_date }) => {
-      const targetListId = state.getCurrentListId();
-      if (!targetListId) {
-        throw new ToolInputError("No active list found in artifact context");
-      }
+    execute: async ({ list_id, items, assignee_user_id, due_date }) => {
       const parsedAssigneeUserId = assignee_user_id === void 0 ? void 0 : parseRequiredSlackUserIdParam("assignee_user_id", assignee_user_id);
       if (parsedAssigneeUserId?.ok === false) {
         throw new ToolInputError(parsedAssigneeUserId.error);
       }
       const operationKey = createOperationKey("slackListAddItems", {
-        list_id: targetListId,
+        list_id,
         items,
         assignee_user_id: parsedAssigneeUserId?.value ?? null,
         due_date: due_date ?? null
@@ -11095,18 +11596,13 @@ function createSlackListAddItemsTool(state) {
         };
       }
       const result = await addListItems({
-        listId: targetListId,
+        listId: list_id,
         titles: items,
-        listColumnMap: state.artifactState.listColumnMap,
         assigneeUserId: parsedAssigneeUserId?.value,
         dueDate: due_date
       });
-      await state.patchArtifactState({
-        lastListId: targetListId,
-        listColumnMap: result.listColumnMap
-      });
       const response = {
-        list_id: targetListId,
+        list_id,
         created_item_ids: result.createdItemIds,
         created_count: result.createdItemIds.length
       };
@@ -11117,7 +11613,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: {
@@ -11126,9 +11622,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 }) => {
@@ -11141,11 +11637,6 @@ function createSlackListCreateTool(state) {
         };
       }
       const list = await createTodoList(name);
-      await state.patchArtifactState({
-        lastListId: list.listId,
-        lastListUrl: list.permalink,
-        listColumnMap: list.listColumnMap
-      });
       const response = {
         list_id: list.listId,
         permalink: list.permalink,
@@ -11158,29 +11649,26 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z47 } from "zod";
-function createSlackListGetItemsTool(state) {
+import { z as z51 } from "zod";
+function createSlackListGetItemsTool() {
   return zodTool({
-    description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
+    description: "Read items from a Slack list.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z47.object({
-      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 ({ limit }) => {
-      const targetListId = state.getCurrentListId();
+    execute: async ({ list_id, limit }) => {
       const resolvedLimit = limit ?? 100;
-      if (!targetListId) {
-        throw new ToolInputError("No active list found in artifact context");
-      }
-      const items = await listItems(targetListId, resolvedLimit);
+      const items = await listItems(list_id, resolvedLimit);
       return {
-        list_id: targetListId,
+        list_id,
         items: items.map((item) => ({ id: item.id, fields: item.fields }))
       };
     }
@@ -11188,21 +11676,23 @@ function createSlackListGetItemsTool(state) {
 }
 
 // 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({
-    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({
-    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) {
@@ -11213,16 +11703,12 @@ function createSlackListUpdateItemTool(state) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Update an item in the active Slack list tracked in artifact context (title/completion). Use when the user asks to mark progress or rename a tracked task. Do not use to add new tasks.",
+    description: "Update an item in a Slack list.",
     inputSchema: updateListItemInputSchema,
     outputSchema: juniorToolOutputSchema,
-    execute: async ({ item_id, completed, title }) => {
-      const targetListId = state.getCurrentListId();
-      if (!targetListId) {
-        throw new ToolInputError("No active list found in artifact context");
-      }
+    execute: async ({ list_id, item_id, completed, title }) => {
       const operationKey = createOperationKey("slackListUpdateItem", {
-        list_id: targetListId,
+        list_id,
         item_id,
         completed: completed ?? null,
         title: title ?? null
@@ -11235,15 +11721,14 @@ function createSlackListUpdateItemTool(state) {
         };
       }
       await updateListItem({
-        listId: targetListId,
+        listId: list_id,
         itemId: item_id,
         completed,
         title,
-        listColumnMap: state.artifactState.listColumnMap ?? {}
+        listColumnMap: {}
       });
-      await state.patchArtifactState({ lastListId: targetListId });
       const response = {
-        list_id: targetListId,
+        list_id,
         item_id,
         completed,
         title
@@ -11254,33 +11739,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) {
@@ -11535,27 +11997,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 }) => {
@@ -11575,14 +12033,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(
@@ -11594,7 +12049,6 @@ function createSlackThreadReadTool(context, deps = {}) {
           context.destinationChannelId,
           context.sourceChannelId
         ],
-        store: deps.visibilityStore,
         targetChannelId: channelId,
         teamId: context.teamId
       });
@@ -11602,20 +12056,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;
       }
@@ -11631,6 +12122,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,
@@ -11643,183 +12136,70 @@ function createSlackThreadReadTool(context, deps = {}) {
   });
 }
 
-// src/chat/slack/tools/user-lookup.ts
-import { and, eq } from "drizzle-orm";
-import { z as z50 } from "zod";
-
-// src/chat/slack/users.ts
-function normalizeUser(raw) {
-  const rawFields = raw.profile?.fields;
-  const profileFields = [];
-  if (rawFields && typeof rawFields === "object") {
-    for (const [id, field] of Object.entries(rawFields)) {
-      if (!field) continue;
-      profileFields.push({
-        id,
-        label: field.label || void 0,
-        value: field.value || void 0,
-        alt: field.alt || void 0
-      });
-    }
-  }
-  return {
-    id: raw.id ?? "",
-    team_id: raw.team_id || void 0,
-    name: raw.name || void 0,
-    real_name: raw.real_name || raw.profile?.real_name || void 0,
-    display_name: raw.profile?.display_name || void 0,
-    title: raw.profile?.title || void 0,
-    email: raw.profile?.email || void 0,
-    status_text: raw.profile?.status_text ?? void 0,
-    status_emoji: raw.profile?.status_emoji ?? void 0,
-    is_bot: raw.is_bot ?? false,
-    is_deleted: raw.deleted ?? false,
-    timezone: raw.tz || void 0,
-    ...profileFields.length > 0 ? { profile_fields: profileFields } : {}
-  };
-}
-async function lookupSlackUserProfile(userId) {
-  const client = getSlackClient();
-  const result = await withSlackRetries(
-    () => client.users.info({ user: userId }),
-    3,
-    { action: "users.info" }
-  );
-  const user = result.user;
-  if (!user) {
-    throw new Error(`Slack users.info returned no user for ${userId}`);
-  }
-  return normalizeUser(user);
-}
-async function lookupSlackUserByEmail(email) {
-  const client = getSlackClient();
-  let result;
-  try {
-    result = await withSlackRetries(
-      () => client.users.lookupByEmail({ email }),
-      3,
-      { action: "users.lookupByEmail" }
-    );
-  } catch (error) {
-    const apiError = error.apiError;
-    if (apiError === "users_not_found") {
-      return null;
-    }
-    throw error;
-  }
-  const user = result.user;
-  if (!user) {
-    return null;
-  }
-  return normalizeUser(user);
-}
-function scoreMatch(user, queryLower) {
-  const name = (user.name ?? "").toLowerCase();
-  const realName = (user.real_name ?? user.profile?.real_name ?? "").toLowerCase();
-  const displayName = (user.profile?.display_name ?? "").toLowerCase();
-  if (name === queryLower || displayName === queryLower) return 100;
-  if (realName === queryLower) return 90;
-  if (name.startsWith(queryLower) || displayName.startsWith(queryLower))
-    return 70;
-  if (realName.startsWith(queryLower)) return 60;
-  const realNameWords = realName.split(/\s+/);
-  if (realNameWords.some((w) => w === queryLower)) return 55;
-  if (realNameWords.some((w) => w.startsWith(queryLower))) return 50;
-  if (name.includes(queryLower) || displayName.includes(queryLower)) return 30;
-  if (realName.includes(queryLower)) return 20;
-  return 0;
-}
-async function searchSlackUsers(options) {
-  const {
-    query,
-    limit = 10,
-    maxPages = 3,
-    includeDeleted = false,
-    includeBots = false
-  } = options;
-  const queryLower = query.toLowerCase().trim();
-  const client = getSlackClient();
-  const matches = [];
-  let cursor;
-  let pages = 0;
-  let totalScanned = 0;
-  let truncated = false;
-  while (pages < maxPages) {
-    pages++;
-    const result = await withSlackRetries(
-      () => client.users.list({
-        limit: 200,
-        ...cursor ? { cursor } : {}
-      }),
-      3,
-      { action: "users.list" }
-    );
-    const members = result.members ?? [];
-    totalScanned += members.length;
-    for (const member of members) {
-      if (!includeDeleted && member.deleted) continue;
-      if (!includeBots && member.is_bot) continue;
-      if (member.id === "USLACKBOT") continue;
-      const score = scoreMatch(member, queryLower);
-      if (score > 0) {
-        matches.push({ user: member, score });
-      }
-    }
-    const nextCursor = result.response_metadata?.next_cursor;
-    if (!nextCursor) {
-      break;
-    }
-    cursor = nextCursor;
-  }
-  if (pages >= maxPages && cursor) {
-    truncated = true;
-  }
-  matches.sort((a, b) => {
-    if (b.score !== a.score) return b.score - a.score;
-    return (a.user.name ?? "").localeCompare(b.user.name ?? "");
-  });
-  return {
-    users: matches.slice(0, limit).map((m) => normalizeUser(m.user)),
-    searched_pages: pages,
-    searched_user_count: totalScanned,
-    truncated
-  };
-}
-
-// src/chat/slack/tools/user-lookup.ts
+// src/chat/tools/user-lookup.ts
+import { and, eq, or, sql } from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
+import { z as z54 } from "zod";
+var linkedSlackIdentity = alias(juniorIdentities, "user_lookup_slack_identity");
 function explicitUserLookupError(error) {
-  if (error.apiError === "user_not_found") {
+  if (error.apiError === "user_not_found" || error.code === "not_found") {
     return "No Slack user found for the supplied user ID.";
   }
   if (error.code === "missing_scope") {
-    return error.needed ? `Slack user lookup is unavailable because this installation is missing the \`${error.needed}\` scope.` : "Slack user lookup is unavailable because this installation is missing a required Slack scope.";
-  }
-  if (error.code === "not_found") {
-    return "No Slack user found for the supplied user ID.";
+    return error.needed ? `User lookup is unavailable because this installation is missing the \`${error.needed}\` scope.` : "User lookup is unavailable because this installation is missing a required Slack scope.";
   }
   if (error.code === "invalid_arguments") {
     return `Slack rejected the user lookup arguments (${error.apiError ?? error.code}).`;
   }
   if (error.code === "feature_unavailable") {
-    return "Slack user lookup is not available for this workspace or app installation.";
+    return "User lookup is not available for this workspace or app installation.";
   }
   return void 0;
 }
 function slackMention(userId) {
   return `<@${userId}>`;
 }
-async function storeProfile(teamId, profile) {
-  await upsertIdentity(getSqlExecutor(), {
-    kind: profile.is_bot ? "service" : "user",
-    provider: "slack",
-    providerTenantId: teamId,
-    providerSubjectId: profile.id,
-    ...profile.real_name || profile.display_name ? { displayName: profile.real_name || profile.display_name } : {},
-    ...profile.name ? { handle: profile.name } : {},
-    ...profile.email ? { email: profile.email, emailVerified: true } : {}
-  });
+function asMatch(user) {
+  return { ...user, mention: slackMention(user.id) };
+}
+function lookupResult(args) {
+  const users = args.users.map(asMatch);
+  if (users.length === 1) {
+    return {
+      provider: args.provider,
+      query: args.query,
+      count: 1,
+      mention: users[0].mention,
+      user: users[0],
+      ...args.search
+    };
+  }
+  return {
+    provider: args.provider,
+    query: args.query,
+    count: users.length,
+    users,
+    ...args.search
+  };
+}
+function slackProfileFromIdentity(identity) {
+  return {
+    id: identity.providerSubjectId,
+    name: identity.handle ?? void 0,
+    real_name: identity.displayName ?? void 0,
+    display_name: identity.displayName ?? void 0,
+    email: identity.email ?? void 0,
+    is_bot: false,
+    is_deleted: false
+  };
+}
+function slackMentionProfileFromIdentity(identity) {
+  return {
+    id: identity.providerSubjectId,
+    name: identity.handle ?? void 0
+  };
 }
-async function storedUserByEmail(teamId, email) {
+async function storedSlackUserByEmail(teamId, email) {
   const emailNormalized = normalizeIdentityEmail(email);
   if (!emailNormalized) return void 0;
   const identities = await getSqlExecutor().db().select().from(juniorIdentities).where(
@@ -11836,94 +12216,86 @@ async function storedUserByEmail(teamId, email) {
       `Multiple Slack users share verified email ${emailNormalized} in workspace ${teamId}`
     );
   }
-  const identity = identities[0];
-  if (!identity) return void 0;
-  return {
-    id: identity.providerSubjectId,
-    ...identity.handle ? { name: identity.handle } : {},
-    ...identity.displayName ? { real_name: identity.displayName } : {},
-    ...identity.displayName ? { display_name: identity.displayName } : {},
-    ...identity.email ? { email: identity.email } : {},
-    is_bot: false,
-    is_deleted: false
-  };
+  return identities[0] ? slackProfileFromIdentity(identities[0]) : void 0;
+}
+function looksLikeEmail(query) {
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(query);
+}
+async function resolveSlack(teamId, query) {
+  const userId = parseSlackUserId(query);
+  if (userId) {
+    const user = await lookupSlackUserProfile(userId);
+    return lookupResult({ provider: "slack", query, users: [user] });
+  }
+  if (looksLikeEmail(query)) {
+    const stored = await storedSlackUserByEmail(teamId, query);
+    if (stored) {
+      return lookupResult({ provider: "slack", query, users: [stored] });
+    }
+    const profile = await lookupSlackUserByEmail(query);
+    if (!profile) {
+      throw new ToolInputError(
+        `No Slack user found with email address ${query}.`
+      );
+    }
+    return lookupResult({ provider: "slack", query, users: [profile] });
+  }
+  const result = await searchSlackUsers({
+    query,
+    limit: 10,
+    maxPages: 3,
+    includeBots: false
+  });
+  return lookupResult({
+    provider: "slack",
+    query,
+    users: result.users,
+    search: {
+      searched_pages: result.searched_pages,
+      searched_user_count: result.searched_user_count,
+      truncated: result.truncated
+    }
+  });
+}
+async function resolveStoredProvider(teamId, provider, query) {
+  const rows = await getSqlExecutor().db().select({ slack: linkedSlackIdentity }).from(juniorIdentities).innerJoin(
+    linkedSlackIdentity,
+    and(
+      eq(linkedSlackIdentity.userId, juniorIdentities.userId),
+      eq(linkedSlackIdentity.kind, "user"),
+      eq(linkedSlackIdentity.provider, "slack"),
+      eq(linkedSlackIdentity.providerTenantId, teamId)
+    )
+  ).where(
+    and(
+      eq(juniorIdentities.kind, "user"),
+      eq(juniorIdentities.provider, provider),
+      or(
+        eq(juniorIdentities.providerSubjectId, query),
+        sql`lower(${juniorIdentities.handle}) = lower(${query})`
+      )
+    )
+  ).limit(11);
+  const users = rows.slice(0, 10).map((row) => slackMentionProfileFromIdentity(row.slack));
+  return lookupResult({ provider, query, users });
 }
-function createSlackUserLookupTool(teamId) {
+function createUserLookupTool(teamId, providers) {
   return zodTool({
-    description: "Look up Slack user profiles by user ID, email, or name search. Returns Slack `mention` values (`<@U\u2026>`). Use a mention only when one person clearly matches; otherwise ask which person the user means.",
+    description: "Look up people by identity provider and query. Pass an enabled `provider` and its provider subject ID or handle. The `slack` provider also accepts email and name searches. Returns Slack `mention` values (`<@U\u2026>`) for the current workspace. Use a mention only when one person clearly matches; otherwise ask which person the user means.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z50.object({
-      mode: z50.enum(["user_id", "email", "query"]).describe(
-        "Lookup method: user_id for Slack IDs, email for email addresses, or query for name searches."
-      ),
-      value: z50.string().trim().min(2).describe(
-        "The Slack user ID, email address, or name to look up, interpreted according to mode."
-      )
+    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 ({ mode, value }) => {
+    execute: async ({ provider, query }) => {
       try {
-        if (mode === "user_id") {
-          const parsedUserId = parseRequiredSlackUserIdParam("value", value);
-          if (!parsedUserId.ok) {
-            throw new ToolInputError(parsedUserId.error);
-          }
-          const user = await lookupSlackUserProfile(parsedUserId.value);
-          await storeProfile(teamId, user);
-          return {
-            mode: "user_id",
-            mention: slackMention(user.id),
-            user
-          };
-        }
-        if (mode === "email") {
-          const stored = await storedUserByEmail(teamId, value);
-          if (stored) {
-            return {
-              mode: "email",
-              mention: slackMention(stored.id),
-              user: stored
-            };
-          }
-          const profile = await lookupSlackUserByEmail(value);
-          if (!profile) {
-            throw new ToolInputError(
-              `No Slack user found with email address ${value}.`
-            );
-          }
-          await storeProfile(teamId, profile);
-          return {
-            mode: "email",
-            mention: slackMention(profile.id),
-            user: profile
-          };
-        }
-        const result = await searchSlackUsers({
-          query: value,
-          limit: 10,
-          maxPages: 3,
-          includeBots: false
-        });
-        if (result.users.length === 1) {
-          await storeProfile(teamId, result.users[0]);
-        }
-        return {
-          mode: "query",
-          query: value,
-          count: result.users.length,
-          searched_pages: result.searched_pages,
-          searched_user_count: result.searched_user_count,
-          truncated: result.truncated,
-          users: result.users.map((user) => ({
-            ...user,
-            mention: slackMention(user.id)
-          }))
-        };
+        return provider === "slack" ? await resolveSlack(teamId, query) : await resolveStoredProvider(teamId, provider, query);
       } catch (error) {
         if (error instanceof SlackActionError) {
           const message = explicitUserLookupError(error);
@@ -11938,18 +12310,18 @@ function createSlackUserLookupTool(teamId) {
 }
 
 // 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({
@@ -12029,27 +12401,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({
@@ -12062,16 +12434,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) => {
@@ -12317,10 +12689,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
   });
@@ -12334,7 +12706,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,
@@ -12355,7 +12727,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";
@@ -12798,9 +13170,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 }) => {
@@ -12845,7 +13217,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;
@@ -12887,9 +13259,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 }) => {
@@ -12931,7 +13303,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: {
@@ -12942,9 +13314,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 () => {
@@ -12956,28 +13328,9 @@ function createWriteFileTool() {
 }
 
 // src/chat/tools/index.ts
-function createToolState(hooks, context) {
+function createToolState() {
   const operationResultCache = /* @__PURE__ */ new Map();
-  const artifactState = {
-    ...context.artifactState ?? {},
-    listColumnMap: {
-      ...context.artifactState?.listColumnMap ?? {}
-    }
-  };
-  const patchArtifactState = async (patch) => {
-    Object.assign(artifactState, patch);
-    if (patch.listColumnMap) {
-      artifactState.listColumnMap = {
-        ...artifactState.listColumnMap ?? {},
-        ...patch.listColumnMap
-      };
-    }
-    await hooks.onArtifactStatePatch?.(patch);
-  };
   return {
-    artifactState,
-    patchArtifactState,
-    getCurrentListId: () => artifactState.lastListId,
     getOperationResult: (operationKey) => operationResultCache.get(operationKey),
     setOperationResult: (operationKey, result) => {
       operationResultCache.set(operationKey, result);
@@ -12985,7 +13338,7 @@ function createToolState(hooks, context) {
   };
 }
 function createTools(availableSkills, hooks = {}, context, options = {}) {
-  const state = createToolState(hooks, context);
+  const state = createToolState();
   const slackContext = getSlackToolContext(context);
   const slackSourceCapabilities = slackContext ? resolveChannelCapabilities(slackContext.sourceChannelId) : void 0;
   const canSendFilesToActiveConversation = Boolean(
@@ -13055,6 +13408,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(
         {
@@ -13065,15 +13419,22 @@ 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
       );
     }
-    tools.slackUserLookup = createSlackUserLookupTool(slackContext.teamId);
+    const identityProviders = [
+      "slack",
+      ...getOAuthAccountProviders().filter((provider) => provider !== "slack")
+    ];
+    tools.userLookup = createUserLookupTool(
+      slackContext.teamId,
+      identityProviders
+    );
     tools.slackListCreate = createSlackListCreateTool(state);
     tools.slackListAddItems = createSlackListAddItemsTool(state);
-    tools.slackListGetItems = createSlackListGetItemsTool(state);
+    tools.slackListGetItems = createSlackListGetItemsTool();
     tools.slackListUpdateItem = createSlackListUpdateItemTool(state);
     const outputChannelId = slackContext.destinationChannelId;
     const outputCapabilities = outputChannelId ? resolveChannelCapabilities(outputChannelId) : void 0;
@@ -13093,9 +13454,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,
@@ -13654,7 +14013,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({
@@ -13666,11 +14025,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(),
@@ -13710,7 +14069,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;
@@ -13755,29 +14114,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) ?? [];
@@ -13988,14 +14347,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) => ({
@@ -14327,7 +14686,6 @@ function createMcpAuthOrchestration(input) {
       ...input.threadTs ? { threadTs: input.threadTs } : {},
       ...input.toolChannelId ? { toolChannelId: input.toolChannelId } : {},
       configuration: input.getConfiguration(),
-      artifactState: input.getArtifactState(),
       createAuthorizationState: input.authorization?.createState
     });
     authSessionIdsByProvider.set(plugin.manifest.name, provider.authSessionId);
@@ -14365,11 +14723,9 @@ function createMcpAuthOrchestration(input) {
     });
     const reusedAuthSessionId = reusingPendingLink && input.pendingAuth?.kind === "mcp" ? input.pendingAuth.authSessionId : void 0;
     const activeAuthSessionId = reusedAuthSessionId ?? authSessionId;
-    const latestArtifactState = input.getMergedArtifactState();
     await patchMcpAuthSession(activeAuthSessionId, {
       configuration: { ...input.getConfiguration() },
-      artifactState: latestArtifactState,
-      toolChannelId: input.toolChannelId ?? latestArtifactState.assistantContextChannelId ?? input.channelId
+      toolChannelId: input.toolChannelId ?? input.channelId
     });
     const providerLabel = formatProviderLabel(provider);
     const nextPendingAuth = {
@@ -15240,7 +15596,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.
@@ -15308,17 +15664,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.`
@@ -15346,6 +15702,7 @@ function createGuardianActionReviewer(options) {
         maxTokens: GUARDIAN_REVIEW_MAX_TOKENS,
         recordTelemetryPayloads: false,
         temperature: 0,
+        promptName: "junior.guardian_action_review",
         signal,
         metadata: {
           conversationId: proposal.context.conversationId,
@@ -15562,6 +15919,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;
@@ -15578,7 +15967,7 @@ async function wireAgentTools(args) {
     egressSignals: args.policy.sandboxEgressSignals,
     credentialEgress: args.routing.credentialContext,
     actor: args.currentActor,
-    channelConfiguration: args.policy.channelConfiguration,
+    locationConfiguration: args.policy.locationConfiguration,
     configurationValues: args.configurationValues,
     getActiveSkill: () => args.skillSandbox.getActiveSkill(),
     prepareSandbox: pluginHooks.prepareSandbox,
@@ -15600,11 +15989,6 @@ async function wireAgentTools(args) {
     userMessage: args.userInput,
     pendingAuth: args.state.pendingAuth,
     getConfiguration: () => args.configurationValues,
-    getArtifactState: () => args.state.artifactState,
-    getMergedArtifactState: () => mergeArtifactsState(
-      args.state.artifactState ?? {},
-      args.artifactStatePatch
-    ),
     recordPendingAuth: args.durability.recordPendingAuth,
     interactiveAuthEnabled: !isAgentRunFeatureDisabled(
       args.policy,
@@ -15617,6 +16001,7 @@ async function wireAgentTools(args) {
     conversationId: args.conversationId,
     sessionId: args.turnId,
     actorId: credentialUserId,
+    actor: args.currentActor,
     channelId: slackChannelId,
     destination: args.routing.destination,
     source: runSource,
@@ -15654,7 +16039,6 @@ async function wireAgentTools(args) {
   const commonToolRuntimeContext = {
     conversationId: args.conversationId,
     userText: args.userInput,
-    artifactState: args.state.artifactState,
     configuration: args.configurationValues,
     egress: createPluginEgress({
       credentialContext: args.routing.credentialContext,
@@ -15683,36 +16067,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())
@@ -15742,15 +16110,6 @@ async function wireAgentTools(args) {
         args.generatedFiles.push(...files);
         return refs;
       },
-      onArtifactStatePatch: async (patch) => {
-        Object.assign(args.artifactStatePatch, patch);
-        await args.durability.onArtifactStateUpdated?.(
-          mergeArtifactsState(
-            args.state.artifactState ?? {},
-            args.artifactStatePatch
-          )
-        );
-      },
       toolOverrides: args.policy.toolOverrides,
       onSkillLoaded: async (loadedSkill) => {
         const resolvedSkill = await args.skillSandbox.loadSkill(
@@ -15927,6 +16286,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
@@ -16329,6 +16689,7 @@ async function summarizeContext(args, deps) {
     messageAttributeMode: "metadata",
     temperature: 0,
     signal: args.signal,
+    promptName: "junior.context_compaction",
     messages: [
       {
         role: "user",
@@ -16734,6 +17095,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,
@@ -16772,7 +17139,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
@@ -16829,6 +17196,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,
@@ -16851,7 +17219,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         });
       }
     };
-    const persistedConfigurationValues = policy.channelConfiguration ? await policy.channelConfiguration.resolveValues() : {};
+    const persistedConfigurationValues = policy.locationConfiguration ? await policy.locationConfiguration.resolveValues() : {};
     const configurationValues = {
       ...getConfigDefaults(),
       ...policy.configuration ?? {},
@@ -16946,6 +17314,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         turnId,
         modelProfile: routedModelProfile,
         modelId: routedModelId,
+        ...turnRoute.costUsd !== void 0 ? { costUsd: turnRoute.costUsd } : {},
         reasoningLevel: turnRoute.reasoningLevel,
         ...turnRoute.confidence !== void 0 ? { confidence: turnRoute.confidence } : {},
         source: turnRoute.source ?? "configured"
@@ -16953,10 +17322,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     }
     activeModelProfile = routedModelProfile;
     activeModelId = routedModelId;
-    const generatedFiles = [];
-    const artifactStatePatch = {};
-    const toolCalls = [];
-    let agent;
     let pendingPiHookError;
     let pendingHandoff;
     const currentAgentMessages = () => agent ? [...agent.state.messages] : [];
@@ -17060,7 +17425,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       currentAgentMessages,
       currentTurnMessages,
       currentUserIntent,
-      artifactStatePatch,
       availableSkills,
       configurationValues,
       connectedMcpProviders,
@@ -17096,6 +17460,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 {
@@ -17149,7 +17514,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     } = await assemblePrompt({
       activeMcpCatalogs: wiring.activeMcpCatalogs,
       currentActor: actor,
-      artifactState: state.artifactState,
       availableSkills,
       configurationValues,
       contextContentParts: [
@@ -17278,6 +17642,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       }
       try {
         await delivery(message);
+        acceptedToolFreeAssistant = true;
       } catch (error) {
         assistantMessageDeliveryError = new AssistantMessageDeliveryError(
           error
@@ -17359,13 +17724,13 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         return void 0;
       },
       afterToolCall: async ({ result: result2, toolCall }, signal2) => {
-        const deadlineResult = runResume.timedOut && signal2?.aborted ? annotateTurnDeadlineToolResult(result2) : void 0;
-        const sourceResult = deadlineResult ?? result2;
+        const timedOutResult = runResume.timedOut && signal2?.aborted ? projectTimedOutToolResult(result2) : void 0;
+        const sourceResult = timedOutResult ?? result2;
         const projectedResult = wiring.projectActionReviewResult(
           toolCall.id,
           sourceResult
         );
-        return deadlineResult || projectedResult !== result2 ? projectedResult : void 0;
+        return timedOutResult || projectedResult !== result2 ? projectedResult : void 0;
       },
       prepareNextTurnWithContext: async (nextTurn, hookSignal) => {
         try {
@@ -17735,7 +18100,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     const result = buildTurnResult({
       newMessages,
       userInput,
-      artifactStatePatch,
       toolCalls,
       sandboxRef: wiring.getSandboxRef(),
       piMessages: [...agent.state.messages],
@@ -17762,6 +18126,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,